@aztec/aztec.js 0.16.4 → 0.16.5

package/src/account/index.ts

@@ -1,124 +0,0 @@
-/**
- * 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';
-import { SchnorrAccountContract } from './contract/schnorr_account_contract.js';
-import { SingleKeyAccountContract } from './contract/single_key_account_contract.js';
-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 };
-
-/** A contract deployment salt. */
-export type Salt = Fr | number | bigint;
-
-/**
- * Creates an Account that relies on an ECDSA signing key for authentication.
- * @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(
-  pxe: PXE,
-  encryptionPrivateKey: GrumpkinPrivateKey,
-  signingPrivateKey: Buffer,
-  saltOrAddress?: Salt | CompleteAddress,
-): AccountManager {
-  return new AccountManager(pxe, encryptionPrivateKey, new EcdsaAccountContract(signingPrivateKey), saltOrAddress);
-}
-
-/**
- * Creates an Account that relies on a Grumpkin signing key for authentication.
- * @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(
-  pxe: PXE,
-  encryptionPrivateKey: GrumpkinPrivateKey,
-  signingPrivateKey: GrumpkinPrivateKey,
-  saltOrAddress?: Salt | CompleteAddress,
-): AccountManager {
-  return new AccountManager(pxe, encryptionPrivateKey, new SchnorrAccountContract(signingPrivateKey), saltOrAddress);
-}
-
-/**
- * Creates an Account that uses the same Grumpkin key for encryption and authentication.
- * @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(
-  pxe: PXE,
-  encryptionAndSigningPrivateKey: GrumpkinPrivateKey,
-  saltOrAddress?: Salt | CompleteAddress,
-): AccountManager {
-  return new AccountManager(
-    pxe,
-    encryptionAndSigningPrivateKey,
-    new SingleKeyAccountContract(encryptionAndSigningPrivateKey),
-    saltOrAddress,
-  );
-}
-
-/**
- * Gets a wallet for an already registered account using Schnorr signatures with a single key for encryption and authentication.
- * @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(
-  pxe: PXE,
-  address: AztecAddress,
-  signingKey: GrumpkinPrivateKey,
-): Promise<AccountWallet> {
-  return getWallet(pxe, address, new SingleKeyAccountContract(signingKey));
-}
-
-/**
- * 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);
-}

package/src/account/interface.ts

@@ -1,35 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { AuthWitness, CompleteAddress, FunctionCall, TxExecutionRequest } from '@aztec/types';
-
-// docs:start:account-interface
-/** Creates authorization witnesses. */
-export interface AuthWitnessProvider {
-  /**
-   * Create an authorization witness for the given message.
-   * @param message - Message to authorize.
-   */
-  createAuthWitness(message: Fr): Promise<AuthWitness>;
-}
-
-/** Creates transaction execution requests out of a set of function calls. */
-export interface EntrypointInterface {
-  /**
-   * Generates an authenticated request out of set of function calls.
-   * @param executions - The execution intents to be run.
-   * @param opts - Options.
-   * @returns The authenticated transaction execution request.
-   */
-  createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest>;
-}
-
-/**
- * Handler for interfacing with an account. Knows how to create transaction execution
- * requests and authorize actions for its corresponding account.
- */
-export interface AccountInterface extends AuthWitnessProvider, EntrypointInterface {
-  /**
-   * Returns the complete address for this account.
-   */
-  getCompleteAddress(): CompleteAddress;
-}
-// docs:end:account-interface

package/src/account/manager/deploy_account_sent_tx.ts

@@ -1,42 +0,0 @@
-import { FieldsOf } from '@aztec/circuits.js';
-import { TxHash, TxReceipt } from '@aztec/types';
-
-import { DefaultWaitOpts, SentTx, WaitOpts } from '../../contract/sent_tx.js';
-import { Wallet } from '../../wallet/index.js';
-import { waitForAccountSynch } from './util.js';
-
-/** Extends a transaction receipt with a wallet instance for the newly deployed contract. */
-export type DeployAccountTxReceipt = FieldsOf<TxReceipt> & {
-  /** Wallet that corresponds to the newly deployed account contract. */
-  wallet: Wallet;
-};
-
-/**
- * A deployment transaction for an account contract sent to the network, extending SentTx with methods to get the resulting wallet.
- */
-export class DeployAccountSentTx extends SentTx {
-  constructor(private wallet: Wallet, txHashPromise: Promise<TxHash>) {
-    super(wallet, txHashPromise);
-  }
-
-  /**
-   * Awaits for the tx to be mined and returns the contract instance. Throws if tx is not mined.
-   * @param opts - Options for configuring the waiting for the tx to be mined.
-   * @returns The deployed contract instance.
-   */
-  public async getWallet(opts?: WaitOpts): Promise<Wallet> {
-    const receipt = await this.wait(opts);
-    return receipt.wallet;
-  }
-
-  /**
-   * Awaits for the tx to be mined and returns the receipt along with a wallet instance. Throws if tx is not mined.
-   * @param opts - Options for configuring the waiting for the tx to be mined.
-   * @returns The transaction receipt with the wallet for the deployed account contract.
-   */
-  public async wait(opts: WaitOpts = DefaultWaitOpts): Promise<DeployAccountTxReceipt> {
-    const receipt = await super.wait(opts);
-    await waitForAccountSynch(this.pxe, this.wallet.getCompleteAddress(), opts);
-    return { ...receipt, wallet: this.wallet };
-  }
-}

