@aztec/aztec.js 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/src/wallet/account_entrypoint_meta_payment_method.ts

@@ -0,0 +1,105 @@
+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 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
+ * It works by rerouting the provided fee payment method through the account's entrypoint,
+ * which sets itself as fee payer. If no payment method is provided, it is assumed the
+ * account will pay with its own fee juice balance.
+ *
+ * Usually, in order to pay fees it is necessary to obtain an ExecutionPayload that encodes the necessary information
+ * that is sent to the user's account entrypoint, that has plumbing to handle it.
+ * If there's no account contract yet (it's being deployed) a MultiCallContract is used, which doesn't have a concept of fees or
+ * how to handle this payload.
+ * HOWEVER, the account contract's entrypoint does, so this method reshapes that fee payload into a call to the account contract entrypoint
+ * being deployed with the original fee payload.
+ *
+ * This class can be seen in action in DeployAccountMethod.ts#getSelfPaymentMethod
+ */
+export class AccountEntrypointMetaPaymentMethod implements FeePaymentMethod {
+  constructor(
+    private wallet: Wallet,
+    private artifact: ContractArtifact,
+    private feePaymentNameOrArtifact: string | FunctionArtifact,
+    private accountAddress: AztecAddress,
+    private paymentMethod?: FeePaymentMethod,
+  ) {}
+
+  getAsset(): Promise<AztecAddress> {
+    return this.paymentMethod?.getAsset() ?? Promise.resolve(ProtocolContractAddress.FeeJuice);
+  }
+
+  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 entrypoint args
+    const args = [feeEncodedCalls, accountFeePaymentMethodOptions, false];
+    const feePaymentArtifact =
+      typeof this.feePaymentNameOrArtifact === 'string'
+        ? getFunctionArtifactByName(this.artifact, this.feePaymentNameOrArtifact)
+        : this.feePaymentNameOrArtifact;
+
+    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,
+    );
+
+    // Compute the authwitness required to verify the combined payload
+    const payloadAuthWitness = await this.wallet.createAuthWit(this.accountAddress, await feeEncodedCalls.hash());
+
+    return new ExecutionPayload(
+      [entrypointCall],
+      [payloadAuthWitness, ...feeAuthwitnesses],
+      [],
+      feeEncodedCalls.hashedArguments,
+    );
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.accountAddress);
+  }
+
+  getGasSettings(): GasSettings | undefined {
+    return this.paymentMethod?.getGasSettings();
+  }
+}

package/src/wallet/account_manager.ts

