@aztec/aztec.js 0.23.0 → 0.24.0

package/src/utils/cheat_codes.ts

@@ -0,0 +1,297 @@
+import { Note, PXE } from '@aztec/circuit-types';
+import { AztecAddress, EthAddress, Fr } from '@aztec/circuits.js';
+import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
+import { keccak, pedersenHash } from '@aztec/foundation/crypto';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+import fs from 'fs';
+
+/**
+ * A class that provides utility functions for interacting with the chain.
+ */
+export class CheatCodes {
+  constructor(
+    /**
+     * The cheat codes for ethereum (L1).
+     */
+    public eth: EthCheatCodes,
+    /**
+     * The cheat codes for aztec.
+     */
+    public aztec: AztecCheatCodes,
+  ) {}
+
+  static create(rpcUrl: string, pxe: PXE): CheatCodes {
+    const ethCheatCodes = new EthCheatCodes(rpcUrl);
+    const aztecCheatCodes = new AztecCheatCodes(pxe, ethCheatCodes);
+    return new CheatCodes(ethCheatCodes, aztecCheatCodes);
+  }
+}
+
+/**
+ * A class that provides utility functions for interacting with ethereum (L1).
+ */
+export class EthCheatCodes {
+  constructor(
+    /**
+     * The RPC URL to use for interacting with the chain
+     */
+    public rpcUrl: string,
+    /**
+     * The logger to use for the eth cheatcodes
+     */
+    public logger = createDebugLogger('aztec:cheat_codes:eth'),
+  ) {}
+
+  async rpcCall(method: string, params: any[]) {
+    const paramsString = JSON.stringify(params);
+    const content = {
+      body: `{"jsonrpc":"2.0", "method": "${method}", "params": ${paramsString}, "id": 1}`,
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    };
+    return await (await fetch(this.rpcUrl, content)).json();
+  }
+
+  /**
+   * Get the current blocknumber
+   * @returns The current block number
+   */
+  public async blockNumber(): Promise<number> {
+    const res = await this.rpcCall('eth_blockNumber', []);
+    return parseInt(res.result, 16);
+  }
+
+  /**
+   * Get the current chainId
+   * @returns The current chainId
+   */
+  public async chainId(): Promise<number> {
+    const res = await this.rpcCall('eth_chainId', []);
+    return parseInt(res.result, 16);
+  }
+
+  /**
+   * Get the current timestamp
+   * @returns The current timestamp
+   */
+  public async timestamp(): Promise<number> {
+    const res = await this.rpcCall('eth_getBlockByNumber', ['latest', true]);
+    return parseInt(res.result.timestamp, 16);
+  }
+
+  /**
+   * Advance the chain by a number of blocks
+   * @param numberOfBlocks - The number of blocks to mine
+   * @returns The current chainId
+   */
+  public async mine(numberOfBlocks = 1): Promise<void> {
+    const res = await this.rpcCall('hardhat_mine', [numberOfBlocks]);
+    if (res.error) {
+      throw new Error(`Error mining: ${res.error.message}`);
+    }
+    this.logger(`Mined ${numberOfBlocks} blocks`);
+  }
+
+  /**
+   * Set the next block timestamp
+   * @param timestamp - The timestamp to set the next block to
+   */
+  public async setNextBlockTimestamp(timestamp: number): Promise<void> {
+    const res = await this.rpcCall('evm_setNextBlockTimestamp', [timestamp]);
+    if (res.error) {
+      throw new Error(`Error setting next block timestamp: ${res.error.message}`);
+    }
+    this.logger(`Set next block timestamp to ${timestamp}`);
+  }
+
+  /**
+   * Dumps the current chain state to a file.
+   * @param fileName - The file name to dump state into
+   */
+  public async dumpChainState(fileName: string): Promise<void> {
+    const res = await this.rpcCall('hardhat_dumpState', []);
+    if (res.error) {
+      throw new Error(`Error dumping state: ${res.error.message}`);
+    }
+    const jsonContent = JSON.stringify(res.result);
+    fs.writeFileSync(`${fileName}.json`, jsonContent, 'utf8');
+    this.logger(`Dumped state to ${fileName}`);
+  }
+
+  /**
+   * Loads the chain state from a file.
+   * @param fileName - The file name to load state from
+   */
+  public async loadChainState(fileName: string): Promise<void> {
+    const data = JSON.parse(fs.readFileSync(`${fileName}.json`, 'utf8'));
+    const res = await this.rpcCall('hardhat_loadState', [data]);
+    if (res.error) {
+      throw new Error(`Error loading state: ${res.error.message}`);
+    }
+    this.logger(`Loaded state from ${fileName}`);
+  }
+
+  /**
+   * Load the value at a storage slot of a contract address on eth
+   * @param contract - The contract address
+   * @param slot - The storage slot
+   * @returns - The value at the storage slot
+   */
+  public async load(contract: EthAddress, slot: bigint): Promise<bigint> {
+    const res = await this.rpcCall('eth_getStorageAt', [contract.toString(), toHex(slot), 'latest']);
+    return BigInt(res.result);
+  }
+
+  /**
+   * Set the value at a storage slot of a contract address on eth
+   * @param contract - The contract address
+   * @param slot - The storage slot
+   * @param value - The value to set the storage slot to
+   */
+  public async store(contract: EthAddress, slot: bigint, value: bigint): Promise<void> {
+    // for the rpc call, we need to change value to be a 32 byte hex string.
+    const res = await this.rpcCall('hardhat_setStorageAt', [contract.toString(), toHex(slot), toHex(value, true)]);
+    if (res.error) {
+      throw new Error(`Error setting storage for contract ${contract} at ${slot}: ${res.error.message}`);
+    }
+    this.logger(`Set storage for contract ${contract} at ${slot} to ${value}`);
+  }
+
+  /**
+   * Computes the slot value for a given map and key.
+   * @param baseSlot - The base slot of the map (specified in Aztec.nr contract)
+   * @param key - The key to lookup in the map
+   * @returns The storage slot of the value in the map
+   */
+  public keccak256(baseSlot: bigint, key: bigint): bigint {
+    // abi encode (removing the 0x) - concat key and baseSlot (both padded to 32 bytes)
+    const abiEncoded = toHex(key, true).substring(2) + toHex(baseSlot, true).substring(2);
+    return toBigIntBE(keccak(Buffer.from(abiEncoded, 'hex')));
+  }
+
+  /**
+   * Send transactions impersonating an externally owned account or contract.
+   * @param who - The address to impersonate
+   */
+  public async startImpersonating(who: EthAddress): Promise<void> {
+    const res = await this.rpcCall('hardhat_impersonateAccount', [who.toString()]);
+    if (res.error) {
+      throw new Error(`Error impersonating ${who}: ${res.error.message}`);
+    }
+    this.logger(`Impersonating ${who}`);
+  }
+
+  /**
+   * Stop impersonating an account that you are currently impersonating.
+   * @param who - The address to stop impersonating
+   */
+  public async stopImpersonating(who: EthAddress): Promise<void> {
+    const res = await this.rpcCall('hardhat_stopImpersonatingAccount', [who.toString()]);
+    if (res.error) {
+      throw new Error(`Error when stopping the impersonation of ${who}: ${res.error.message}`);
+    }
+    this.logger(`Stopped impersonating ${who}`);
+  }
+
+  /**
+   * Set the bytecode for a contract
+   * @param contract - The contract address
+   * @param bytecode - The bytecode to set
+   */
+  public async etch(contract: EthAddress, bytecode: `0x${string}`): Promise<void> {
+    const res = await this.rpcCall('hardhat_setCode', [contract.toString(), bytecode]);
+    if (res.error) {
+      throw new Error(`Error setting bytecode for ${contract}: ${res.error.message}`);
+    }
+    this.logger(`Set bytecode for ${contract} to ${bytecode}`);
+  }
+
+  /**
+   * Get the bytecode for a contract
+   * @param contract - The contract address
+   * @returns The bytecode for the contract
+   */
+  public async getBytecode(contract: EthAddress): Promise<`0x${string}`> {
+    const res = await this.rpcCall('eth_getCode', [contract.toString(), 'latest']);
+    return res.result;
+  }
+}
+
+/**
+ * A class that provides utility functions for interacting with the aztec chain.
+ */
+export class AztecCheatCodes {
+  constructor(
+    /**
+     * The PXE Service to use for interacting with the chain
+     */
+    public pxe: PXE,
+    /**
+     * The eth cheat codes.
+     */
+    public eth: EthCheatCodes,
+    /**
+     * The logger to use for the aztec cheatcodes
+     */
+    public logger = createDebugLogger('aztec:cheat_codes:aztec'),
+  ) {}
+
+  /**
+   * Computes the slot value for a given map and key.
+   * @param baseSlot - The base slot of the map (specified in Aztec.nr contract)
+   * @param key - The key to lookup in the map
+   * @returns The storage slot of the value in the map
+   */
+  public computeSlotInMap(baseSlot: Fr | bigint, key: Fr | bigint | AztecAddress): Fr {
+    // Based on `at` function in
+    // aztec3-packages/aztec-nr/aztec/src/state_vars/map.nr
+    return Fr.fromBuffer(pedersenHash([new Fr(baseSlot), new Fr(key)].map(f => f.toBuffer())));
+  }
+
+  /**
+   * Get the current blocknumber
+   * @returns The current block number
+   */
+  public async blockNumber(): Promise<number> {
+    return await this.pxe.getBlockNumber();
+  }
+
+  /**
+   * Set time of the next execution on aztec.
+   * It also modifies time on eth for next execution and stores this time as the last rollup block on the rollup contract.
+   * @param to - The timestamp to set the next block to (must be greater than current time)
+   */
+  public async warp(to: number): Promise<void> {
+    const rollupContract = (await this.pxe.getNodeInfo()).l1ContractAddresses.rollupAddress;
+    await this.eth.setNextBlockTimestamp(to);
+    // also store this time on the rollup contract (slot 1 tracks `lastBlockTs`).
+    // This is because when the sequencer executes public functions, it uses the timestamp stored in the rollup contract.
+    await this.eth.store(rollupContract, 1n, BigInt(to));
+    // also store this on slot 2 of the rollup contract (`lastWarpedBlockTs`) which tracks the last time warp was used.
+    await this.eth.store(rollupContract, 2n, BigInt(to));
+  }
+
+  /**
+   * Loads the value stored at the given slot in the public storage of the given contract.
+   * @param who - The address of the contract
+   * @param slot - The storage slot to lookup
+   * @returns The value stored at the given slot
+   */
+  public async loadPublic(who: AztecAddress, slot: Fr | bigint): Promise<Fr> {
+    const storageValue = await this.pxe.getPublicStorageAt(who, new Fr(slot));
+    return storageValue;
+  }
+
+  /**
+   * Loads the value stored at the given slot in the private storage of the given contract.
+   * @param contract - The address of the contract
+   * @param owner - The owner for whom the notes are encrypted
+   * @param slot - The storage slot to lookup
+   * @returns The notes stored at the given slot
+   */
+  public async loadPrivate(owner: AztecAddress, contract: AztecAddress, slot: Fr | bigint): Promise<Note[]> {
+    const extendedNotes = await this.pxe.getNotes({ owner, contractAddress: contract, storageSlot: new Fr(slot) });
+    return extendedNotes.map(extendedNote => extendedNote.note);
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,9 @@
+export * from './secrets.js';
+export * from './pub_key.js';
+export * from './l1_contracts.js';
+export * from './l2_contracts.js';
+export * from './abi_types.js';
+export * from './cheat_codes.js';
+export * from './authwit.js';
+export * from './pxe.js';
+export * from './account.js';

package/src/utils/l1_contracts.ts

@@ -0,0 +1,21 @@
+import { L1ContractAddresses } from '@aztec/ethereum';
+import { retryUntil } from '@aztec/foundation/retry';
+
+import { createPXEClient } from '../rpc_clients/index.js';
+
+export const getL1ContractAddresses = async (url: string): Promise<L1ContractAddresses> => {
+  const pxeClient = createPXEClient(url);
+  const response = await retryUntil(
+    async () => {
+      try {
+        return (await pxeClient.getNodeInfo()).l1ContractAddresses;
+      } catch (err) {
+        // do nothing
+      }
+    },
+    'isNodeReady',
+    120,
+    1,
+  );
+  return response;
+};

package/src/utils/l2_contracts.ts

@@ -0,0 +1,12 @@
+import { PXE } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+
+/**
+ * Checks whether a give contract is deployed on the network.
+ * @param pxe - The PXE to use to obtain the information.
+ * @param contractAddress - The address of the contract to check.
+ * @returns A flag indicating whether the contract is deployed.
+ */
+export async function isContractDeployed(pxe: PXE, contractAddress: AztecAddress): Promise<boolean> {
+  return !!(await pxe.getContractData(contractAddress));
+}

package/src/utils/pub_key.ts

@@ -0,0 +1,12 @@
+import { GrumpkinPrivateKey, PublicKey } from '@aztec/circuits.js';
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+
+/**
+ * Method for generating a public grumpkin key from a private key.
+ * @param privateKey - The private key.
+ * @returns The generated public key.
+ */
+export function generatePublicKey(privateKey: GrumpkinPrivateKey): PublicKey {
+  const grumpkin = new Grumpkin();
+  return grumpkin.mul(grumpkin.generator(), privateKey);
+}

package/src/utils/pxe.ts

@@ -0,0 +1,16 @@
+import { PXE } from '@aztec/circuit-types';
+import { DebugLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+
+export const waitForPXE = async (pxe: PXE, logger?: DebugLogger) => {
+  await retryUntil(async () => {
+    try {
+      logger?.('Attempting to contact PXE...');
+      await pxe.getNodeInfo();
+      return true;
+    } catch (error) {
+      logger?.('Failed to contact PXE!');
+    }
+    return undefined;
+  }, 'RPC Get Node Info');
+};

package/src/utils/secrets.ts

@@ -0,0 +1,11 @@
+import { Fr } from '@aztec/circuits.js';
+import { computeSecretMessageHash } from '@aztec/circuits.js/abis';
+
+/**
+ * Given a secret, it computes its pedersen hash - used to send l1 to l2 messages
+ * @param secret - the secret to hash - secret could be generated however you want e.g. `Fr.random()`
+ * @returns the hash
+ */
+export function computeMessageSecretHash(secret: Fr) {
+  return computeSecretMessageHash(secret);
+}

package/src/wallet/account_wallet.ts

@@ -0,0 +1,70 @@
+import { AuthWitness, FunctionCall, PXE, TxExecutionRequest } from '@aztec/circuit-types';
+import { Fr } from '@aztec/circuits.js';
+import { ABIParameterVisibility, FunctionAbi, FunctionType } from '@aztec/foundation/abi';
+
+import { AccountInterface, FeeOptions } from '../account/interface.js';
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { BaseWallet } from './base_wallet.js';
+
+/**
+ * A wallet implementation that forwards authentication requests to a provided account.
+ */
+export class AccountWallet extends BaseWallet {
+  constructor(pxe: PXE, protected account: AccountInterface) {
+    super(pxe);
+  }
+
+  createTxExecutionRequest(execs: FunctionCall[], fee?: FeeOptions): Promise<TxExecutionRequest> {
+    return this.account.createTxExecutionRequest(execs, fee);
+  }
+
+  async createAuthWitness(message: Fr | Buffer): Promise<AuthWitness> {
+    message = Buffer.isBuffer(message) ? Fr.fromBuffer(message) : message;
+    const witness = await this.account.createAuthWitness(message);
+    await this.pxe.addAuthWitness(witness);
+    return witness;
+  }
+
+  /**
+   * Returns a function interaction to set a message hash as authorized in this account.
+   * Public calls can then consume this authorization.
+   * @param message - Message hash to authorize.
+   * @param authorized - True to authorize, false to revoke authorization.
+   * @returns - A function interaction.
+   */
+  public setPublicAuth(message: Fr | Buffer, authorized: boolean): ContractFunctionInteraction {
+    const args = [message, authorized];
+    return new ContractFunctionInteraction(this, this.getAddress(), this.getSetIsValidStorageAbi(), args);
+  }
+
+  /** Returns the complete address of the account that implements this wallet. */
+  public getCompleteAddress() {
+    return this.account.getCompleteAddress();
+  }
+
+  /** Returns the address of the account that implements this wallet. */
+  public getAddress() {
+    return this.getCompleteAddress().address;
+  }
+
+  private getSetIsValidStorageAbi(): FunctionAbi {
+    return {
+      name: 'set_is_valid_storage',
+      functionType: 'open' as FunctionType,
+      isInternal: true,
+      parameters: [
+        {
+          name: 'message_hash',
+          type: { kind: 'field' },
+          visibility: 'private' as ABIParameterVisibility,
+        },
+        {
+          name: 'value',
+          type: { kind: 'boolean' },
+          visibility: 'private' as ABIParameterVisibility,
+        },
+      ],
+      returnTypes: [],
+    };
+  }
+}

package/src/wallet/account_wallet_with_private_key.ts

@@ -0,0 +1,28 @@
+import { PXE } from '@aztec/circuit-types';
+import { GrumpkinPrivateKey } from '@aztec/circuits.js';
+
+import { Salt } from '../account/index.js';
+import { AccountInterface } from '../account/interface.js';
+import { AccountWallet } from './account_wallet.js';
+
+/**
+ * Extends {@link AccountWallet} with the encryption private key. Not required for
+ * implementing the wallet interface but useful for testing purposes or exporting
+ * an account to another pxe.
+ */
+export class AccountWalletWithPrivateKey extends AccountWallet {
+  constructor(
+    pxe: PXE,
+    account: AccountInterface,
+    private encryptionPrivateKey: GrumpkinPrivateKey,
+    /** Deployment salt for this account contract. */
+    public readonly salt: Salt,
+  ) {
+    super(pxe, account);
+  }
+
+  /** Returns the encryption private key associated with this account. */
+  public getEncryptionPrivateKey() {
+    return this.encryptionPrivateKey;
+  }
+}

package/src/wallet/base_wallet.ts

@@ -0,0 +1,123 @@
+import {
+  AuthWitness,
+  ContractData,
+  DeployedContract,
+  ExtendedContractData,
+  ExtendedNote,
+  FunctionCall,
+  GetUnencryptedLogsResponse,
+  L2Block,
+  L2Tx,
+  LogFilter,
+  NoteFilter,
+  PXE,
+  SyncStatus,
+  Tx,
+  TxExecutionRequest,
+  TxHash,
+  TxReceipt,
+} from '@aztec/circuit-types';
+import { AztecAddress, CompleteAddress, Fr, GrumpkinPrivateKey, PartialAddress } from '@aztec/circuits.js';
+import { ContractInstanceWithAddress } from '@aztec/types/contracts';
+import { NodeInfo } from '@aztec/types/interfaces';
+
+import { FeeOptions } from '../account/interface.js';
+import { Wallet } from '../account/wallet.js';
+
+/**
+ * A base class for Wallet implementations
+ */
+export abstract class BaseWallet implements Wallet {
+  constructor(protected readonly pxe: PXE) {}
+
+  abstract getCompleteAddress(): CompleteAddress;
+
+  abstract createTxExecutionRequest(execs: FunctionCall[], fee?: FeeOptions): Promise<TxExecutionRequest>;
+
+  abstract createAuthWitness(message: Fr): Promise<AuthWitness>;
+
+  getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    return this.pxe.getContractInstance(address);
+  }
+  addCapsule(capsule: Fr[]): Promise<void> {
+    return this.pxe.addCapsule(capsule);
+  }
+  registerAccount(privKey: GrumpkinPrivateKey, partialAddress: PartialAddress): Promise<CompleteAddress> {
+    return this.pxe.registerAccount(privKey, partialAddress);
+  }
+  registerRecipient(account: CompleteAddress): Promise<void> {
+    return this.pxe.registerRecipient(account);
+  }
+  getRegisteredAccounts(): Promise<CompleteAddress[]> {
+    return this.pxe.getRegisteredAccounts();
+  }
+  getRegisteredAccount(address: AztecAddress): Promise<CompleteAddress | undefined> {
+    return this.pxe.getRegisteredAccount(address);
+  }
+  getRecipients(): Promise<CompleteAddress[]> {
+    return this.pxe.getRecipients();
+  }
+  getRecipient(address: AztecAddress): Promise<CompleteAddress | undefined> {
+    return this.pxe.getRecipient(address);
+  }
+  addContracts(contracts: DeployedContract[]): Promise<void> {
+    return this.pxe.addContracts(contracts);
+  }
+  getContracts(): Promise<AztecAddress[]> {
+    return this.pxe.getContracts();
+  }
+  simulateTx(txRequest: TxExecutionRequest, simulatePublic: boolean): Promise<Tx> {
+    return this.pxe.simulateTx(txRequest, simulatePublic);
+  }
+  sendTx(tx: Tx): Promise<TxHash> {
+    return this.pxe.sendTx(tx);
+  }
+  getTx(txHash: TxHash): Promise<L2Tx | undefined> {
+    return this.pxe.getTx(txHash);
+  }
+  getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
+    return this.pxe.getTxReceipt(txHash);
+  }
+  getNotes(filter: NoteFilter): Promise<ExtendedNote[]> {
+    return this.pxe.getNotes(filter);
+  }
+  getPublicStorageAt(contract: AztecAddress, storageSlot: Fr): Promise<any> {
+    return this.pxe.getPublicStorageAt(contract, storageSlot);
+  }
+  addNote(note: ExtendedNote): Promise<void> {
+    return this.pxe.addNote(note);
+  }
+  getBlock(number: number): Promise<L2Block | undefined> {
+    return this.pxe.getBlock(number);
+  }
+  viewTx(functionName: string, args: any[], to: AztecAddress, from?: AztecAddress | undefined): Promise<any> {
+    return this.pxe.viewTx(functionName, args, to, from);
+  }
+  getExtendedContractData(contractAddress: AztecAddress): Promise<ExtendedContractData | undefined> {
+    return this.pxe.getExtendedContractData(contractAddress);
+  }
+  getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
+    return this.pxe.getContractData(contractAddress);
+  }
+  getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+    return this.pxe.getUnencryptedLogs(filter);
+  }
+  getBlockNumber(): Promise<number> {
+    return this.pxe.getBlockNumber();
+  }
+  getNodeInfo(): Promise<NodeInfo> {
+    return this.pxe.getNodeInfo();
+  }
+  isGlobalStateSynchronized() {
+    return this.pxe.isGlobalStateSynchronized();
+  }
+  isAccountStateSynchronized(account: AztecAddress) {
+    return this.pxe.isAccountStateSynchronized(account);
+  }
+  getSyncStatus(): Promise<SyncStatus> {
+    return this.pxe.getSyncStatus();
+  }
+  addAuthWitness(authWitness: AuthWitness) {
+    return this.pxe.addAuthWitness(authWitness);
+  }
+}

