@aztec/aztec.js 0.7.10 → 0.8.5

package/src/account/index.ts

@@ -1,4 +1,25 @@
-import { AztecRPC, CompleteAddress, GrumpkinPrivateKey } from '@aztec/types';
+/**
+ * The `account` module provides utilities for managing accounts. The most common methods to use
+ * are {@link getEcdsaAccount} and {@link getSchnorrAccount}, which return {@link AccountManager} instances
+ * using the default ECDSA or Schnorr account implementation respectively. The {@link AccountManager} class then
+ * allows to deploy and register a fresh account, or to obtain a `Wallet` instance out of an account already deployed.
+ *
+ * ```ts
+ * const encryptionPrivateKey = GrumpkinScalar.random();
+ * const signingPrivateKey = GrumpkinScalar.random();
+ * const wallet = getSchnorrAccount(pxe, encryptionPrivateKey, signingPrivateKey).waitDeploy();
+ * ```
+ *
+ * For testing purposes, consider using the {@link createAccount} and {@link createAccounts} methods,
+ * which create, register, and deploy random accounts, and return their associated `Wallet`s.
+ *
+ * For implementing your own account contract, the recommended way is to extend from the base
+ * {@link BaseAccountContract} class.
+ * Read more in {@link https://docs.aztec.network/dev_docs/wallets/writing_an_account_contract | Writing an account contract}.
+ *
+ * @packageDocumentation
+ */
+import { CompleteAddress, GrumpkinPrivateKey, PXE } from '@aztec/types';
 
 import { AccountContract, AccountWallet, AztecAddress, Fr } from '../index.js';
 import { EcdsaAccountContract } from './contract/ecdsa_account_contract.js';
@@ -8,6 +29,7 @@ import { AccountManager } from './manager/index.js';
 
 export * from './contract/index.js';
 export * from './defaults/index.js';
+export * from './utils.js';
 export { AccountInterface, AuthWitnessProvider } from './interface.js';
 export { AccountManager, CompleteAddress };
 