@@ -0,0 +1,154 @@
+import { Fr } from '@aztec/foundation/fields';
+import {
+  CompleteAddress,
+  type ContractInstanceWithAddress,
+  getContractInstanceFromInstantiationParams,
+} from '@aztec/stdlib/contract';
+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';
+
+/**
+ * Manages a user account. Provides methods for calculating the account's address and other related data,
+ * plus a helper to return a preconfigured deploy method.
+ */
+export class AccountManager {
+  private constructor(
+    private wallet: Wallet,
+    private secretKey: Fr,
+    private accountContract: AccountContract,
+    private instance: ContractInstanceWithAddress,
+    /**
+     * Contract instantiation salt for the account contract
+     */
+    public readonly salt: Salt,
+  ) {}
+
+  static async create(wallet: Wallet, secretKey: Fr, accountContract: AccountContract, salt?: Salt) {
+    const { publicKeys } = await deriveKeys(secretKey);
+    salt = salt !== undefined ? new Fr(salt) : Fr.random();
+
+    const { constructorName, constructorArgs } = (await accountContract.getInitializationFunctionAndArgs()) ?? {
+      constructorName: undefined,
+      constructorArgs: undefined,
+    };
+
+    const artifact = await accountContract.getContractArtifact();
+    const instance = await getContractInstanceFromInstantiationParams(artifact, {
+      constructorArtifact: constructorName,
+      constructorArgs,
+      salt: salt,
+      publicKeys,
+    });
+
+    return new AccountManager(wallet, 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 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.
+   * @returns The address, partial address, and encryption public key.
+   */
+  public getCompleteAddress(): Promise<CompleteAddress> {
+    return CompleteAddress.fromSecretKeyAndInstance(this.secretKey, this.instance);
+  }
+
+  /**
+   * Returns the secret key used to derive the rest of the privacy keys for this contract
+   */
+  public getSecretKey() {
+    return this.secretKey;
+  }
+
+  get address() {
+    return this.instance.address;
+  }
+
+  /**
+   * Returns the contract instance definition associated with this account.
+   * Does not require the account to have been published for public execution.
+   * @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 getAccount(): Promise<AccountWithSecretKey> {
+    const accountInterface = await this.getAccountInterface();
+    return new AccountWithSecretKey(accountInterface, this.secretKey, this.salt);
+  }
+
+  /**
+   * Returns the account contract that backs this account.
+   * @returns The account contract
+   */
+  getAccountContract(): AccountContract {
+    return this.accountContract;
+  }
+
+  /**
+   * Returns a preconfigured deploy method that contains all the necessary function
+   * calls to deploy the account contract.
+   */
+  public async getDeployMethod(): Promise<DeployAccountMethod> {
+    const artifact = await this.accountContract.getContractArtifact();
+
+    if (!(await this.hasInitializer())) {
+      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/15576):
+      // there should be a path which enables an account contract's class & instance to be published,
+      // even if the account contract doesn't have an initializer function. This should not throw.
+      throw new Error(`Account contract ${artifact.name} does not have an initializer function to call.`);
+    }
+
+    const { constructorName, constructorArgs } = (await this.accountContract.getInitializationFunctionAndArgs()) ?? {
+      constructorName: undefined,
+      constructorArgs: undefined,
+    };
+
+    return new DeployAccountMethod(
+      this.getPublicKeys(),
+      this.wallet,
+      artifact,
+      address => Contract.at(address, artifact, this.wallet),
+      new Fr(this.salt),
+      constructorArgs,
+      constructorName,
+    );
+  }
+
+  /**
+   * Returns whether this account contract has an initializer function.
+   */
+  public async hasInitializer() {
+    return (await this.accountContract.getInitializationFunctionAndArgs()) !== undefined;
+  }
+}

package/src/wallet/base_wallet.ts

@@ -1,105 +1,322 @@
-import type { FeeOptions, TxExecutionOptions } from '@aztec/entrypoints/interfaces';
-import type { ExecutionPayload } from '@aztec/entrypoints/payload';
-import type { Fr } from '@aztec/foundation/fields';
-import type { ContractArtifact } from '@aztec/stdlib/abi';
+import {
+  GAS_ESTIMATION_DA_GAS_LIMIT,
+  GAS_ESTIMATION_L2_GAS_LIMIT,
+  GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT,
+  GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT,
+} from '@aztec/constants';
+import { AccountFeePaymentMethodOptions, type DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import type { ContractArtifact, EventMetadataDefinition } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { CompleteAddress, ContractInstanceWithAddress, NodeInfo } from '@aztec/stdlib/contract';
-import type { GasFees } from '@aztec/stdlib/gas';
+import {
+  type ContractClassMetadata,
+  type ContractInstanceWithAddress,
+  type ContractInstantiationData,
+  type ContractMetadata,
+  computePartialAddress,
+  getContractClassFromArtifact,
+  getContractInstanceFromInstantiationParams,
+} from '@aztec/stdlib/contract';
+import { SimulationError } from '@aztec/stdlib/errors';
+import { Gas, GasSettings } from '@aztec/stdlib/gas';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type {
-  ContractClassMetadata,
-  ContractMetadata,
-  EventMetadataDefinition,
-  PXE,
-  PXEInfo,
-} from '@aztec/stdlib/interfaces/client';
-import type {
-  PrivateExecutionResult,
-  SimulationOverrides,
-  Tx,
   TxExecutionRequest,
   TxHash,
   TxProfileResult,
-  TxProvingResult,
   TxReceipt,
   TxSimulationResult,
   UtilitySimulationResult,
 } from '@aztec/stdlib/tx';
 
-import type { IntentAction, IntentInnerHash } from '../utils/authwit.js';
-import type { Wallet } from './wallet.js';
+import { inspect } from 'util';
+
+import type { Account } from '../account/account.js';
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
+import type {
+  Aliased,
+  BatchResults,
+  BatchableMethods,
+  BatchedMethod,
+  ContractInstanceAndArtifact,
+  ProfileOptions,
+  SendOptions,
+  SimulateOptions,
+  UserFeeOptions,
+  Wallet,
+} from './wallet.js';
+
+/**
+ * Options to configure fee payment for a transaction
+ */
+export type FeeOptions = {
+  /**
+   * A wallet-provided fallback fee payment method that is used only if the transaction that is being constructed
+   * doesn't already include one
+   */
+  walletFeePaymentMethod?: FeePaymentMethod;
+  /** Configuration options for the account to properly handle the selected fee payment method */
+  accountFeePaymentMethodOptions: AccountFeePaymentMethodOptions;
+  /** The gas settings to use for the transaction */
+  gasSettings: GasSettings;
+};
 
 /**
  * A base class for Wallet implementations
  */
 export abstract class BaseWallet implements Wallet {
-  constructor(protected readonly pxe: PXE) {}
+  protected log = createLogger('aztecjs:base_wallet');
 
-  abstract getCompleteAddress(): CompleteAddress;
+  protected baseFeePadding = 0.5;
+  protected cancellableTransactions = false;
 
-  abstract getChainId(): Fr;
+  // Protected because we want to force wallets to instantiate their own PXE.
+  protected constructor(
+    // TODO: We cannot type here pxe because we cannot import that package as that would result in a circular
+    // dependency. This will eventually get resolved by the introduction of @aztec/wallet-sdk package.
+    protected readonly pxe: any,
+    protected readonly aztecNode: AztecNode,
+  ) {}
 
-  abstract getVersion(): Fr;
+  protected abstract getAccountFromAddress(address: AztecAddress): Promise<Account>;
 
-  abstract createTxExecutionRequest(
-    exec: ExecutionPayload,
-    fee: FeeOptions,
-    options: TxExecutionOptions,
-  ): Promise<TxExecutionRequest>;
+  abstract getAccounts(): Promise<Aliased<AztecAddress>[]>;
 
-  abstract createAuthWit(intent: Fr | Buffer | IntentInnerHash | IntentAction): Promise<AuthWitness>;
+  /**
+   * Returns the list of aliased contacts associated with the wallet.
+   * This base implementation directly returns PXE's senders, but note that in general contacts are a superset of senders.
+   *  - Senders: Addresses we check during synching in case they sent us notes,
+   *  - Contacts: more general concept akin to a phone's contact list.
+   * @returns The aliased collection of AztecAddresses that form this wallet's address book
+   */
+  async getAddressBook(): Promise<Aliased<AztecAddress>[]> {
+    const senders: AztecAddress[] = await this.pxe.getSenders();
+    return senders.map(sender => ({ item: sender, alias: '' }));
+  }
 
-  getAddress() {
-    return this.getCompleteAddress().address;
+  async getChainInfo(): Promise<ChainInfo> {
+    const { l1ChainId, rollupVersion } = await this.aztecNode.getNodeInfo();
+    return { chainId: new Fr(l1ChainId), version: new Fr(rollupVersion) };
   }
 
-  registerSender(address: AztecAddress): Promise<AztecAddress> {
-    return this.pxe.registerSender(address);
+  protected async createTxExecutionRequestFromPayloadAndFee(
+    executionPayload: ExecutionPayload,
+    from: AztecAddress,
+    feeOptions: FeeOptions,
+  ): Promise<TxExecutionRequest> {
+    const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+    const executionOptions: DefaultAccountEntrypointOptions = {
+      txNonce: Fr.random(),
+      cancellable: this.cancellableTransactions,
+      feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions,
+    };
+    const finalExecutionPayload = feeExecutionPayload
+      ? mergeExecutionPayloads([feeExecutionPayload, executionPayload])
+      : executionPayload;
+    const fromAccount = await this.getAccountFromAddress(from);
+    return fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, executionOptions);
   }
-  getSenders(): Promise<AztecAddress[]> {
-    return this.pxe.getSenders();
+
+  public async createAuthWit(
+    from: AztecAddress,
+    messageHashOrIntent: Fr | Buffer | IntentInnerHash | CallIntent,
+  ): Promise<AuthWitness> {
+    const account = await this.getAccountFromAddress(from);
+    return account.createAuthWit(messageHashOrIntent);
   }
-  async removeSender(address: AztecAddress): Promise<void> {
-    await this.pxe.removeSender(address);
+
+  public async batch<const T extends readonly BatchedMethod<keyof BatchableMethods>[]>(
+    methods: T,
+  ): Promise<BatchResults<T>> {
+    const results: any[] = [];
+    for (const method of methods) {
+      const { name, args } = method;
+      // Type safety is guaranteed by the BatchedMethod type, which ensures that:
+      // 1. `name` is a valid batchable method name
+      // 2. `args` matches the parameter types of that specific method
+      // 3. The return type is correctly mapped in BatchResults<T>
+      // We use dynamic dispatch here for simplicity, but the types are enforced at the call site.
+
+      const fn = this[name] as (...args: any[]) => Promise<any>;
+      const result = await fn.apply(this, args);
+      // Wrap result with method name for discriminated union deserialization
+      results.push({ name, result });
+    }
+    return results as BatchResults<T>;
   }
-  registerContract(contract: {
-    /** Instance */ instance: ContractInstanceWithAddress;
-    /** Associated artifact */ artifact?: ContractArtifact;
-  }): Promise<void> {
-    return this.pxe.registerContract(contract);
+
+  /**
+   * Returns default values for the transaction fee options
+   * if they were omitted by the user.
+   * @param from - The address where the transaction is being sent from
+   * @param userFeeOptions - User-provided fee options, which might be incomplete
+   * @returns - Populated fee options that can be used to create a transaction execution request
+   */
+  protected async getDefaultFeeOptions(from: AztecAddress, userFeeOptions?: UserFeeOptions): Promise<FeeOptions> {
+    const maxFeesPerGas =
+      userFeeOptions?.gasSettings?.maxFeesPerGas ??
+      (await this.aztecNode.getCurrentBaseFees()).mul(1 + this.baseFeePadding);
+    let accountFeePaymentMethodOptions;
+    // The transaction does not include a fee payment method, so we set the flag
+    // for the account to use its fee juice balance
+    if (!userFeeOptions?.embeddedPaymentMethodFeePayer) {
+      accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE;
+    } else {
+      // The transaction includes fee payment method, so we check if we are the fee payer for it
+      // (this can only happen if the embedded payment method is FeeJuiceWithClaim)
+      accountFeePaymentMethodOptions = from.equals(userFeeOptions.embeddedPaymentMethodFeePayer)
+        ? AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM
+        : AccountFeePaymentMethodOptions.EXTERNAL;
+    }
+    const gasSettings: GasSettings = GasSettings.default({ ...userFeeOptions?.gasSettings, maxFeesPerGas });
+    this.log.debug(`Using L2 gas settings`, gasSettings);
+    return {
+      gasSettings,
+      walletFeePaymentMethod: undefined,
+      accountFeePaymentMethodOptions,
+    };
   }
-  registerContractClass(artifact: ContractArtifact): Promise<void> {
-    return this.pxe.registerContractClass(artifact);
+
+  /**
+   * Returns unreasonably high gas limits in order to execute a simulation
+   * with the goal of estimating its gas cost. It will otherwise try to respect
+   * the user-specified fee options, filling the gaps with default values as needed.
+   * @param from - The address where the transaction is being sent from
+   * @param userFeeOptions - User-provided fee options to use as a basis for the fully populated `FeeOptions` type.
+   */
+  protected async getFeeOptionsForGasEstimation(from: AztecAddress, userFeeOptions?: UserFeeOptions) {
+    const defaultFeeOptions = await this.getDefaultFeeOptions(from, userFeeOptions);
+    const {
+      gasSettings: { maxFeesPerGas, maxPriorityFeesPerGas },
+    } = defaultFeeOptions;
+    // Use unrealistically high gas limits for estimation to avoid running out of gas.
+    // They will be tuned down after the simulation.
+    const gasSettingsForEstimation = new GasSettings(
+      new Gas(GAS_ESTIMATION_DA_GAS_LIMIT, GAS_ESTIMATION_L2_GAS_LIMIT),
+      new Gas(GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT),
+      maxFeesPerGas,
+      maxPriorityFeesPerGas,
+    );
+    return {
+      ...defaultFeeOptions,
+      gasSettings: gasSettingsForEstimation,
+    };
   }
-  updateContract(contractAddress: AztecAddress, artifact: ContractArtifact): Promise<void> {
-    return this.pxe.updateContract(contractAddress, artifact);
+
+  registerSender(address: AztecAddress, _alias: string = ''): Promise<AztecAddress> {
+    return this.pxe.registerSender(address);
   }
-  proveTx(txRequest: TxExecutionRequest, privateExecutionResult: PrivateExecutionResult): Promise<TxProvingResult> {
-    return this.pxe.proveTx(txRequest, privateExecutionResult);
+
+  async registerContract(
+    instanceData: AztecAddress | ContractInstanceWithAddress | ContractInstantiationData | ContractInstanceAndArtifact,
+    artifact?: ContractArtifact,
+    secretKey?: Fr,
+  ): Promise<ContractInstanceWithAddress> {
+    /** Determines if the provided instance data is already a contract instance with an address. */
+    function isInstanceWithAddress(instanceData: any): instanceData is ContractInstanceWithAddress {
+      return (instanceData as ContractInstanceWithAddress).address !== undefined;
+    }
+    /** Determines if the provided instance data is contract instantiation data */
+    function isContractInstantiationData(instanceData: any): instanceData is ContractInstantiationData {
+      return (instanceData as ContractInstantiationData).salt !== undefined;
+    }
+    /** Determines if the provided instance data is already a contract */
+    function isContractInstanceAndArtifact(instanceData: any): instanceData is ContractInstanceAndArtifact {
+      return (
+        (instanceData as ContractInstanceAndArtifact).instance !== undefined &&
+        (instanceData as ContractInstanceAndArtifact).artifact !== undefined
+      );
+    }
+    let instance: ContractInstanceWithAddress;
+    if (isContractInstanceAndArtifact(instanceData)) {
+      instance = instanceData.instance;
+      await this.pxe.registerContract(instanceData);
+    } else if (isInstanceWithAddress(instanceData)) {
+      instance = instanceData;
+      await this.pxe.registerContract({ artifact, instance });
+    } else if (isContractInstantiationData(instanceData)) {
+      if (!artifact) {
+        throw new Error(`Contract artifact must be provided when registering a contract using instantiation data`);
+      }
+      instance = await getContractInstanceFromInstantiationParams(artifact, instanceData);
+      await this.pxe.registerContract({ artifact, instance });
+    } else {
+      if (!artifact) {
+        throw new Error(`Contract artifact must be provided when registering a contract using an address`);
+      }
+      const { contractInstance: maybeContractInstance } = await this.pxe.getContractMetadata(instanceData);
+      if (!maybeContractInstance) {
+        throw new Error(`Contract instance at ${instanceData.toString()} has not been registered in the wallet's PXE`);
+      }
+      instance = maybeContractInstance;
+      const thisContractClass = await getContractClassFromArtifact(artifact);
+      if (!thisContractClass.id.equals(instance.currentContractClassId)) {
+        // wallet holds an outdated version of this contract
+        await this.pxe.updateContract(instance.address, artifact);
+        instance.currentContractClassId = thisContractClass.id;
+      }
+    }
+    if (secretKey) {
+      await this.pxe.registerAccount(secretKey, await computePartialAddress(instance));
+    }
+    return instance;
   }
-  profileTx(
-    txRequest: TxExecutionRequest,
-    profileMode: 'gates' | 'execution-steps' | 'full',
-    skipProofGeneration?: boolean,
-    msgSender?: AztecAddress,
-  ): Promise<TxProfileResult> {
-    return this.pxe.profileTx(txRequest, profileMode, skipProofGeneration, msgSender);
+
+  async simulateTx(executionPayload: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult> {
+    const feeOptions = opts.fee?.estimateGas
+      ? await this.getFeeOptionsForGasEstimation(opts.from, opts.fee)
+      : await this.getDefaultFeeOptions(opts.from, opts.fee);
+    const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, feeOptions);
+    return this.pxe.simulateTx(
+      txRequest,
+      true /* simulatePublic */,
+      opts?.skipTxValidation,
+      opts?.skipFeeEnforcement ?? true,
+    );
   }
-  simulateTx(
-    txRequest: TxExecutionRequest,
-    simulatePublic: boolean,
-    skipTxValidation?: boolean,
-    skipFeeEnforcement?: boolean,
-    overrides?: SimulationOverrides,
-  ): Promise<TxSimulationResult> {
-    return this.pxe.simulateTx(txRequest, simulatePublic, skipTxValidation, skipFeeEnforcement, overrides);
+
+  async profileTx(executionPayload: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult> {
+    const fee = await this.getDefaultFeeOptions(opts.from, opts.fee);
+    const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, fee);
+    return this.pxe.profileTx(txRequest, opts.profileMode, opts.skipProofGeneration ?? true);
   }
-  sendTx(tx: Tx): Promise<TxHash> {
-    return this.pxe.sendTx(tx);
+
+  async sendTx(executionPayload: ExecutionPayload, opts: SendOptions): Promise<TxHash> {
+    const fee = await this.getDefaultFeeOptions(opts.from, opts.fee);
+    const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(executionPayload, opts.from, fee);
+    const provenTx = await this.pxe.proveTx(txRequest);
+    const tx = await provenTx.toTx();
+    const txHash = tx.getTxHash();
+    if (await this.aztecNode.getTxEffect(txHash)) {
+      throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
+    }
+    this.log.debug(`Sending transaction ${txHash}`);
+    await this.aztecNode.sendTx(tx).catch(err => {
+      throw this.contextualizeError(err, inspect(tx));
+    });
+    this.log.info(`Sent transaction ${txHash}`);
+    return txHash;
   }
-  getCurrentBaseFees(): Promise<GasFees> {
-    return this.pxe.getCurrentBaseFees();
+
+  protected contextualizeError(err: Error, ...context: string[]): Error {
+    let contextStr = '';
+    if (context.length > 0) {
+      contextStr = `\nContext:\n${context.join('\n')}`;
+    }
+    if (err instanceof SimulationError) {
+      err.setAztecContext(contextStr);
+    } else {
+      this.log.error(err.name, err);
+      this.log.debug(contextStr);
+    }
+    return err;
   }
+
   simulateUtility(
     functionName: string,
     args: any[],
@@ -109,12 +326,7 @@ export abstract class BaseWallet implements Wallet {
   ): Promise<UtilitySimulationResult> {
     return this.pxe.simulateUtility(functionName, args, to, authwits, from);
   }
-  getNodeInfo(): Promise<NodeInfo> {
-    return this.pxe.getNodeInfo();
-  }
-  getPXEInfo(): Promise<PXEInfo> {
-    return this.pxe.getPXEInfo();
-  }
+
   getContractClassMetadata(id: Fr, includeArtifact: boolean = false): Promise<ContractClassMetadata> {
     return this.pxe.getContractClassMetadata(id, includeArtifact);
   }
@@ -123,7 +335,7 @@ export abstract class BaseWallet implements Wallet {
   }
 
   getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
-    return this.pxe.getTxReceipt(txHash);
+    return this.aztecNode.getTxReceipt(txHash);
   }
 
   getPrivateEvents<T>(
@@ -131,11 +343,8 @@ export abstract class BaseWallet implements Wallet {
     event: EventMetadataDefinition,
     from: number,
     limit: number,
-    recipients: AztecAddress[] = [this.getCompleteAddress().address],
+    recipients: AztecAddress[] = [],
   ): Promise<T[]> {
     return this.pxe.getPrivateEvents(contractAddress, event, from, limit, recipients);
   }
-  getPublicEvents<T>(event: EventMetadataDefinition, from: number, limit: number): Promise<T[]> {
-    return this.pxe.getPublicEvents(event, from, limit);
-  }
 }