package/src/account/manager/index.ts

@@ -1,156 +0,0 @@
-import { PublicKey, getContractDeploymentInfo } from '@aztec/circuits.js';
-import { Fr } from '@aztec/foundation/fields';
-import { CompleteAddress, GrumpkinPrivateKey, PXE } from '@aztec/types';
-
-import { DefaultWaitOpts } from '../../contract/sent_tx.js';
-import {
-  AccountWalletWithPrivateKey,
-  ContractDeployer,
-  DeployMethod,
-  WaitOpts,
-  generatePublicKey,
-} from '../../index.js';
-import { AccountContract, Salt } from '../index.js';
-import { AccountInterface } from '../interface.js';
-import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
-import { waitForAccountSynch } from './util.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 PXE Service.
- */
-export class AccountManager {
-  /** Deployment salt for the account contract. */
-  public readonly salt?: Fr;
-
-  private completeAddress?: CompleteAddress;
-  private encryptionPublicKey?: PublicKey;
-  private deployMethod?: DeployMethod;
-
-  constructor(
-    private pxe: PXE,
-    private encryptionPrivateKey: GrumpkinPrivateKey,
-    private accountContract: AccountContract,
-    saltOrAddress?: Salt | CompleteAddress,
-  ) {
-    if (saltOrAddress instanceof CompleteAddress) {
-      this.completeAddress = saltOrAddress;
-    } else {
-      this.salt = saltOrAddress ? new Fr(saltOrAddress) : Fr.random();
-    }
-  }
-
-  protected getEncryptionPublicKey() {
-    if (!this.encryptionPublicKey) {
-      this.encryptionPublicKey = generatePublicKey(this.encryptionPrivateKey);
-    }
-    return this.encryptionPublicKey;
-  }
-
-  /**
-   * Returns the entrypoint for this account as defined by its account contract.
-   * @returns An entrypoint.
-   */
-  public async getAccount(): Promise<AccountInterface> {
-    const nodeInfo = await this.pxe.getNodeInfo();
-    const completeAddress = this.getCompleteAddress();
-    return this.accountContract.getInterface(completeAddress, nodeInfo);
-  }
-
-  /**
-   * 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 getCompleteAddress(): CompleteAddress {
-    if (!this.completeAddress) {
-      const encryptionPublicKey = generatePublicKey(this.encryptionPrivateKey);
-      const contractDeploymentInfo = getContractDeploymentInfo(
-        this.accountContract.getContractArtifact(),
-        this.accountContract.getDeploymentArgs(),
-        this.salt!,
-        encryptionPublicKey,
-      );
-      this.completeAddress = contractDeploymentInfo.completeAddress;
-    }
-    return this.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<AccountWalletWithPrivateKey> {
-    const entrypoint = await this.getAccount();
-    return new AccountWalletWithPrivateKey(this.pxe, entrypoint, this.encryptionPrivateKey);
-  }
-
-  /**
-   * 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.
-   * @param opts - Options to wait for the account to be synched.
-   * @returns A Wallet instance.
-   */
-  public async register(opts: WaitOpts = DefaultWaitOpts): Promise<AccountWalletWithPrivateKey> {
-    const address = await this.#register();
-    await waitForAccountSynch(this.pxe, address, opts);
-    return this.getWallet();
-  }
-
-  /**
-   * Returns the pre-populated deployment method to deploy the account contract that backs this account.
-   * Typically you will not need this method and can call `deploy` directly. Use this for having finer
-   * grained control on when to create, simulate, and send the deployment tx.
-   * @returns A DeployMethod instance that deploys this account contract.
-   */
-  public async getDeployMethod() {
-    if (!this.deployMethod) {
-      if (!this.salt) {
-        throw new Error(`Cannot deploy account contract without known salt.`);
-      }
-      await this.#register();
-      const encryptionPublicKey = this.getEncryptionPublicKey();
-      const deployer = new ContractDeployer(this.accountContract.getContractArtifact(), this.pxe, encryptionPublicKey);
-      const args = this.accountContract.getDeploymentArgs();
-      this.deployMethod = deployer.deploy(...args);
-    }
-    return this.deployMethod;
-  }
-
-  /**
-   * 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 PXE Service before deploying the contract.
-   * @returns A SentTx object that can be waited to get the associated Wallet.
-   */
-  public async deploy(): Promise<DeployAccountSentTx> {
-    const deployMethod = await this.getDeployMethod();
-    const wallet = await this.getWallet();
-    const sentTx = deployMethod.send({ contractAddressSalt: this.salt });
-    return new DeployAccountSentTx(wallet, sentTx.getTxHash());
-  }
-
-  /**
-   * Deploys the account contract that backs this account and awaits the tx to be mined.
-   * 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 PXE Service before deploying the contract.
-   * @param opts - Options to wait for the tx to be mined.
-   * @returns A Wallet instance.
-   */
-  public async waitDeploy(opts: WaitOpts = DefaultWaitOpts): Promise<AccountWalletWithPrivateKey> {
-    await this.deploy().then(tx => tx.wait(opts));
-    return this.getWallet();
-  }
-
-  async #register(): Promise<CompleteAddress> {
-    const completeAddress = this.getCompleteAddress();
-    await this.pxe.registerAccount(this.encryptionPrivateKey, completeAddress.partialAddress);
-    return completeAddress;
-  }
-}