package/src/wallet/create_recipient.ts

@@ -0,0 +1,13 @@
+import { PXE } from '@aztec/circuit-types';
+import { CompleteAddress } from '@aztec/circuits.js';
+
+/**
+ * Creates a random address and registers it as a recipient on the pxe server. Useful for testing.
+ * @param pxe - PXE.
+ * @returns Complete address of the registered recipient.
+ */
+export async function createRecipient(pxe: PXE): Promise<CompleteAddress> {
+  const completeAddress = CompleteAddress.random();
+  await pxe.registerRecipient(completeAddress);
+  return completeAddress;
+}

package/src/wallet/index.ts

@@ -0,0 +1,31 @@
+import { PXE } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+
+import { AccountContract } from '../account/contract.js';
+import { AccountWallet } from './account_wallet.js';
+
+export * from '../account/wallet.js';
+export * from './account_wallet.js';
+export * from './account_wallet_with_private_key.js';
+export * from './signerless_wallet.js';
+
+/**
+ * Gets a wallet for an already registered account.
+ * @param pxe - PXE Service instance.
+ * @param address - Address for the account.
+ * @param accountContract - Account contract implementation.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export async function getWallet(
+  pxe: PXE,
+  address: AztecAddress,
+  accountContract: AccountContract,
+): Promise<AccountWallet> {
+  const completeAddress = await pxe.getRegisteredAccount(address);
+  if (!completeAddress) {
+    throw new Error(`Account ${address} not found`);
+  }
+  const nodeInfo = await pxe.getNodeInfo();
+  const entrypoint = accountContract.getInterface(completeAddress, nodeInfo);
+  return new AccountWallet(pxe, entrypoint);
+}