@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.b655e406

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,198 +1,350 @@
-import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
-import type { Fr, Point } from '@aztec/foundation/fields';
-import type { SiblingPath } from '@aztec/foundation/trees';
-import type { AbiDecoded, 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 { L2Block } from '@aztec/stdlib/block';
-import type { CompleteAddress, ContractInstanceWithAddress, NodeInfo, PartialAddress } 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,
-  GetContractClassLogsResponse,
-  GetPublicLogsResponse,
-  PXE,
-  PXEInfo,
-} from '@aztec/stdlib/interfaces/client';
-import type { LogFilter } from '@aztec/stdlib/logs';
-import type { NotesFilter, UniqueNote } from '@aztec/stdlib/note';
-import type {
-  PrivateExecutionResult,
-  Tx,
   TxExecutionRequest,
   TxHash,
-  TxProvingResult,
+  TxProfileResult,
   TxReceipt,
   TxSimulationResult,
+  UtilitySimulationResult,
 } from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/wallet.js';
-import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
-import type { IntentAction, IntentInnerHash } from '../utils/authwit.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, private scopes?: AztecAddress[]) {}
-
-  abstract isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean>;
+  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: ExecutionRequestInit): 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: '' }));
+  }
 
-  setScopes(scopes: AztecAddress[]) {
-    this.scopes = scopes;
+  async getChainInfo(): Promise<ChainInfo> {
+    const { l1ChainId, rollupVersion } = await this.aztecNode.getNodeInfo();
+    return { chainId: new Fr(l1ChainId), version: new Fr(rollupVersion) };
   }
 
-  getScopes() {
-    return this.scopes;
+  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);
   }
 
-  getAddress() {
-    return this.getCompleteAddress().address;
+  public async createAuthWit(
+    from: AztecAddress,
+    messageHashOrIntent: Fr | Buffer | IntentInnerHash | CallIntent,
+  ): Promise<AuthWitness> {
+    const account = await this.getAccountFromAddress(from);
+    return account.createAuthWit(messageHashOrIntent);
   }
-  storeCapsule(contract: AztecAddress, storageSlot: Fr, capsule: Fr[]): Promise<void> {
-    return this.pxe.storeCapsule(contract, storageSlot, capsule);
+
+  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>;
   }
-  registerAccount(secretKey: Fr, partialAddress: PartialAddress): Promise<CompleteAddress> {
-    return this.pxe.registerAccount(secretKey, partialAddress);
+
+  /**
+   * 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,
+    };
   }
-  getRegisteredAccounts(): Promise<CompleteAddress[]> {
-    return this.pxe.getRegisteredAccounts();
+
+  /**
+   * 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,
+    };
   }
-  registerSender(address: AztecAddress): Promise<AztecAddress> {
+
+  registerSender(address: AztecAddress, _alias: string = ''): Promise<AztecAddress> {
     return this.pxe.registerSender(address);
   }
-  getSenders(): Promise<AztecAddress[]> {
-    return this.pxe.getSenders();
-  }
-  async removeSender(address: AztecAddress): Promise<void> {
-    await this.pxe.removeSender(address);
-  }
-  registerContract(contract: {
-    /** Instance */ instance: ContractInstanceWithAddress;
-    /** Associated artifact */ artifact?: ContractArtifact;
-  }): Promise<void> {
-    return this.pxe.registerContract(contract);
-  }
-  registerContractClass(artifact: ContractArtifact): Promise<void> {
-    return this.pxe.registerContractClass(artifact);
-  }
-  updateContract(contractAddress: AztecAddress, artifact: ContractArtifact): Promise<void> {
-    return this.pxe.updateContract(contractAddress, artifact);
-  }
-  getContracts(): Promise<AztecAddress[]> {
-    return this.pxe.getContracts();
-  }
-  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;
   }
