@aztec/accounts 0.22.0 → 0.24.0

package/src/testing/configuration.ts

@@ -0,0 +1,81 @@
+import { generatePublicKey } from '@aztec/aztec.js';
+import { AccountWalletWithPrivateKey } from '@aztec/aztec.js/wallet';
+import { PXE } from '@aztec/circuit-types';
+import { Fr, GrumpkinScalar } from '@aztec/foundation/fields';
+
+import { getSchnorrAccount } from '../schnorr/index.js';
+
+export const INITIAL_TEST_ENCRYPTION_KEYS = [
+  GrumpkinScalar.fromString('2153536ff6628eee01cf4024889ff977a18d9fa61d0e414422f7681cf085c281'),
+  GrumpkinScalar.fromString('aebd1b4be76efa44f5ee655c20bf9ea60f7ae44b9a7fd1fd9f189c7a0b0cdae'),
+  GrumpkinScalar.fromString('0f6addf0da06c33293df974a565b03d1ab096090d907d98055a8b7f4954e120c'),
+];
+
+export const INITIAL_TEST_SIGNING_KEYS = INITIAL_TEST_ENCRYPTION_KEYS;
+
+export const INITIAL_TEST_ACCOUNT_SALTS = [Fr.ZERO, Fr.ZERO, Fr.ZERO];
+
+/**
+ * Gets a collection of wallets for the Aztec accounts that are initially stored in the test environment.
+ * @param pxe - PXE instance.
+ * @returns A set of AccountWallet implementations for each of the initial accounts.
+ */
+export function getInitialTestAccountsWallets(pxe: PXE): Promise<AccountWalletWithPrivateKey[]> {
+  return Promise.all(
+    INITIAL_TEST_ENCRYPTION_KEYS.map((encryptionKey, i) =>
+      getSchnorrAccount(pxe, encryptionKey!, INITIAL_TEST_SIGNING_KEYS[i]!, INITIAL_TEST_ACCOUNT_SALTS[i]).getWallet(),
+    ),
+  );
+}
+
+/**
+ * Queries a PXE for it's registered accounts and returns wallets for those accounts using keys in the initial test accounts.
+ * @param pxe - PXE instance.
+ * @returns A set of AccountWallet implementations for each of the initial accounts.
+ */
+export async function getDeployedTestAccountsWallets(pxe: PXE): Promise<AccountWalletWithPrivateKey[]> {
+  const registeredAccounts = await pxe.getRegisteredAccounts();
+  return Promise.all(
+    INITIAL_TEST_ENCRYPTION_KEYS.filter(initialKey => {
+      const publicKey = generatePublicKey(initialKey);
+      return registeredAccounts.find(registered => registered.publicKey.equals(publicKey)) != undefined;
+    }).map((encryptionKey, i) =>
+      getSchnorrAccount(pxe, encryptionKey!, INITIAL_TEST_SIGNING_KEYS[i]!, INITIAL_TEST_ACCOUNT_SALTS[i]).getWallet(),
+    ),
+  );
+}
+
+/**
+ * Deploys the initial set of schnorr signature accounts to the test environment
+ * @param pxe - PXE instance.
+ * @returns The set of deployed Account objects and associated private encryption keys
+ */
+export async function deployInitialTestAccounts(pxe: PXE) {
+  const accounts = INITIAL_TEST_ENCRYPTION_KEYS.map((privateKey, i) => {
+    const account = getSchnorrAccount(pxe, privateKey, INITIAL_TEST_SIGNING_KEYS[i], INITIAL_TEST_ACCOUNT_SALTS[i]);
+    return {
+      account,
+      privateKey,
+    };
+  });
+  // Attempt to get as much parallelism as possible
+  const deployMethods = await Promise.all(
+    accounts.map(async x => {
+      const deployMethod = await x.account.getDeployMethod();
+      await deployMethod.create({ contractAddressSalt: x.account.salt });
+      await deployMethod.simulate({});
+      return deployMethod;
+    }),
+  );
+  // Send tx together to try and get them in the same rollup
+  const sentTxs = deployMethods.map(dm => {
+    return dm.send();
+  });
+  await Promise.all(
+    sentTxs.map(async (tx, i) => {
+      const wallet = await accounts[i].account.getWallet();
+      return tx.wait({ wallet });
+    }),
+  );
+  return accounts;
+}

package/src/testing/create_account.ts

@@ -0,0 +1,39 @@
+import { AccountWalletWithPrivateKey } from '@aztec/aztec.js/wallet';
+import { PXE } from '@aztec/circuit-types';
+import { GrumpkinScalar } from '@aztec/circuits.js';
+
+import { getSchnorrAccount } from '../schnorr/index.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 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());
+    // Unfortunately the function below is not stateless and we call it here because it takes a long time to run and
+    // the results get stored within the account object. By calling it here we increase the probability of all the
+    // accounts being deployed in the same block because it makes the deploy() method basically instant.
+    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/testing/index.ts

@@ -0,0 +1,11 @@
+/**
+ * The `@aztec/accounts/testing` export provides utility methods for testing, in particular in a Sandbox environment.
+ *
+ * Use the {@link createAccount} and {@link createAccounts} methods to create new sample accounts for testing,
+ * or use {@link getInitialTestAccountsWallets} to obtain a list of wallets for the Sandbox pre-seeded accounts.
+ *
+ * @packageDocumentation
+ */
+
+export * from './create_account.js';
+export * from './configuration.js';