@aztec/accounts 0.0.0-test.0

package/src/testing/create_account.ts

@@ -0,0 +1,93 @@
+import { type AccountManager, FeeJuicePaymentMethod, type PXE, type WaitOpts } from '@aztec/aztec.js';
+import { Fr } from '@aztec/foundation/fields';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+
+import { getSchnorrAccount, getSchnorrAccountContractAddress } from '../schnorr/index.js';
+import type { InitialAccountData } from './configuration.js';
+
+/**
+ * Generate a fixed amount of random schnorr account contract instance.
+ */
+export async function generateSchnorrAccounts(numberOfAccounts: number) {
+  const secrets = Array.from({ length: numberOfAccounts }, () => Fr.random());
+  return await Promise.all(
+    secrets.map(async secret => {
+      const salt = Fr.random();
+      return {
+        secret,
+        signingKey: deriveSigningKey(secret),
+        salt,
+        address: await getSchnorrAccountContractAddress(secret, salt),
+      };
+    }),
+  );
+}
+
+/**
+ * Data for deploying funded account.
+ */
+type DeployAccountData = Pick<InitialAccountData, 'secret' | 'salt'> & {
+  /**
+   * An optional signingKey if it's not derived from the secret.
+   */
+  signingKey?: InitialAccountData['signingKey'];
+};
+
+/**
+ * Deploy schnorr account contract.
+ * It will pay for the fee for the deployment itself. So it must be funded with the prefilled public data.
+ */
+export async function deployFundedSchnorrAccount(
+  pxe: PXE,
+  account: DeployAccountData,
+  opts: WaitOpts & {
+    /**
+     * Whether or not to skip registering contract class.
+     */
+    skipClassRegistration?: boolean;
+  } = { interval: 0.1, skipClassRegistration: false },
+): Promise<AccountManager> {
+  const signingKey = account.signingKey ?? deriveSigningKey(account.secret);
+  const accountManager = await getSchnorrAccount(pxe, account.secret, signingKey, account.salt);
+
+  // Pay the fee by the account itself.
+  // This only works when the world state is prefilled with the balance for the account in test environment.
+  const paymentMethod = new FeeJuicePaymentMethod(accountManager.getAddress());
+
+  await accountManager
+    .deploy({
+      skipClassRegistration: opts.skipClassRegistration,
+      skipPublicDeployment: true,
+      fee: { paymentMethod },
+    })
+    .wait(opts);
+
+  return accountManager;
+}
+
+/**
+ * Deploy schnorr account contracts.
+ * They will pay for the fees for the deployment themselves. So they must be funded with the prefilled public data.
+ */
+export async function deployFundedSchnorrAccounts(
+  pxe: PXE,
+  accounts: DeployAccountData[],
+  opts: WaitOpts & {
+    /**
+     * Whether or not to skip registering contract class.
+     */
+    skipClassRegistration?: boolean;
+  } = { interval: 0.1, skipClassRegistration: false },
+): Promise<AccountManager[]> {
+  const accountManagers: AccountManager[] = [];
+  // Serial due to https://github.com/AztecProtocol/aztec-packages/issues/12045
+  for (let i = 0; i < accounts.length; i++) {
+    accountManagers.push(
+      await deployFundedSchnorrAccount(pxe, accounts[i], {
+        ...opts,
+        skipClassRegistration: i !== 0 || opts.skipClassRegistration, // Register the contract class at most once.
+      }),
+    );
+  }
+  return accountManagers;
+}

package/src/testing/index.ts