@@ -16,49 +38,49 @@ export type Salt = Fr | number | bigint;
 
 /**
  * Creates an Account that relies on an ECDSA signing key for authentication.
- * @param rpc - An AztecRPC server instance.
+ * @param pxe - An PXE server instance.
  * @param encryptionPrivateKey - Grumpkin key used for note encryption.
  * @param signingPrivateKey - Secp256k1 key used for signing transactions.
  * @param saltOrAddress - Deployment salt or complete address if account contract is already deployed.
  */
 export function getEcdsaAccount(
-  rpc: AztecRPC,
+  pxe: PXE,
   encryptionPrivateKey: GrumpkinPrivateKey,
   signingPrivateKey: Buffer,
   saltOrAddress?: Salt | CompleteAddress,
 ): AccountManager {
-  return new AccountManager(rpc, encryptionPrivateKey, new EcdsaAccountContract(signingPrivateKey), saltOrAddress);
+  return new AccountManager(pxe, encryptionPrivateKey, new EcdsaAccountContract(signingPrivateKey), saltOrAddress);
 }
 
 /**
  * Creates an Account that relies on a Grumpkin signing key for authentication.
- * @param rpc - An AztecRPC server instance.
+ * @param pxe - An PXE server instance.
  * @param encryptionPrivateKey - Grumpkin key used for note encryption.
  * @param signingPrivateKey - Grumpkin key used for signing transactions.
  * @param saltOrAddress - Deployment salt or complete address if account contract is already deployed.
  */
 export function getSchnorrAccount(
-  rpc: AztecRPC,
+  pxe: PXE,
   encryptionPrivateKey: GrumpkinPrivateKey,
   signingPrivateKey: GrumpkinPrivateKey,
   saltOrAddress?: Salt | CompleteAddress,
 ): AccountManager {
-  return new AccountManager(rpc, encryptionPrivateKey, new SchnorrAccountContract(signingPrivateKey), saltOrAddress);
+  return new AccountManager(pxe, encryptionPrivateKey, new SchnorrAccountContract(signingPrivateKey), saltOrAddress);
 }
 
 /**
  * Creates an Account that uses the same Grumpkin key for encryption and authentication.
- * @param rpc - An AztecRPC server instance.
+ * @param pxe - An PXE server instance.
  * @param encryptionAndSigningPrivateKey - Grumpkin key used for note encryption and signing transactions.
  * @param saltOrAddress - Deployment salt or complete address if account contract is already deployed.
  */
 export function getUnsafeSchnorrAccount(
-  rpc: AztecRPC,
+  pxe: PXE,
   encryptionAndSigningPrivateKey: GrumpkinPrivateKey,
   saltOrAddress?: Salt | CompleteAddress,
 ): AccountManager {
   return new AccountManager(
-    rpc,
+    pxe,
     encryptionAndSigningPrivateKey,
     new SingleKeyAccountContract(encryptionAndSigningPrivateKey),
     saltOrAddress,
@@ -67,36 +89,36 @@ export function getUnsafeSchnorrAccount(
 
 /**
  * Gets a wallet for an already registered account using Schnorr signatures with a single key for encryption and authentication.
- * @param rpc - An AztecRPC server instance.
+ * @param pxe - An PXE server instance.
  * @param address - Address for the account.
  * @param signingPrivateKey - Grumpkin key used for note encryption and signing transactions.
  * @returns A wallet for this account that can be used to interact with a contract instance.
  */
 export function getUnsafeSchnorrWallet(
-  rpc: AztecRPC,
+  pxe: PXE,
   address: AztecAddress,
   signingKey: GrumpkinPrivateKey,
 ): Promise<AccountWallet> {
-  return getWallet(rpc, address, new SingleKeyAccountContract(signingKey));
+  return getWallet(pxe, address, new SingleKeyAccountContract(signingKey));
 }
 
 /**
  * Gets a wallet for an already registered account.
- * @param rpc - An AztecRPC server instance.
+ * @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(
-  rpc: AztecRPC,
+  pxe: PXE,
   address: AztecAddress,
   accountContract: AccountContract,
 ): Promise<AccountWallet> {
-  const completeAddress = await rpc.getRegisteredAccount(address);
+  const completeAddress = await pxe.getRegisteredAccount(address);
   if (!completeAddress) {
     throw new Error(`Account ${address} not found`);
   }
-  const nodeInfo = await rpc.getNodeInfo();
+  const nodeInfo = await pxe.getNodeInfo();
   const entrypoint = await accountContract.getInterface(completeAddress, nodeInfo);
-  return new AccountWallet(rpc, entrypoint);
+  return new AccountWallet(pxe, entrypoint);
 }

package/src/account/manager/index.ts

@@ -1,5 +1,5 @@
 import { Fr, PublicKey, getContractDeploymentInfo } from '@aztec/circuits.js';
-import { AztecRPC, CompleteAddress, GrumpkinPrivateKey } from '@aztec/types';
+import { CompleteAddress, GrumpkinPrivateKey, PXE } from '@aztec/types';
 
 import { AccountWallet, ContractDeployer, DeployMethod, WaitOpts, generatePublicKey } from '../../index.js';
 import { AccountContract, Salt } from '../index.js';
@@ -8,7 +8,7 @@ import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
 
 /**
  * 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 RPC server.
+ * and creating and registering the user wallet in the PXE Service.
  */
 export class AccountManager {
   /** Deployment salt for the account contract. */
@@ -19,7 +19,7 @@ export class AccountManager {
   private deployMethod?: DeployMethod;
 
   constructor(
-    private rpc: AztecRPC,
+    private pxe: PXE,
     private encryptionPrivateKey: GrumpkinPrivateKey,
     private accountContract: AccountContract,
     saltOrAddress?: Salt | CompleteAddress,
@@ -43,7 +43,7 @@ export class AccountManager {
    * @returns An entrypoint.
    */
   public async getAccount(): Promise<AccountInterface> {
-    const nodeInfo = await this.rpc.getNodeInfo();
+    const nodeInfo = await this.pxe.getNodeInfo();
     const completeAddress = await this.getCompleteAddress();
     return this.accountContract.getInterface(completeAddress, nodeInfo);
   }
@@ -74,18 +74,18 @@ export class AccountManager {
    */
   public async getWallet(): Promise<AccountWallet> {
     const entrypoint = await this.getAccount();
-    return new AccountWallet(this.rpc, entrypoint);
+    return new AccountWallet(this.pxe, entrypoint);
   }
 
   /**
-   * Registers this account in the RPC server and returns the associated wallet. Registering
-   * the account on the RPC server is required for managing private state associated with it.
+   * 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.
    * @returns A Wallet instance.
    */
   public async register(): Promise<AccountWallet> {
     const completeAddress = await this.getCompleteAddress();
-    await this.rpc.registerAccount(this.encryptionPrivateKey, completeAddress.partialAddress);
+    await this.pxe.registerAccount(this.encryptionPrivateKey, completeAddress.partialAddress);
     return this.getWallet();
   }
 
@@ -100,7 +100,7 @@ export class AccountManager {
       if (!this.salt) throw new Error(`Cannot deploy account contract without known salt.`);
       await this.register();
       const encryptionPublicKey = await this.getEncryptionPublicKey();
-      const deployer = new ContractDeployer(this.accountContract.getContractAbi(), this.rpc, encryptionPublicKey);
+      const deployer = new ContractDeployer(this.accountContract.getContractAbi(), this.pxe, encryptionPublicKey);
       const args = await this.accountContract.getDeploymentArgs();
       this.deployMethod = deployer.deploy(...args);
     }
@@ -112,7 +112,7 @@ export class AccountManager {
    * Uses the salt provided in the constructor or a randomly generated one.
    * Note that if the Account is constructed with an explicit complete address
    * it is assumed that the account contract has already been deployed and this method will throw.
-   * Registers the account in the RPC server before deploying the contract.
+   * Registers the account in the PXE Service before deploying the contract.
    * @returns A SentTx object that can be waited to get the associated Wallet.
    */
   public async deploy(): Promise<DeployAccountSentTx> {
@@ -127,7 +127,7 @@ export class AccountManager {
    * Uses the salt provided in the constructor or a randomly generated one.
    * Note that if the Account is constructed with an explicit complete address
    * it is assumed that the account contract has already been deployed and this method will throw.
-   * Registers the account in the RPC server before deploying the contract.
+   * Registers the account in the PXE Service before deploying the contract.
    * @param opts - Options to wait for the tx to be mined.
    * @returns A Wallet instance.
    */

package/src/{utils/account.ts → account/utils.ts}

@@ -1,41 +1,41 @@
 import { CompleteAddress, GrumpkinScalar } from '@aztec/circuits.js';
-import { AztecRPC } from '@aztec/types';
+import { PXE } from '@aztec/types';
 
 import { getSchnorrAccount } from '../index.js';
 import { AccountWallet } from '../wallet/account_wallet.js';
 
 /**
- * Deploys and registers a new account using random private keys and returns the associated wallet. Useful for testing.
- * @param rpc - RPC client.
+ * Deploys and registers a new account using random private keys and returns the associated Schnorr account wallet. Useful for testing.
+ * @param pxe - PXE.
  * @returns - A wallet for a fresh account.
  */
-export function createAccount(rpc: AztecRPC): Promise<AccountWallet> {
-  return getSchnorrAccount(rpc, GrumpkinScalar.random(), GrumpkinScalar.random()).waitDeploy();
+export function createAccount(pxe: PXE): Promise<AccountWallet> {
+  return getSchnorrAccount(pxe, GrumpkinScalar.random(), GrumpkinScalar.random()).waitDeploy();
 }
 
 /**
- * Creates a random address and registers it as a recipient on the RPC server. Useful for testing.
- * @param rpc - RPC client.
+ * 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(rpc: AztecRPC): Promise<CompleteAddress> {
+export async function createRecipient(pxe: PXE): Promise<CompleteAddress> {
   const completeAddress = await CompleteAddress.random();
-  await rpc.registerRecipient(completeAddress);
+  await pxe.registerRecipient(completeAddress);
   return completeAddress;
 }
 
 /**
  * Creates a given number of random accounts using the Schnorr account wallet.
- * @param rpc - RPC interface.
+ * @param pxe - PXE.
  * @param numberOfAccounts - How many accounts to create.
  * @returns The created account wallets.
  */
-export async function createAccounts(rpc: AztecRPC, numberOfAccounts = 1): Promise<AccountWallet[]> {
+export async function createAccounts(pxe: PXE, numberOfAccounts = 1): Promise<AccountWallet[]> {
   const accounts = [];
 
   // Prepare deployments
   for (let i = 0; i < numberOfAccounts; ++i) {
-    const account = getSchnorrAccount(rpc, GrumpkinScalar.random(), GrumpkinScalar.random());
+    const account = getSchnorrAccount(pxe, GrumpkinScalar.random(), GrumpkinScalar.random());
     await account.getDeployMethod().then(d => d.simulate({ contractAddressSalt: account.salt }));
     accounts.push(account);
   }

package/src/contract/base_contract_interaction.ts

@@ -1,4 +1,4 @@
-import { AztecRPC, Tx, TxExecutionRequest } from '@aztec/types';
+import { PXE, Tx, TxExecutionRequest } from '@aztec/types';
 
 import { SentTx } from './sent_tx.js';
 
@@ -6,12 +6,12 @@ import { SentTx } from './sent_tx.js';
  * Represents options for calling a (constrained) function in a contract.
  * Allows the user to specify the sender address and nonce for a transaction.
  */
-export interface SendMethodOptions {
+export type SendMethodOptions = {
   /**
    * Wether to skip the simulation of the public part of the transaction.
    */
   skipPublicSimulation?: boolean;
-}
+};
 
 /**
  * Base class for an interaction with a contract, be it a deployment, a function call, or a batch.
@@ -21,7 +21,7 @@ export abstract class BaseContractInteraction {
   protected tx?: Tx;
   protected txRequest?: TxExecutionRequest;
 
-  constructor(protected rpc: AztecRPC) {}
+  constructor(protected pxe: PXE) {}
 
   /**
    * Create a transaction execution request ready to be simulated.
@@ -37,7 +37,7 @@ export abstract class BaseContractInteraction {
    */
   public async simulate(options: SendMethodOptions = {}): Promise<Tx> {
     const txRequest = this.txRequest ?? (await this.create(options));
-    this.tx = await this.rpc.simulateTx(txRequest, !options.skipPublicSimulation);
+    this.tx = await this.pxe.simulateTx(txRequest, !options.skipPublicSimulation);
     return this.tx;
   }
 
@@ -53,9 +53,9 @@ export abstract class BaseContractInteraction {
   public send(options: SendMethodOptions = {}) {
     const promise = (async () => {
       const tx = this.tx ?? (await this.simulate(options));
-      return this.rpc.sendTx(tx);
+      return this.pxe.sendTx(tx);
     })();
 
-    return new SentTx(this.rpc, promise);
+    return new SentTx(this.pxe, promise);
   }
 }

package/src/contract/contract.ts

@@ -10,7 +10,7 @@ import { ContractBase } from './contract_base.js';
  * The Contract class represents a contract and provides utility methods for interacting with it.
  * It enables the creation of ContractFunctionInteraction instances for each function in the contract's ABI,
  * allowing users to call or send transactions to these functions. Additionally, the Contract class can be used
- * to attach the contract instance to a deployed contract on-chain through the AztecRPCClient, which facilitates
+ * to attach the contract instance to a deployed contract on-chain through the PXE, which facilitates
  * interaction with Aztec's privacy protocol.
  */
 export class Contract extends ContractBase {

package/src/contract/contract_base.ts

@@ -74,12 +74,12 @@ export class ContractBase {
 
   /**
    * Attach the current contract instance to a portal contract and optionally add its dependencies.
-   * The function will return a promise that resolves when all contracts have been added to the AztecRPCClient.
+   * The function will return a promise that resolves when all contracts have been added to the PXE.
    * This is useful when you need to interact with a deployed contract that has multiple nested contracts.
    *
    * @param portalContract - The Ethereum address of the portal contract.
    * @param dependencies - An optional array of additional DeployedContract instances to be attached.
-   * @returns A promise that resolves when all contracts are successfully added to the AztecRPCClient.
+   * @returns A promise that resolves when all contracts are successfully added to the PXE.
    */
   public attach(portalContract: EthAddress, dependencies: DeployedContract[] = []) {
     const deployedContract: DeployedContract = {

package/src/contract/contract_function_interaction.ts

@@ -11,12 +11,12 @@ export { SendMethodOptions };
  * Represents the options for a view method in a contract function interaction.
  * Allows specifying the address from which the view method should be called.
  */
-export interface ViewMethodOptions {
+export type ViewMethodOptions = {
   /**
    * The sender's Aztec address.
    */
   from?: AztecAddress;
-}
+};
 
 /**
  * This is the class that is returned when calling e.g. `contract.methods.myMethod(arg0, arg1)`.

package/src/contract/index.ts

@@ -1,3 +1,40 @@
+/**
+ * The `contract` module provides utilities for deploying and interacting with contracts, based on a
+ * `Wallet` instance and a compiled artifact. Refer to the {@link account} module for how to obtain a valid
+ * `Wallet` instance, and to the {@link https://docs.aztec.network/dev_docs/contracts/compiling | Compiling contracts}
+ * section of the documentation for how to generate an artifact out of your Noir source code.
+ *
+ * The {@link Contract} class is the main class in this module, and provides static methods for deploying
+ * a contract or interacting with an already deployed one. The `methods` property of the contract instance
+ * provides access to private, public, and view methods, that can be invoked in a transaction via `send()`,
+ * or can be queried via `view()`.
+ *
+ * ```ts
+ * const contract = await Contract.deploy(wallet, MyContractAbi, [...constructorArgs]).send().deployed();
+ * console.log(`Contract deployed at ${contract.address}`);
+ * ```
+ *
+ * ```ts
+ * const contract = await Contract.at(address, MyContractAbi, wallet);
+ * await contract.methods.mint(1000, owner).send().wait();
+ * console.log(`Total supply is now ${await contract.methods.totalSupply().view()}`);
+ * ```
+ *
+ * The result of calling a method in a contract instance, such as `contract.methods.mint(1000, owner)`
+ * in the example, is a {@link ContractFunctionInteraction} instance. Usually this will be just sent as
+ * a transaction to the network via the `send` method, but you can also `simulate` it without sending,
+ * or obtaining the `request` for aggregating into a {@link BatchCall}.
+ *
+ * The result of `send`ing a transaction is a {@link SentTx} object, from which you can get the
+ * transaction hash, or simply `wait` until the transaction is mined and the local PXE Service
+ * has synchronised its changes.
+ *
+ * @remarks If you are using typescript, consider using the
+ * {@link https://docs.aztec.network/dev_docs/contracts/compiling#typescript-interfaces | autogenerated type-safe interfaces}
+ * for interacting with your contracts.
+ *
+ * @packageDocumentation
+ */
 export * from './contract.js';
 export * from './contract_function_interaction.js';
 export * from './sent_tx.js';

package/src/contract/sent_tx.ts

@@ -1,6 +1,6 @@
 import { FieldsOf } from '@aztec/circuits.js';
 import { retryUntil } from '@aztec/foundation/retry';
-import { AztecRPC, TxHash, TxReceipt, TxStatus } from '@aztec/types';
+import { PXE, TxHash, TxReceipt, TxStatus } from '@aztec/types';
 
 import every from 'lodash.every';
 
@@ -11,7 +11,7 @@ export type WaitOpts = {
   /** The time interval (in seconds) between retries to fetch the transaction receipt. Defaults to 1. */
   interval?: number;
   /**
-   * Whether to wait for the RPC server to sync all notes up to the block in which this tx was mined.
+   * Whether to wait for the PXE Service to sync all notes up to the block in which this tx was mined.
    * If false, then any queries that depend on state set by this transaction may return stale data. Defaults to true.
    **/
   waitForNotesSync?: boolean;
@@ -24,11 +24,11 @@ const DefaultWaitOpts: WaitOpts = {
 };
 
 /**
- * The SentTx class represents a sent transaction through the AztecRPCClient, providing methods to fetch
+ * The SentTx class represents a sent transaction through the PXE, providing methods to fetch
  * its hash, receipt, and mining status.
  */
 export class SentTx {
-  constructor(protected arc: AztecRPC, protected txHashPromise: Promise<TxHash>) {}
+  constructor(protected pxe: PXE, protected txHashPromise: Promise<TxHash>) {}
 
   /**
    * Retrieves the transaction hash of the SentTx instance.
@@ -43,13 +43,13 @@ export class SentTx {
   /**
    * Retrieve the transaction receipt associated with the current SentTx instance.
    * The function fetches the transaction hash using 'getTxHash' and then queries
-   * the AztecRPCClient to get the corresponding transaction receipt.
+   * the PXE to get the corresponding transaction receipt.
    *
    * @returns A promise that resolves to a TxReceipt object representing the fetched transaction receipt.
    */
   public async getReceipt(): Promise<TxReceipt> {
     const txHash = await this.getTxHash();
-    return await this.arc.getTxReceipt(txHash);
+    return await this.pxe.getTxReceipt(txHash);
   }
 
   /**
@@ -84,7 +84,7 @@ export class SentTx {
     const txHash = await this.getTxHash();
     return await retryUntil(
       async () => {
-        const txReceipt = await this.arc.getTxReceipt(txHash);
+        const txReceipt = await this.pxe.getTxReceipt(txHash);
         // If receipt is not yet available, try again
         if (txReceipt.status === TxStatus.PENDING) return undefined;
         // If the tx was dropped, return it
@@ -92,8 +92,8 @@ export class SentTx {
         // If we don't care about waiting for notes to be synced, return the receipt
         const waitForNotesSync = opts?.waitForNotesSync ?? DefaultWaitOpts.waitForNotesSync;
         if (!waitForNotesSync) return txReceipt;
-        // Check if all sync blocks on the rpc server are greater or equal than the block in which the tx was mined
-        const { blocks, notes } = await this.arc.getSyncStatus();
+        // Check if all sync blocks on the PXE Service are greater or equal than the block in which the tx was mined
+        const { blocks, notes } = await this.pxe.getSyncStatus();
         const targetBlock = txReceipt.blockNumber!;
         const areNotesSynced = blocks >= targetBlock && every(notes, block => block >= targetBlock);
         return areNotesSynced ? txReceipt : undefined;

package/src/contract_deployer/contract_deployer.ts

@@ -1,6 +1,6 @@
 import { Point } from '@aztec/circuits.js';
 import { ContractAbi } from '@aztec/foundation/abi';
-import { AztecRPC, PublicKey } from '@aztec/types';
+import { PXE, PublicKey } from '@aztec/types';
 
 import { DeployMethod } from './deploy_method.js';
 
@@ -9,7 +9,7 @@ import { DeployMethod } from './deploy_method.js';
  * @remarks Keeping this around even though we have Aztec.nr contract types because it can be useful for non-TS users.
  */
 export class ContractDeployer {
-  constructor(private abi: ContractAbi, private arc: AztecRPC, private publicKey?: PublicKey) {}
+  constructor(private abi: ContractAbi, private pxe: PXE, private publicKey?: PublicKey) {}
 
   /**
    * Deploy a contract using the provided ABI and constructor arguments.
@@ -18,9 +18,9 @@ export class ContractDeployer {
    * be passed to the contract's constructor during deployment.
    *
    * @param args - The constructor arguments for the contract being deployed.
-   * @returns A DeployMethod instance configured with the ABI, AztecRPCClient, and constructor arguments.
+   * @returns A DeployMethod instance configured with the ABI, PXE, and constructor arguments.
    */
   public deploy(...args: any[]) {
-    return new DeployMethod(this.publicKey ?? Point.ZERO, this.arc, this.abi, args);
+    return new DeployMethod(this.publicKey ?? Point.ZERO, this.pxe, this.abi, args);
   }
 }

package/src/contract_deployer/deploy_method.ts

@@ -8,7 +8,7 @@ import {
 import { ContractAbi, FunctionAbi, encodeArguments } from '@aztec/foundation/abi';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
-import { AztecRPC, PackedArguments, PublicKey, Tx, TxExecutionRequest } from '@aztec/types';
+import { PXE, PackedArguments, PublicKey, Tx, TxExecutionRequest } from '@aztec/types';
 
 import { BaseContractInteraction } from '../contract/base_contract_interaction.js';
 import { Contract, ContractBase, SendMethodOptions } from '../contract/index.js';
@@ -18,7 +18,7 @@ import { DeploySentTx } from './deploy_sent_tx.js';
  * Options for deploying a contract on the Aztec network.
  * Allows specifying a portal contract, contract address salt, and additional send method options.
  */
-export interface DeployOptions extends SendMethodOptions {
+export type DeployOptions = {
   /**
    * The Ethereum address of the Portal contract.
    */
@@ -27,7 +27,7 @@ export interface DeployOptions extends SendMethodOptions {
    * An optional salt value used to deterministically calculate the contract address.
    */
   contractAddressSalt?: Fr;
-}
+} & SendMethodOptions;
 
 /**
  * Creates a TxRequest from a contract ABI, for contract deployment.
@@ -40,8 +40,8 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
   /** Constructor function to call. */
   private constructorAbi: FunctionAbi;
 
-  constructor(private publicKey: PublicKey, private arc: AztecRPC, private abi: ContractAbi, private args: any[] = []) {
-    super(arc);
+  constructor(private publicKey: PublicKey, protected pxe: PXE, private abi: ContractAbi, private args: any[] = []) {
+    super(pxe);
     const constructorAbi = abi.functions.find(f => f.name === 'constructor');
     if (!constructorAbi) throw new Error('Cannot find constructor in the ABI.');
     this.constructorAbi = constructorAbi;
@@ -60,7 +60,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
     const portalContract = options.portalContract ?? EthAddress.ZERO;
     const contractAddressSalt = options.contractAddressSalt ?? Fr.random();
 
-    const { chainId, protocolVersion } = await this.rpc.getNodeInfo();
+    const { chainId, protocolVersion } = await this.pxe.getNodeInfo();
 
     const { completeAddress, constructorHash, functionTreeRoot } = await getContractDeploymentInfo(
       this.abi,
@@ -103,7 +103,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
     this.completeAddress = completeAddress;
 
     // TODO: Should we add the contracts to the DB here, or once the tx has been sent or mined?
-    await this.rpc.addContracts([{ abi: this.abi, completeAddress, portalContract }]);
+    await this.pxe.addContracts([{ abi: this.abi, completeAddress, portalContract }]);
 
     return this.txRequest;
   }
@@ -118,7 +118,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    */
   public send(options: DeployOptions = {}): DeploySentTx<TContract> {
     const txHashPromise = super.send(options).getTxHash();
-    return new DeploySentTx(this.abi, this.arc, txHashPromise);
+    return new DeploySentTx(this.abi, this.pxe, txHashPromise);
   }
 
   /**

package/src/contract_deployer/deploy_sent_tx.ts

@@ -2,7 +2,7 @@ import { FieldsOf } from '@aztec/circuits.js';
 import { ContractAbi } from '@aztec/foundation/abi';
 import { TxHash, TxReceipt } from '@aztec/types';
 
-import { AztecAddress, AztecRPC, Contract, ContractBase, SentTx, WaitOpts, Wallet } from '../index.js';
+import { AztecAddress, Contract, ContractBase, PXE, SentTx, WaitOpts, Wallet } from '../index.js';
 
 /** Options related to waiting for a deployment tx. */
 export type DeployedWaitOpts = WaitOpts & {
@@ -20,7 +20,7 @@ export type DeployTxReceipt<TContract extends ContractBase = Contract> = FieldsO
  * A contract deployment transaction sent to the network, extending SentTx with methods to create a contract instance.
  */
 export class DeploySentTx<TContract extends ContractBase = Contract> extends SentTx {
-  constructor(private abi: ContractAbi, wallet: AztecRPC | Wallet, txHashPromise: Promise<TxHash>) {
+  constructor(private abi: ContractAbi, wallet: PXE | Wallet, txHashPromise: Promise<TxHash>) {
     super(wallet, txHashPromise);
   }
 
@@ -46,8 +46,8 @@ export class DeploySentTx<TContract extends ContractBase = Contract> extends Sen
   }
 
   protected getContractInstance(wallet?: Wallet, address?: AztecAddress): Promise<TContract> {
-    const isWallet = (rpc: AztecRPC | Wallet): rpc is Wallet => !!(rpc as Wallet).createTxExecutionRequest;
-    const contractWallet = wallet ?? (isWallet(this.arc) && this.arc);
+    const isWallet = (pxe: PXE | Wallet): pxe is Wallet => !!(pxe as Wallet).createTxExecutionRequest;
+    const contractWallet = wallet ?? (isWallet(this.pxe) && this.pxe);
     if (!contractWallet) throw new Error(`A wallet is required for creating a contract instance`);
     if (!address) throw new Error(`Contract address is missing from transaction receipt`);
     return Contract.at(address, this.abi, contractWallet) as Promise<TContract>;

package/src/index.ts

@@ -1,7 +1,7 @@
 export * from './contract/index.js';
 export * from './contract_deployer/index.js';
 export * from './utils/index.js';
-export * from './aztec_rpc_client.js';
+export * from './pxe_client.js';
 export * from './account/index.js';
 export * from './contract_deployer/deploy_method.js';
 export * from './sandbox/index.js';
@@ -9,13 +9,15 @@ export * from './wallet/index.js';
 
 export { AztecAddress, EthAddress, Point, Fr, GrumpkinScalar } from '@aztec/circuits.js';
 export {
-  AztecRPC,
+  PXE,
   ContractData,
   ExtendedContractData as ExtendedContractData,
   DeployedContract,
   FunctionCall,
   L2BlockL2Logs,
+  UnencryptedL2Log,
   NodeInfo,
+  NotePreimage,
   PackedArguments,
   PublicKey,
   GrumpkinPrivateKey,

package/src/{aztec_rpc_client.ts → pxe_client.ts}

@@ -2,11 +2,12 @@ import { AztecAddress, CompleteAddress, EthAddress, Fr, GrumpkinScalar, Point }
 import { createJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
 import {
   AuthWitness,
-  AztecRPC,
   ContractData,
   ExtendedContractData,
   L2BlockL2Logs,
+  L2Tx,
   NotePreimage,
+  PXE,
   Tx,
   TxExecutionRequest,
   TxHash,
@@ -15,8 +16,8 @@ import {
 
 export { makeFetch } from '@aztec/foundation/json-rpc/client';
 
-export const createAztecRpcClient = (url: string, fetch = makeFetch([1, 2, 3], true)): AztecRPC =>
-  createJsonRpcClient<AztecRPC>(
+export const createPXEClient = (url: string, fetch = makeFetch([1, 2, 3], true)): PXE =>
+  createJsonRpcClient<PXE>(
     url,
     {
       CompleteAddress,
@@ -31,6 +32,7 @@ export const createAztecRpcClient = (url: string, fetch = makeFetch([1, 2, 3], t
       GrumpkinScalar,
       NotePreimage,
       AuthWitness,
+      L2Tx,
     },
     { Tx, TxReceipt, L2BlockL2Logs },
     false,