feat(aztec-js): Account class

[spalladino]

Fixes #1342. Introduces a new Account class for managing a user account:

/**
 * 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.
 */
export class Account {
  /**
   * Gets the calculated complete address associated with this account.
   * Does not require the account to be deployed or registered.
   * @returns The address, partial address, and encryption public key.
   */
  public async getCompleteAddress(): Promise<CompleteAddress> {...}

  /**
   * Returns a Wallet instance associated with this account. Use it to create Contract
   * instances to be interacted with from this account.
   * @returns A Wallet instance.
   */
  public async getWallet(): Promise<Wallet> {...}

  /**
   * 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.
   * Use the returned wallet to create Contract instances to be interacted with from this account.
   * @returns A Wallet instance.
   */
  public async register(): Promise<Wallet> {...}

  /**
   * Deploys the account contract that backs this account.
   * 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.
   * @returns A SentTx object that can be waited to get the associated Wallet.
   */
  public async deploy(): Promise<DeployAccountSentTx> {...}
}

This class is constructed out of an RPC server, an encryption private key, and an instance of a new AccountContract interface. This interface is all a dev needs to implement on ts to build their own flavor of account abstraction:

/**
 * An account contract instance. Knows its ABI, deployment arguments, and to create transaction execution
 * requests out of function calls through an entrypoint.
 */
export interface AccountContract {
  /** Returns the ABI of this account contract. */
  getContractAbi(): ContractAbi;
  /** Returns the deployment arguments for this instance. */
  getDeploymentArgs(): Promise<any[]>;
  /**
   * Creates an entrypoint for creating transaction execution requests for this account contract.
   * @param address - Complete address of the deployed account contract.
   * @param nodeInfo - Chain id and protocol version where the account contract is deployed.
   */
  getEntrypoint(address: CompleteAddress, nodeInfo: NodeInfo): Promise<Entrypoint>;
}

Along with these changes, the old AccountImplementation was renamed to Entrypoint, since its only concern was formatting FunctionCalls to be sent through an account's entrypoint. I'm still not in love with this new name, so suggestions are welcome.

For the user's convenience, we are also exposing methods that build Account instances out of the well known kinds, such as:

/**
 * Creates an Account that relies on an ECDSA signing key for authentication.
 * @param rpc - An AztecRPC 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,
  encryptionPrivateKey: PrivateKey,
  signingPrivateKey: PrivateKey,
  saltOrAddress?: Salt | CompleteAddress,
): Account {
  return new Account(rpc, encryptionPrivateKey, new EcdsaAccountContract(signingPrivateKey), saltOrAddress);
}

Example usage from the user's perspective:

// Create a new ECDSA account
const account = getEcdsaAccount(rpc, Privatekey.random(), Privatekey.random());
// Register it on the RPC server and deploy its contract
const wallet = await account.deploy().then(tx => tx.getWallet());
// Deploy a new child contract
const contract = await ChildContract.deploy(wallet).send().deployed();
// Send and await a tx to the new contract through the new wallet
await child.methods.value(42).send().wait();

Pending tasks, which can be done on a subsequent PR:

• Add unit tests for the Account class.
• Use the new Account class in e2e tests setup.
• Use the new Account class in the CLI.
• Review all names. Account, AccountContract, Entrypoint, these are all still somewhat confusing.
• Definitely rename SchnorrMultiKeyAccount and SchnorrSingleKeyAccount contracts.
• Ensure that accounts work in the browser (not sure if webpack is picking up the JSON files for ABIs).

[PhilWindle]

Looks nice. Was going to suggest updating the e2e tests but I see you have marked that as follow up work.