-  simulateTx(
-    txRequest: TxExecutionRequest,
-    simulatePublic: boolean,
-    msgSender?: AztecAddress,
-    skipTxValidation?: boolean,
-    skipFeeEnforcement?: boolean,
-    profile?: boolean,
-  ): Promise<TxSimulationResult> {
+
+  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,
-      simulatePublic,
-      msgSender,
-      skipTxValidation,
-      skipFeeEnforcement,
-      profile,
-      this.scopes,
+      true /* simulatePublic */,
+      opts?.skipTxValidation,
+      opts?.skipFeeEnforcement ?? true,
     );
   }
-  sendTx(tx: Tx): Promise<TxHash> {
-    return this.pxe.sendTx(tx);
-  }
-  getTxEffect(txHash: TxHash) {
-    return this.pxe.getTxEffect(txHash);
-  }
-  getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
-    return this.pxe.getTxReceipt(txHash);
-  }
-  getNotes(filter: NotesFilter): Promise<UniqueNote[]> {
-    return this.pxe.getNotes(filter);
-  }
-  getPublicStorageAt(contract: AztecAddress, storageSlot: Fr): Promise<any> {
-    return this.pxe.getPublicStorageAt(contract, storageSlot);
+
+  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);
   }
-  getBlock(number: number): Promise<L2Block | undefined> {
-    return this.pxe.getBlock(number);
+
+  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;
   }
-  simulateUnconstrained(
+
+  simulateUtility(
     functionName: string,
     args: any[],
     to: AztecAddress,
-    from?: AztecAddress | undefined,
-  ): Promise<AbiDecoded> {
-    return this.pxe.simulateUnconstrained(functionName, args, to, from);
-  }
-  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
-    return this.pxe.getPublicLogs(filter);
-  }
-  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
-    return this.pxe.getContractClassLogs(filter);
-  }
-  getBlockNumber(): Promise<number> {
-    return this.pxe.getBlockNumber();
-  }
-  getProvenBlockNumber(): Promise<number> {
-    return this.pxe.getProvenBlockNumber();
-  }
-  getNodeInfo(): Promise<NodeInfo> {
-    return this.pxe.getNodeInfo();
-  }
-  addAuthWitness(authWitness: AuthWitness) {
-    return this.pxe.addAuthWitness(authWitness);
-  }
-  getAuthWitness(messageHash: Fr) {
-    return this.pxe.getAuthWitness(messageHash);
-  }
-  getPXEInfo(): Promise<PXEInfo> {
-    return this.pxe.getPXEInfo();
+    authwits?: AuthWitness[],
+    from?: AztecAddress,
+  ): Promise<UtilitySimulationResult> {
+    return this.pxe.simulateUtility(functionName, args, to, authwits, from);
   }
+
   getContractClassMetadata(id: Fr, includeArtifact: boolean = false): Promise<ContractClassMetadata> {
     return this.pxe.getContractClassMetadata(id, includeArtifact);
   }
   getContractMetadata(address: AztecAddress): Promise<ContractMetadata> {
     return this.pxe.getContractMetadata(address);
   }
+
+  getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
+    return this.aztecNode.getTxReceipt(txHash);
+  }
+
   getPrivateEvents<T>(
+    contractAddress: AztecAddress,
     event: EventMetadataDefinition,
     from: number,
     limit: number,
-    vpks: Point[] = [this.getCompleteAddress().publicKeys.masterIncomingViewingPublicKey],
+    recipients: AztecAddress[] = [],
   ): Promise<T[]> {
-    return this.pxe.getPrivateEvents(event, from, limit, vpks);
-  }
-  getPublicEvents<T>(event: EventMetadataDefinition, from: number, limit: number): Promise<T[]> {
-    return this.pxe.getPublicEvents(event, from, limit);
-  }
-  public getL1ToL2MembershipWitness(
-    contractAddress: AztecAddress,
-    messageHash: Fr,
-    secret: Fr,
-  ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
-    return this.pxe.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
-  }
-  getL2ToL1MembershipWitness(blockNumber: number, l2Tol1Message: Fr): Promise<[bigint, SiblingPath<number>]> {
-    return this.pxe.getL2ToL1MembershipWitness(blockNumber, l2Tol1Message);
+    return this.pxe.getPrivateEvents(contractAddress, event, from, limit, recipients);
   }
 }