@aztec/end-to-end 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/fixtures/setup_p2p_test.ts

@@ -2,29 +2,28 @@
  * 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 { addLogNameHandler, removeLogNameHandler } from '@aztec/foundation/log';
+import { range } from '@aztec/foundation/array';
+import { SecretValue } from '@aztec/foundation/config';
+import { withLoggerBindings } from '@aztec/foundation/log/server';
+import { bufferToHex } from '@aztec/foundation/string';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { PXEService } from '@aztec/pxe/server';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 
 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;
+// 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 interface NodeContext {
-  node: AztecNodeService;
-  pxeService: PXEService;
-  txs: SentTx[];
-}
+// Global counters for actor naming (start at 1)
+let validatorCounter = 1;
+let nodeCounter = 1;
+let proverCounter = 1;
 
 export function generatePrivateKeys(startIndex: number, numberOfKeys: number): `0x${string}`[] {
   const privateKeys: `0x${string}`[] = [];
@@ -36,89 +35,151 @@ export function generatePrivateKeys(startIndex: number, numberOfKeys: number): `
 }
 
 export async function createNodes(
-  config: AztecNodeConfig,
+  config: AztecNodeConfig & { dontStartSequencer?: boolean },
   dateProvider: DateProvider,
   bootstrapNodeEnr: string,
   numNodes: number,
   bootNodePort: number,
-  prefilledPublicData?: PublicDataTreeLeaf[],
+  genesis?: GenesisData,
   dataDirectory?: string,
   metricsPort?: number,
+  indexOffset = 0,
+  validatorsPerNode = 1,
 ): Promise<AztecNodeService[]> {
   const nodePromises: Promise<AztecNodeService>[] = [];
-  const loggerIdStorage = new AsyncLocalStorage<string>();
-  const logNameHandler = (module: string) =>
-    loggerIdStorage.getStore() ? `${module}:${loggerIdStorage.getStore()}` : module;
-  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,
-      prefilledPublicData,
+      validatorIndices,
+      genesis,
       dataDir,
       metricsPort,
-      loggerIdStorage,
     );
     nodePromises.push(nodePromise);
   }
   const nodes = await Promise.all(nodePromises);
-  removeLogNameHandler(logNameHandler);
+
+  // 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');
+  }
+
   return nodes;
 }
 
-// creates a P2P enabled instance of Aztec Node Service
+/** Extended config type for createNode with test-specific overrides. */
+export type CreateNodeConfig = AztecNodeConfig & {
+  /** Whether to skip starting the sequencer. */
+  dontStartSequencer?: boolean;
+  /** Override the private key (instead of deriving from addressIndex). */
+  validatorPrivateKey?: `0x${string}`;
+  /** Corrupt only the block proposal at this indexWithinCheckpoint (testing only). */
+  invalidBlockProposalIndexWithinCheckpoint?: number;
+  /** Accept proposal gossip regardless of slot timing (testing only). */
+  skipProposalSlotValidation?: boolean;
+};
+
+/** Creates a P2P enabled instance of Aztec Node Service with a validator. */
 export async function createNode(
-  config: AztecNodeConfig,
+  config: CreateNodeConfig,
   dateProvider: DateProvider,
   tcpPort: number,
   bootstrapNode: string | undefined,
-  accountIndex: number,
-  prefilledPublicData?: PublicDataTreeLeaf[],
+  addressIndex: number | number[],
+  genesis?: GenesisData,
   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 });
-  };
-  return loggerIdStorage ? await loggerIdStorage.run(tcpPort.toString(), createNode) : createNode();
+  const actorIndex = validatorCounter++;
+  return await withLoggerBindings({ actor: `validator-${actorIndex}` }, async () => {
+    const validatorConfig = await createValidatorConfig(config, bootstrapNode, tcpPort, addressIndex, dataDirectory);
+    const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
+    return await AztecNodeService.createAndSync(
+      validatorConfig,
+      { telemetry, dateProvider },
+      { genesis, dontStartSequencer: config.dontStartSequencer },
+    );
+  });
 }
 
-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,
+  genesis?: GenesisData,
+  dataDirectory?: string,
+  metricsPort?: number,
+) {
+  const actorIndex = nodeCounter++;
+  return await withLoggerBindings({ actor: `node-${actorIndex}` }, async () => {
+    const p2pConfig = await createP2PConfig(baseConfig, bootstrapNode, tcpPort, dataDirectory);
+    const config: AztecNodeConfig = {
+      ...p2pConfig,
+      disableValidator: true,
+      validatorPrivateKeys: undefined,
+      sequencerPublisherPrivateKeys: [],
+    };
+    const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
+    return await AztecNodeService.createAndSync(config, { telemetry, dateProvider }, { genesis });
+  });
+}
+
+export async function createProverNode(
+  config: AztecNodeConfig,
+  tcpPort: number,
+  bootstrapNode: string | undefined,
+  addressIndex: number,
+  deps: { dateProvider: DateProvider },
+  genesis?: GenesisData,
+  dataDirectory?: string,
+  metricsPort?: number,
+): Promise<{ proverNode: AztecNodeService }> {
+  const actorIndex = proverCounter++;
+  return await withLoggerBindings({ actor: `prover-${actorIndex}` }, async () => {
+    const proverNodePrivateKey = getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex)!;
+    const telemetry = await getEndToEndTestTelemetryClient(metricsPort);
+
+    const p2pConfig = await createP2PConfig(config, bootstrapNode, tcpPort, dataDirectory);
+
+    return await createAndSyncProverNode(
+      bufferToHex(proverNodePrivateKey),
+      { ...config, ...p2pConfig },
+      { dataDirectory },
+      { ...deps, telemetry },
+      { genesis },
+    );
+  });
+}
+
+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 +189,30 @@ export async function createValidatorConfig(
 
   return nodeConfig;
 }
+
+export async function createValidatorConfig(
+  config: CreateNodeConfig,
+  bootstrapNodeEnr?: string,
+  port?: number,
+  addressIndex: number | number[] = 1,
+  dataDirectory?: string,
+) {
+  const addressIndices = Array.isArray(addressIndex) ? addressIndex : [addressIndex];
+  if (addressIndices.length === 0 && !config.validatorPrivateKey) {
+    throw new Error('At least one address index must be provided to create a validator config');
+  }
+
+  // Use override private key if provided, otherwise derive from address indices
+  const attesterPrivateKeys = config.validatorPrivateKey
+    ? [config.validatorPrivateKey]
+    : 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),
+    sequencerPublisherPrivateKeys: [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,
+  });
 
   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,
+  additionalScopes?: AztecAddress[],
 ) {
-  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, additionalScopes });
 }
-// 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 balance = await contractWithWallet.methods.balance_of_private(owner).simulate({ from: owner });
+  const contractWithWallet = TokenContract.at(token.address, wallet);
+  const { result: 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);
+}