@aztec/end-to-end 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/fixtures/setup_p2p_test.ts

@@ -2,29 +2,25 @@
  * Test fixtures and utilities to set up and run a test using multiple validators
  */
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
-import type { SentTx } from '@aztec/aztec.js';
+import { range } from '@aztec/foundation/array';
+import { SecretValue } from '@aztec/foundation/config';
 import { addLogNameHandler, removeLogNameHandler } from '@aztec/foundation/log';
+import { bufferToHex } from '@aztec/foundation/string';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { PXEService } from '@aztec/pxe/server';
+import type { ProverNodeConfig, ProverNodeDeps } from '@aztec/prover-node';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 
 import getPort from 'get-port';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
 import { TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
-import { getPrivateKeyFromIndex } from './utils.js';
+import { createAndSyncProverNode, getPrivateKeyFromIndex } from './utils.js';
 import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 
-// Setup snapshots will create a node with index 0, so all of our loops here
-// need to start from 1 to avoid running validators with the same key
-export const PROPOSER_PRIVATE_KEYS_START_INDEX = 1;
-export const ATTESTER_PRIVATE_KEYS_START_INDEX = 1001;
-
-export interface NodeContext {
-  node: AztecNodeService;
-  pxeService: PXEService;
-  txs: SentTx[];
-}
+// Setup snapshots will create a node with index 0, and run extra bootstrap with
+// index 1, and prover node with index 2, so all of our loops here need to start from 3
+// to avoid running validators with the same key
+export const ATTESTER_PRIVATE_KEYS_START_INDEX = 3;
 
 export function generatePrivateKeys(startIndex: number, numberOfKeys: number): `0x${string}`[] {
   const privateKeys: `0x${string}`[] = [];
@@ -36,7 +32,7 @@ export function generatePrivateKeys(startIndex: number, numberOfKeys: number): `
 }
 
 export async function createNodes(
-  config: AztecNodeConfig,
+  config: AztecNodeConfig & { dontStartSequencer?: boolean },
   dateProvider: DateProvider,
   bootstrapNodeEnr: string,
   numNodes: number,
@@ -44,6 +40,8 @@ export async function createNodes(
   prefilledPublicData?: PublicDataTreeLeaf[],
   dataDirectory?: string,
   metricsPort?: number,
+  indexOffset = 0,
+  validatorsPerNode = 1,
 ): Promise<AztecNodeService[]> {
   const nodePromises: Promise<AztecNodeService>[] = [];
   const loggerIdStorage = new AsyncLocalStorage<string>();
@@ -52,16 +50,22 @@ export async function createNodes(
   addLogNameHandler(logNameHandler);
 
   for (let i = 0; i < numNodes; i++) {
+    const index = indexOffset + i;
     // We run on ports from the bootnode upwards
-    const port = bootNodePort + i + 1;
+    const port = bootNodePort + 1 + index;
+
+    // Determine validator indices for this node
+    const validatorIndices = validatorsPerNode === 1 ? index : range(validatorsPerNode, validatorsPerNode * index);
+
+    // Assign data directory
+    const dataDir = dataDirectory ? `${dataDirectory}-${index}` : undefined;
 
-    const dataDir = dataDirectory ? `${dataDirectory}-${i}` : undefined;
     const nodePromise = createNode(
       config,
       dateProvider,
       port,
       bootstrapNodeEnr,
-      i,
+      validatorIndices,
       prefilledPublicData,
       dataDir,
       metricsPort,
@@ -70,55 +74,113 @@ export async function createNodes(
     nodePromises.push(nodePromise);
   }
   const nodes = await Promise.all(nodePromises);
+
+  // Sanity check that we have a sequencer if required
+  const seqClient = nodes[0].getSequencer();
+  if (!seqClient && config.disableValidator === false) {
+    throw new Error('Sequencer not found');
+  }
+
   removeLogNameHandler(logNameHandler);
   return nodes;
 }
 
-// creates a P2P enabled instance of Aztec Node Service
+/** Creates a P2P enabled instance of Aztec Node Service with a validator */
 export async function createNode(
-  config: AztecNodeConfig,
+  config: AztecNodeConfig & { dontStartSequencer?: boolean },
   dateProvider: DateProvider,
   tcpPort: number,
   bootstrapNode: string | undefined,
-  accountIndex: number,
+  addressIndex: number | number[],
   prefilledPublicData?: PublicDataTreeLeaf[],
   dataDirectory?: string,
   metricsPort?: number,
   loggerIdStorage?: AsyncLocalStorage<string>,
 ) {
   const createNode = async () => {
-    const validatorConfig = await createValidatorConfig(config, bootstrapNode, tcpPort, accountIndex, dataDirectory);
-    const telemetry = getEndToEndTestTelemetryClient(metricsPort);
-    return await AztecNodeService.createAndSync(validatorConfig, { telemetry, dateProvider }, { prefilledPublicData });
+    const validatorConfig = await createValidatorConfig(config, bootstrapNode, tcpPort, addressIndex, dataDirectory);
+    const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
+    return await AztecNodeService.createAndSync(
+      validatorConfig,
+      { telemetry, dateProvider },
+      { prefilledPublicData, dontStartSequencer: config.dontStartSequencer },
+    );
   };
   return loggerIdStorage ? await loggerIdStorage.run(tcpPort.toString(), createNode) : createNode();
 }
 
-export async function createValidatorConfig(
+/** Creates a P2P enabled instance of Aztec Node Service without a validator */
+export async function createNonValidatorNode(
+  baseConfig: AztecNodeConfig,
+  dateProvider: DateProvider,
+  tcpPort: number,
+  bootstrapNode: string | undefined,
+  prefilledPublicData?: PublicDataTreeLeaf[],
+  dataDirectory?: string,
+  metricsPort?: number,
+  loggerIdStorage?: AsyncLocalStorage<string>,
+) {
+  const createNode = async () => {
+    const p2pConfig = await createP2PConfig(baseConfig, bootstrapNode, tcpPort, dataDirectory);
+    const config: AztecNodeConfig = {
+      ...p2pConfig,
+      disableValidator: true,
+      validatorPrivateKeys: undefined,
+      publisherPrivateKeys: [],
+    };
+    const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
+    return await AztecNodeService.createAndSync(config, { telemetry, dateProvider }, { prefilledPublicData });
+  };
+  return loggerIdStorage ? await loggerIdStorage.run(tcpPort.toString(), createNode) : createNode();
+}
+
+export async function createProverNode(
+  config: AztecNodeConfig,
+  tcpPort: number,
+  bootstrapNode: string | undefined,
+  addressIndex: number,
+  proverNodeDeps: ProverNodeDeps & Required<Pick<ProverNodeDeps, 'dateProvider'>>,
+  prefilledPublicData?: PublicDataTreeLeaf[],
+  dataDirectory?: string,
+  metricsPort?: number,
+  loggerIdStorage?: AsyncLocalStorage<string>,
+) {
+  const createProverNode = async () => {
+    const proverNodePrivateKey = getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex)!;
+    const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
+
+    const proverConfig: Partial<ProverNodeConfig> = await createP2PConfig(
+      config,
+      bootstrapNode,
+      tcpPort,
+      dataDirectory,
+    );
+
+    const aztecNodeRpcTxProvider = undefined;
+    return await createAndSyncProverNode(
+      bufferToHex(proverNodePrivateKey),
+      config,
+      { ...proverConfig, dataDirectory },
+      aztecNodeRpcTxProvider,
+      prefilledPublicData,
+      { ...proverNodeDeps, telemetry },
+    );
+  };
+  return loggerIdStorage ? await loggerIdStorage.run(tcpPort.toString(), createProverNode) : createProverNode();
+}
+
+export async function createP2PConfig(
   config: AztecNodeConfig,
   bootstrapNodeEnr?: string,
   port?: number,
-  accountIndex: number = 1,
   dataDirectory?: string,
 ) {
   port = port ?? (await getPort());
 
-  const attesterPrivateKey: `0x${string}` = `0x${getPrivateKeyFromIndex(
-    ATTESTER_PRIVATE_KEYS_START_INDEX + accountIndex,
-  )!.toString('hex')}`;
-  const proposerPrivateKey: `0x${string}` = `0x${getPrivateKeyFromIndex(
-    PROPOSER_PRIVATE_KEYS_START_INDEX + accountIndex,
-  )!.toString('hex')}`;
-
-  config.validatorPrivateKey = attesterPrivateKey;
-  config.publisherPrivateKey = proposerPrivateKey;
-
   const nodeConfig: AztecNodeConfig = {
     ...config,
-    udpListenAddress: `0.0.0.0:${port}`,
-    tcpListenAddress: `0.0.0.0:${port}`,
-    tcpAnnounceAddress: `127.0.0.1:${port}`,
-    udpAnnounceAddress: `127.0.0.1:${port}`,
+    p2pIp: `127.0.0.1`,
+    p2pPort: port,
     p2pEnabled: true,
     peerCheckIntervalMS: TEST_PEER_CHECK_INTERVAL_MS,
     blockCheckIntervalMS: 1000,
@@ -128,3 +190,29 @@ export async function createValidatorConfig(
 
   return nodeConfig;
 }
+
+export async function createValidatorConfig(
+  config: AztecNodeConfig,
+  bootstrapNodeEnr?: string,
+  port?: number,
+  addressIndex: number | number[] = 1,
+  dataDirectory?: string,
+) {
+  const addressIndices = Array.isArray(addressIndex) ? addressIndex : [addressIndex];
+  if (addressIndices.length === 0) {
+    throw new Error('At least one address index must be provided to create a validator config');
+  }
+
+  const attesterPrivateKeys = addressIndices.map(index =>
+    bufferToHex(getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + index)!),
+  );
+  const p2pConfig = await createP2PConfig(config, bootstrapNodeEnr, port, dataDirectory);
+  const nodeConfig: AztecNodeConfig = {
+    ...config,
+    ...p2pConfig,
+    validatorPrivateKeys: new SecretValue(attesterPrivateKeys),
+    publisherPrivateKeys: [new SecretValue(attesterPrivateKeys[0])],
+  };
+
+  return nodeConfig;
+}

package/src/fixtures/token_utils.ts

@@ -1,34 +1,33 @@
-// docs:start:token_utils
-import type { AztecAddress, Logger, Wallet } from '@aztec/aztec.js';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { BatchCall } from '@aztec/aztec.js/contracts';
+import type { Logger } from '@aztec/aztec.js/log';
+import type { Wallet } from '@aztec/aztec.js/wallet';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
-export async function deployToken(adminWallet: Wallet, initialAdminBalance: bigint, logger: Logger) {
+export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger) {
   logger.info(`Deploying Token contract...`);
-  const contract = await TokenContract.deploy(adminWallet, adminWallet.getAddress(), 'TokenName', 'TokenSymbol', 18)
-    .send()
-    .deployed();
+  const { contract, instance } = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
+    from: admin,
+    wait: { returnReceipt: true },
+  });
 
   if (initialAdminBalance > 0n) {
-    // Minter is minting to herself so contract as minter is the same as contract as recipient
-    await mintTokensToPrivate(contract, adminWallet, adminWallet.getAddress(), initialAdminBalance);
+    await mintTokensToPrivate(contract, admin, admin, initialAdminBalance);
   }
 
   logger.info('L2 contract deployed');
 
-  return contract;
+  return { contract, instance };
 }
 
 export async function mintTokensToPrivate(
   token: TokenContract,
-  minterWallet: Wallet,
+  minter: AztecAddress,
   recipient: AztecAddress,
   amount: bigint,
 ) {
-  const tokenAsMinter = await TokenContract.at(token.address, minterWallet);
-  const from = minterWallet.getAddress(); // we are setting from to minter here because we need a sender to calculate the tag
-  await tokenAsMinter.methods.mint_to_private(from, recipient, amount).send().wait();
+  await token.methods.mint_to_private(recipient, amount).send({ from: minter });
 }
-// docs:end:token_utils
 
 export async function expectTokenBalance(
   wallet: Wallet,
@@ -38,8 +37,27 @@ export async function expectTokenBalance(
   logger: Logger,
 ) {
   // Then check the balance
-  const contractWithWallet = await TokenContract.at(token.address, wallet);
+  const contractWithWallet = TokenContract.at(token.address, wallet);
   const balance = await contractWithWallet.methods.balance_of_private(owner).simulate({ from: owner });
   logger.info(`Account ${owner} balance: ${balance}`);
   expect(balance).toBe(expectedBalance);
 }
+
+export async function mintNotes(
+  wallet: Wallet,
+  minter: AztecAddress,
+  recipient: AztecAddress,
+  asset: TokenContract,
+  noteAmounts: bigint[],
+): Promise<bigint> {
+  // We can only mint 5 notes at a time, since that's the maximum number of calls our entrypoints allow
+  // TODO(#13024): mint as many notes as possible in a single tx
+  const notesPerIteration = 5;
+  for (let mintedNotes = 0; mintedNotes < noteAmounts.length; mintedNotes += notesPerIteration) {
+    const toMint = noteAmounts.slice(mintedNotes, mintedNotes + notesPerIteration);
+    const actions = toMint.map(amt => asset.methods.mint_to_private(recipient, amt));
+    await new BatchCall(wallet, actions).send({ from: minter });
+  }
+
+  return noteAmounts.reduce((prev, curr) => prev + curr, 0n);
+}