@@ -0,0 +1,92 @@
+/**
+ * The `@aztec/accounts/testing` export provides utility methods for testing, in particular in a Sandbox environment.
+ *
+ * Use {@link getInitialTestAccountsWallets} to obtain a list of wallets for the Sandbox pre-seeded accounts.
+ *
+ * @packageDocumentation
+ */
+import type { PXE } from '@aztec/aztec.js';
+import type { AccountWalletWithSecretKey } from '@aztec/aztec.js/wallet';
+
+import {
+  getSchnorrAccount,
+  getSchnorrAccountContractAddress,
+  getSchnorrWalletWithSecretKey,
+} from '../schnorr/index.js';
+import type { InitialAccountData } from './configuration.js';
+import {
+  INITIAL_TEST_ACCOUNT_SALTS,
+  INITIAL_TEST_ENCRYPTION_KEYS,
+  INITIAL_TEST_SECRET_KEYS,
+  INITIAL_TEST_SIGNING_KEYS,
+} from './configuration.js';
+
+export {
+  type InitialAccountData,
+  INITIAL_TEST_ACCOUNT_SALTS,
+  INITIAL_TEST_ENCRYPTION_KEYS,
+  INITIAL_TEST_SECRET_KEYS,
+  INITIAL_TEST_SIGNING_KEYS,
+} from './configuration.js';
+
+/**
+ * Gets the basic information for initial test accounts.
+ */
+export function getInitialTestAccounts(): Promise<InitialAccountData[]> {
+  return Promise.all(
+    INITIAL_TEST_SECRET_KEYS.map(async (secret, i) => ({
+      secret,
+      signingKey: INITIAL_TEST_ENCRYPTION_KEYS[i],
+      salt: INITIAL_TEST_ACCOUNT_SALTS[i],
+      address: await getSchnorrAccountContractAddress(
+        secret,
+        INITIAL_TEST_ACCOUNT_SALTS[i],
+        INITIAL_TEST_SIGNING_KEYS[i],
+      ),
+    })),
+  );
+}
+
+/**
+ * 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<AccountWalletWithSecretKey[]> {
+  return Promise.all(
+    INITIAL_TEST_SECRET_KEYS.map(async (encryptionKey, i) => {
+      const account = await getSchnorrAccount(
+        pxe,
+        encryptionKey!,
+        INITIAL_TEST_SIGNING_KEYS[i]!,
+        INITIAL_TEST_ACCOUNT_SALTS[i],
+      );
+      return account.getWallet();
+    }),
+  );
+}
+
+/**
+ * Queries a PXE for it's registered accounts.
+ * @param pxe - PXE instance.
+ * @returns A set of key data for each of the initial accounts.
+ */
+export async function getDeployedTestAccounts(pxe: PXE): Promise<InitialAccountData[]> {
+  const registeredAccounts = await pxe.getRegisteredAccounts();
+  const testAccounts = await getInitialTestAccounts();
+  return testAccounts.filter(t => registeredAccounts.some(r => r.address.equals(t.address)));
+}
+
+/**
+ * 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<AccountWalletWithSecretKey[]> {
+  const testAccounts = await getDeployedTestAccounts(pxe);
+  return Promise.all(
+    testAccounts.map(({ secret, signingKey, salt }) => getSchnorrWalletWithSecretKey(pxe, secret, signingKey, salt)),
+  );
+}
+
+export { deployFundedSchnorrAccount, deployFundedSchnorrAccounts, generateSchnorrAccounts } from './create_account.js';

package/src/testing/lazy.ts

@@ -0,0 +1,86 @@
+/**
+ * The `@aztec/accounts/testing/lazy` export provides utility methods for testing, in particular in a Sandbox environment.
+ *
+ * Use {@link getInitialTestAccountsWallets} to obtain a list of wallets for the Sandbox pre-seeded accounts.
+ *
+ * @packageDocumentation
+ */
+import type { PXE } from '@aztec/aztec.js';
+import type { AccountWalletWithSecretKey } from '@aztec/aztec.js/wallet';
+
+import { getSchnorrAccount, getSchnorrAccountContractAddress, getSchnorrWalletWithSecretKey } from '../schnorr/lazy.js';
+import {
+  INITIAL_TEST_ACCOUNT_SALTS,
+  INITIAL_TEST_ENCRYPTION_KEYS,
+  INITIAL_TEST_SECRET_KEYS,
+  INITIAL_TEST_SIGNING_KEYS,
+  type InitialAccountData,
+} from './configuration.js';
+
+export {
+  type InitialAccountData,
+  INITIAL_TEST_ACCOUNT_SALTS,
+  INITIAL_TEST_ENCRYPTION_KEYS,
+  INITIAL_TEST_SECRET_KEYS,
+  INITIAL_TEST_SIGNING_KEYS,
+} from './configuration.js';
+
+/**
+ * Gets the basic information for initial test accounts.
+ */
+export function getInitialTestAccounts(): Promise<InitialAccountData[]> {
+  return Promise.all(
+    INITIAL_TEST_SECRET_KEYS.map(async (secret, i) => ({
+      secret,
+      signingKey: INITIAL_TEST_ENCRYPTION_KEYS[i],
+      salt: INITIAL_TEST_ACCOUNT_SALTS[i],
+      address: await getSchnorrAccountContractAddress(
+        secret,
+        INITIAL_TEST_ACCOUNT_SALTS[i],
+        INITIAL_TEST_SIGNING_KEYS[i],
+      ),
+    })),
+  );
+}
+
+/**
+ * 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<AccountWalletWithSecretKey[]> {
+  return Promise.all(
+    INITIAL_TEST_SECRET_KEYS.map(async (encryptionKey, i) => {
+      const account = await getSchnorrAccount(
+        pxe,
+        encryptionKey!,
+        INITIAL_TEST_SIGNING_KEYS[i]!,
+        INITIAL_TEST_ACCOUNT_SALTS[i],
+      );
+      return account.getWallet();
+    }),
+  );
+}
+
+/**
+ * Queries a PXE for it's registered accounts.
+ * @param pxe - PXE instance.
+ * @returns A set of key data for each of the initial accounts.
+ */
+export async function getDeployedTestAccounts(pxe: PXE): Promise<InitialAccountData[]> {
+  const registeredAccounts = await pxe.getRegisteredAccounts();
+  const testAccounts = await getInitialTestAccounts();
+  return testAccounts.filter(t => registeredAccounts.some(r => r.address.equals(t.address)));
+}
+
+/**
+ * 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<AccountWalletWithSecretKey[]> {
+  const testAccounts = await getDeployedTestAccounts(pxe);
+  return Promise.all(
+    testAccounts.map(({ secret, signingKey, salt }) => getSchnorrWalletWithSecretKey(pxe, secret, signingKey, salt)),
+  );
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './ssh_agent.js';

package/src/utils/ssh_agent.ts

@@ -0,0 +1,136 @@
+import { Buffer } from 'buffer';
+import net from 'net';
+
+const SSH_AGENT_IDENTITIES_REQUEST = 11;
+const SSH_AGENT_IDENTITIES_RESPONSE = 12;
+const SSH_AGENT_SIGN_REQUEST = 13;
+const SSH_AGENT_SIGN_RESPONSE = 14;
+
+/**
+ * Connect to the SSH agent via a TCP socket using the standard env variable
+ */
+export function connectToAgent() {
+  const socketPath = process.env.SSH_AUTH_SOCK;
+  if (!socketPath) {
+    throw new Error('SSH_AUTH_SOCK is not set');
+  }
+  return net.connect(socketPath);
+}
+
+/**
+ * Type representing a stored key in the SSH agent.
+ */
+type StoredKey = {
+  /**
+   * Type of the key.
+   */
+  type: string;
+  /**
+   * Public key in base64 encoding.
+   */
+  publicKey: string;
+  /**
+   * Comment associated with the key.
+   */
+  comment: string;
+};
+
+/**
+ * Retrieve the identities stored in the SSH agent.
+ */
+export function getIdentities(): Promise<StoredKey[]> {
+  return new Promise((resolve, reject) => {
+    const stream = connectToAgent();
+    stream.on('connect', () => {
+      const request = Buffer.concat([
+        Buffer.from([0, 0, 0, 5 + 4]), // length
+        Buffer.from([SSH_AGENT_IDENTITIES_REQUEST]),
+        Buffer.from([0, 0, 0, 0]), // flags
+      ]);
+
+      stream.write(request);
+    });
+
+    stream.on('data', data => {
+      const responseType = data[4];
+      if (responseType === SSH_AGENT_IDENTITIES_RESPONSE) {
+        let offset = 5;
+        const numKeys = data.readUInt32BE(offset);
+        offset += 4;
+
+        const keys = [];
+        for (let i = 0; i < numKeys; i++) {
+          const keyLength = data.readUInt32BE(offset);
+          offset += 4;
+          const key = data.subarray(offset, offset + keyLength);
+          offset += keyLength;
+          const commentLength = data.readUInt32BE(offset);
+          offset += 4;
+          const comment = data.subarray(offset, offset + commentLength);
+          offset += commentLength;
+
+          let keyOffset = 0;
+          const typeLen = key.readUInt32BE(keyOffset);
+          keyOffset += 4;
+          const type = key.subarray(keyOffset, keyOffset + typeLen);
+
+          keys.push({
+            type: type.toString('ascii'),
+            publicKey: key.toString('base64'),
+            comment: comment.toString('utf8'),
+          });
+        }
+        stream.end();
+        resolve(keys);
+      } else {
+        stream.end();
+        reject(`Unexpected response type: ${responseType}`);
+      }
+    });
+  });
+}
+
+/**
+ * Sign data using a key stored in the SSH agent. The private signing key is identified by its corresponding public key.
+ */
+export function signWithAgent(keyType: Buffer, curveName: Buffer, publicKey: Buffer, data: Buffer) {
+  return new Promise<Buffer>((resolve, reject) => {
+    const stream = connectToAgent();
+    stream.on('connect', () => {
+      // Construct the key blob
+      const keyBlob = Buffer.concat([
+        Buffer.from([0, 0, 0, keyType.length]),
+        keyType,
+        Buffer.from([0, 0, 0, curveName.length]),
+        curveName,
+        Buffer.from([0, 0, 0, publicKey.length + 1, 4]),
+        publicKey,
+      ]);
+      const request = Buffer.concat([
+        Buffer.from([0, 0, 0, 5 + keyBlob.length + 4 + data.length + 4]), // length
+        Buffer.from([SSH_AGENT_SIGN_REQUEST]),
+        Buffer.from([0, 0, 0, keyBlob.length]), // key blob length
+        keyBlob,
+        Buffer.from([0, 0, 0, data.length]), // data length
+        data,
+        Buffer.from([0, 0, 0, 0]), // flags
+      ]);
+
+      stream.write(request);
+    });
+
+    stream.on('data', data => {
+      const type = data[4];
+
+      if (type === SSH_AGENT_SIGN_RESPONSE) {
+        const signatureLength = data.readUInt32BE(5);
+        const signature = data.subarray(9, 9 + signatureLength);
+        stream.end();
+        resolve(signature);
+      } else {
+        stream.end();
+        reject(`Unexpected response type: ${type}`);
+      }
+    });
+  });
+}