package/src/account/manager/util.ts

@@ -1,29 +0,0 @@
-import { CompleteAddress, PXE, WaitOpts, retryUntil } from '../../index.js';
-
-/**
- * Waits for the account to finish synchronizing with the PXE Service.
- * @param pxe - PXE instance
- * @param address - Address to wait for synch
- * @param opts - Wait options
- */
-export async function waitForAccountSynch(
-  pxe: PXE,
-  address: CompleteAddress,
-  { interval, timeout }: WaitOpts,
-): Promise<void> {
-  const publicKey = address.publicKey.toString();
-  await retryUntil(
-    async () => {
-      const status = await pxe.getSyncStatus();
-      const accountSynchedToBlock = status.notes[publicKey];
-      if (typeof accountSynchedToBlock === 'undefined') {
-        return false;
-      } else {
-        return accountSynchedToBlock >= status.blocks;
-      }
-    },
-    'waitForAccountSynch',
-    timeout,
-    interval,
-  );
-}

package/src/account/utils.ts

@@ -1,47 +0,0 @@
-import { CompleteAddress, GrumpkinScalar } from '@aztec/circuits.js';
-import { PXE } from '@aztec/types';
-
-import { getSchnorrAccount } from '../index.js';
-import { AccountWalletWithPrivateKey } from '../wallet/account_wallet.js';
-
-/**
- * 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(pxe: PXE): Promise<AccountWalletWithPrivateKey> {
-  return getSchnorrAccount(pxe, GrumpkinScalar.random(), GrumpkinScalar.random()).waitDeploy();
-}
-
-/**
- * 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;
-}
-
-/**
- * Creates a given number of random accounts using the Schnorr account wallet.
- * @param pxe - PXE.
- * @param numberOfAccounts - How many accounts to create.
- * @returns The created account wallets.
- */
-export async function createAccounts(pxe: PXE, numberOfAccounts = 1): Promise<AccountWalletWithPrivateKey[]> {
-  const accounts = [];
-
-  // Prepare deployments
-  for (let i = 0; i < numberOfAccounts; ++i) {
-    const account = getSchnorrAccount(pxe, GrumpkinScalar.random(), GrumpkinScalar.random());
-    await account.getDeployMethod().then(d => d.simulate({ contractAddressSalt: account.salt }));
-    accounts.push(account);
-  }
-
-  // Send them and await them to be mined
-  const txs = await Promise.all(accounts.map(account => account.deploy()));
-  await Promise.all(txs.map(tx => tx.wait({ interval: 0.1 })));
-  return Promise.all(accounts.map(account => account.getWallet()));
-}

package/src/api/README.md

@@ -1,7 +0,0 @@
-# API
-
-This provides a more modular api for importing parts of the library as needed.
-The root `index.js` just exposes everything, which can have consequences for startup times and optimizations.
-Here we can gradually build up a much more granular api to allow importing precisely what's needed.
-This should adopt the opposite philosophy to "export all my child exports".
-Every file should (usually) export one thing, and the file/directory structure should be reflected in package.json exports.

package/src/api/abi.ts

@@ -1 +0,0 @@
-export { ContractArtifact, FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';

package/src/api/aztec_address.ts

@@ -1 +0,0 @@
-export { AztecAddress } from '@aztec/foundation/aztec-address';

package/src/api/eth_address.ts

@@ -1 +0,0 @@
-export { EthAddress } from '@aztec/foundation/eth-address';

package/src/api/ethereum.ts

@@ -1,6 +0,0 @@
-export {
-  deployL1Contract,
-  deployL1Contracts,
-  DeployL1Contracts,
-  L1ContractArtifactsForDeployment,
-} from '@aztec/ethereum';

package/src/api/fields.ts

@@ -1 +0,0 @@
-export { Point, Fr, Fq, GrumpkinScalar } from '@aztec/foundation/fields';

package/src/api/init.ts

@@ -1 +0,0 @@
-export { init as initAztecJs } from '@aztec/foundation/crypto';

package/src/api/interfaces/pxe.ts

@@ -1 +0,0 @@
-export { PXE } from '@aztec/types/interfaces';

package/src/api/log_id.ts

@@ -1 +0,0 @@
-export { LogId } from '@aztec/types/log_id';

package/src/api/tx_hash.ts

@@ -1 +0,0 @@
-export { TxHash } from '@aztec/types/tx_hash';