@aztec/end-to-end 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.77.0-testnet-ignition.21

package/src/spartan/utils.ts

@@ -1,9 +1,9 @@
 import { createAztecNodeClient, createLogger, sleep } from '@aztec/aztec.js';
-import { type RollupCheatCodes } from '@aztec/aztec.js/ethereum';
+import type { RollupCheatCodes } from '@aztec/aztec.js/ethereum';
 import type { Logger } from '@aztec/foundation/log';
 import type { SequencerConfig } from '@aztec/sequencer-client';
 
-import { exec, execSync, spawn } from 'child_process';
+import { ChildProcess, exec, execSync, spawn } from 'child_process';
 import path from 'path';
 import { promisify } from 'util';
 import { z } from 'zod';
@@ -14,20 +14,38 @@ const execAsync = promisify(exec);
 
 const logger = createLogger('e2e:k8s-utils');
 
+const ethereumHostsSchema = z.string().refine(
+  str =>
+    str.split(',').every(url => {
+      try {
+        new URL(url.trim());
+        return true;
+      } catch {
+        return false;
+      }
+    }),
+  'ETHEREUM_HOSTS must be a comma-separated list of valid URLs',
+);
+
 const k8sLocalConfigSchema = z.object({
+  ETHEREUM_SLOT_DURATION: z.coerce.number().min(1, 'ETHEREUM_SLOT_DURATION env variable must be set'),
+  AZTEC_SLOT_DURATION: z.coerce.number().min(1, 'AZTEC_SLOT_DURATION env variable must be set'),
+  AZTEC_EPOCH_DURATION: z.coerce.number().min(1, 'AZTEC_EPOCH_DURATION env variable must be set'),
+  AZTEC_PROOF_SUBMISSION_WINDOW: z.coerce.number().min(1, 'AZTEC_PROOF_SUBMISSION_WINDOW env variable must be set'),
   INSTANCE_NAME: z.string().min(1, 'INSTANCE_NAME env variable must be set'),
   NAMESPACE: z.string().min(1, 'NAMESPACE env variable must be set'),
-  HOST_NODE_PORT: z.coerce.number().min(1, 'HOST_NODE_PORT env variable must be set'),
   CONTAINER_NODE_PORT: z.coerce.number().default(8080),
-  HOST_PXE_PORT: z.coerce.number().min(1, 'HOST_PXE_PORT env variable must be set'),
+  CONTAINER_SEQUENCER_PORT: z.coerce.number().default(8080),
+  CONTAINER_PROVER_NODE_PORT: z.coerce.number().default(8080),
   CONTAINER_PXE_PORT: z.coerce.number().default(8080),
-  HOST_ETHEREUM_PORT: z.coerce.number().min(1, 'HOST_ETHEREUM_PORT env variable must be set'),
   CONTAINER_ETHEREUM_PORT: z.coerce.number().default(8545),
-  HOST_METRICS_PORT: z.coerce.number().min(1, 'HOST_METRICS_PORT env variable must be set'),
   CONTAINER_METRICS_PORT: z.coerce.number().default(80),
   GRAFANA_PASSWORD: z.string().optional(),
   METRICS_API_PATH: z.string().default('/api/datasources/proxy/uid/spartan-metrics-prometheus/api/v1'),
   SPARTAN_DIR: z.string().min(1, 'SPARTAN_DIR env variable must be set'),
+  ETHEREUM_HOSTS: ethereumHostsSchema.optional(),
+  L1_ACCOUNT_MNEMONIC: z.string().default('test test test test test test test test test test test junk'),
+  SEPOLIA_RUN: z.string().default('false'),
   K8S: z.literal('local'),
 });
 
@@ -40,7 +58,7 @@ const k8sGCloudConfigSchema = k8sLocalConfigSchema.extend({
 const directConfigSchema = z.object({
   PXE_URL: z.string().url('PXE_URL must be a valid URL'),
   NODE_URL: z.string().url('NODE_URL must be a valid URL'),
-  ETHEREUM_HOST: z.string().url('ETHEREUM_HOST must be a valid URL'),
+  ETHEREUM_HOSTS: ethereumHostsSchema,
   K8S: z.literal('false'),
 });
 
@@ -77,49 +95,73 @@ export async function startPortForward({
   resource: string;
   namespace: string;
   containerPort: number;
-  hostPort: number;
-}) {
-  // check if kubectl is already forwarding this port
-  try {
-    const command = `ps aux | grep 'kubectl.*${hostPort}:${containerPort}' | grep -v grep | awk '{print $2}'`;
-    const { stdout: processId } = await execAsync(command);
-    if (processId) {
-      logger.info(`Restarting port forward for ${resource}:${hostPort}`);
-      // kill the existing port forward
-      await execAsync(`kill -9 ${processId}`);
-    }
-  } catch (e) {
-    logger.info(`No existing port forward found for ${resource}:${hostPort}`);
-  }
-
-  logger.info(`kubectl port-forward -n ${namespace} ${resource} ${hostPort}:${containerPort}`);
-
-  const process = spawn('kubectl', ['port-forward', '-n', namespace, resource, `${hostPort}:${containerPort}`], {
-    detached: true,
-    windowsHide: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  process.stdout?.on('data', data => {
-    const str = data.toString();
-    if (str.includes('Starting port forward')) {
-      logger.info(str);
-    } else {
-      logger.debug(str);
-    }
-  });
-  process.stderr?.on('data', data => {
-    // It's a strange thing:
-    // If we don't pipe stderr, then the port forwarding does not work.
-    // Log to silent because this doesn't actually report errors,
-    // just extremely verbose debug logs.
-    logger.silent(data.toString());
+  // If not provided, the port will be chosen automatically
+  hostPort?: number;
+}): Promise<{
+  process: ChildProcess;
+  port: number;
+}> {
+  const hostPortAsString = hostPort ? hostPort.toString() : '';
+
+  logger.info(`kubectl port-forward -n ${namespace} ${resource} ${hostPortAsString}:${containerPort}`);
+
+  const process = spawn(
+    'kubectl',
+    ['port-forward', '-n', namespace, resource, `${hostPortAsString}:${containerPort}`],
+    {
+      detached: true,
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  let isResolved = false;
+  const connected = new Promise<number>(resolve => {
+    process.stdout?.on('data', data => {
+      const str = data.toString() as string;
+      if (!isResolved && str.includes('Forwarding from')) {
+        isResolved = true;
+        logger.info(str);
+        const port = str.search(/:\d+/);
+        if (port === -1) {
+          throw new Error('Port not found in port forward output');
+        }
+        const portNumber = parseInt(str.slice(port + 1));
+        logger.info(`Port forward connected: ${portNumber}`);
+        logger.info(`Port forward connected: ${portNumber}`);
+        resolve(portNumber);
+      } else {
+        logger.silent(str);
+      }
+    });
+    process.stderr?.on('data', data => {
+      logger.info(data.toString());
+      // It's a strange thing:
+      // If we don't pipe stderr, then the port forwarding does not work.
+      // Log to silent because this doesn't actually report errors,
+      // just extremely verbose debug logs.
+      logger.silent(data.toString());
+    });
+    process.on('close', () => {
+      if (!isResolved) {
+        isResolved = true;
+        logger.warn('Port forward closed before connection established');
+        resolve(0);
+      }
+    });
+    process.on('error', error => {
+      logger.error(`Port forward error: ${error}`);
+      resolve(0);
+    });
+    process.on('exit', code => {
+      logger.info(`Port forward exited with code ${code}`);
+      resolve(0);
+    });
   });
 
-  // Wait a moment for the port forward to establish
-  await new Promise(resolve => setTimeout(resolve, 2000));
+  const port = await connected;
 
-  return process;
+  return { process, port };
 }
 
 export async function deleteResourceByName({
@@ -305,6 +347,44 @@ export function applyProverFailure({
   });
 }
 
+export function applyProverKill({
+  namespace,
+  spartanDir,
+  logger,
+}: {
+  namespace: string;
+  spartanDir: string;
+  logger: Logger;
+}) {
+  return installChaosMeshChart({
+    instanceName: 'prover-kill',
+    targetNamespace: namespace,
+    valuesFile: 'prover-kill.yaml',
+    helmChartDir: getChartDir(spartanDir, 'aztec-chaos-scenarios'),
+    clean: true,
+    logger,
+  });
+}
+
+export function applyProverBrokerKill({
+  namespace,
+  spartanDir,
+  logger,
+}: {
+  namespace: string;
+  spartanDir: string;
+  logger: Logger;
+}) {
+  return installChaosMeshChart({
+    instanceName: 'prover-broker-kill',
+    targetNamespace: namespace,
+    valuesFile: 'prover-broker-kill.yaml',
+    helmChartDir: getChartDir(spartanDir, 'aztec-chaos-scenarios'),
+    clean: true,
+    logger,
+  });
+}
+
 export function applyBootNodeFailure({
   namespace,
   spartanDir,
@@ -419,11 +499,17 @@ export async function enableValidatorDynamicBootNode(
 
 export async function runAlertCheck(config: EnvConfig, alerts: AlertConfig[], logger: Logger) {
   if (isK8sConfig(config)) {
+    const { process, port } = await startPortForward({
+      resource: `svc/metrics-grafana`,
+      namespace: 'metrics',
+      containerPort: config.CONTAINER_METRICS_PORT,
+    });
     const alertChecker = new AlertChecker(logger, {
-      grafanaEndpoint: `http://localhost:${config.HOST_METRICS_PORT}${config.METRICS_API_PATH}`,
+      grafanaEndpoint: `http://localhost:${port}${config.METRICS_API_PATH}`,
       grafanaCredentials: `admin:${config.GRAFANA_PASSWORD}`,
     });
     await alertChecker.runAlertCheck(alerts);
+    process.kill();
   } else {
     logger.info('Not running alert check in non-k8s environment');
   }
@@ -442,22 +528,21 @@ export async function getSequencers(namespace: string) {
 
 export async function updateK8sSequencersConfig(args: {
   containerPort: number;
-  hostPort: number;
   namespace: string;
   config: Partial<SequencerConfig>;
 }) {
-  const { containerPort, hostPort, namespace, config } = args;
+  const { containerPort, namespace, config } = args;
   const sequencers = await getSequencers(namespace);
   for (const sequencer of sequencers) {
-    await startPortForward({
+    const { process, port } = await startPortForward({
       resource: `pod/${sequencer}`,
       namespace,
       containerPort,
-      hostPort,
     });
 
-    const url = `http://localhost:${hostPort}`;
+    const url = `http://localhost:${port}`;
     await updateSequencerConfig(url, config);
+    process.kill();
   }
 }
 
@@ -465,7 +550,6 @@ export async function updateSequencersConfig(env: EnvConfig, config: Partial<Seq
   if (isK8sConfig(env)) {
     await updateK8sSequencersConfig({
       containerPort: env.CONTAINER_NODE_PORT,
-      hostPort: env.HOST_NODE_PORT,
       namespace: env.NAMESPACE,
       config,
     });
@@ -473,3 +557,26 @@ export async function updateSequencersConfig(env: EnvConfig, config: Partial<Seq
     await updateSequencerConfig(env.NODE_URL, config);
   }
 }
+
+/**
+ * Rolls the Aztec pods in the given namespace.
+ * @param namespace - The namespace to roll the Aztec pods in.
+ * @dev - IMPORTANT: This function DOES NOT delete the underlying PVCs.
+ *        This means that the pods will be restarted with the same persistent storage.
+ *        This is useful for testing, but you should be aware of the implications.
+ */
+export async function rollAztecPods(namespace: string) {
+  await deleteResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=boot-node' });
+  await deleteResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=prover-node' });
+  await deleteResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=prover-broker' });
+  await deleteResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=prover-agent' });
+  await deleteResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=validator' });
+  await deleteResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=pxe' });
+  await sleep(10 * 1000);
+  await waitForResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=boot-node' });
+  await waitForResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=prover-node' });
+  await waitForResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=prover-broker' });
+  await waitForResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=prover-agent' });
+  await waitForResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=validator' });
+  await waitForResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=pxe' });
+}

package/dest/shared/browser.js

@@ -1,163 +0,0 @@
-/* eslint-disable no-console */ import * as AztecJs from '@aztec/aztec.js';
-import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
-import { contractArtifactToBuffer } from '@aztec/types/abi';
-import getPort from 'get-port';
-import { launch } from 'puppeteer-core';
-const privKey = AztecJs.GrumpkinScalar.random();
-export const browserTestSuite = (setup, pageLogger)=>describe('e2e_aztec.js_browser', ()=>{
-        const initialBalance = 33n;
-        const transferAmount = 3n;
-        let contractAddress;
-        let testClient;
-        let server;
-        let webServerURL;
-        let pxeServer;
-        let pxeURL;
-        let browser;
-        let page;
-        beforeAll(async ()=>{
-            ({ server, pxeURL, pxeServer, webServerURL } = await setup());
-            testClient = AztecJs.createPXEClient(pxeURL);
-            await AztecJs.waitForPXE(testClient);
-            const debuggingPort = await getPort({
-                port: 9222
-            });
-            browser = await launch({
-                executablePath: process.env.CHROME_BIN,
-                headless: true,
-                debuggingPort,
-                args: [
-                    '--no-sandbox',
-                    '--headless',
-                    '--disable-gpu',
-                    '--disable-dev-shm-usage',
-                    '--disable-software-rasterizer',
-                    `--remote-debugging-port=${debuggingPort}`
-                ]
-            });
-            page = await browser.newPage();
-            page.on('console', (msg)=>{
-                pageLogger.info(msg.text());
-            });
-            page.on('pageerror', (err)=>{
-                pageLogger.error(`Error on web page`, err);
-            });
-            await page.goto(`${webServerURL}/index.html`);
-            while(!await page.evaluate(()=>!!window.AztecJs)){
-                pageLogger.verbose('Waiting for window.AztecJs...');
-                await AztecJs.sleep(1000);
-            }
-        });
-        afterAll(async ()=>{
-            await browser.close();
-            server.close();
-            pxeServer?.close();
-        });
-        it('Loads Aztec.js in the browser', async ()=>{
-            const generatePublicKeyExists = await page.evaluate(()=>{
-                const { generatePublicKey } = window.AztecJs;
-                return typeof generatePublicKey === 'function';
-            });
-            expect(generatePublicKeyExists).toBe(true);
-        });
-        it('Creates an account', async ()=>{
-            const result = await page.evaluate(async (rpcUrl, secretKeyString)=>{
-                const { Fr, createPXEClient, getUnsafeSchnorrAccount } = window.AztecJs;
-                const pxe = createPXEClient(rpcUrl);
-                const secretKey = Fr.fromHexString(secretKeyString);
-                const account = await getUnsafeSchnorrAccount(pxe, secretKey);
-                await account.waitSetup();
-                const completeAddress = await account.getCompleteAddress();
-                const addressString = completeAddress.address.toString();
-                console.log(`Created Account: ${addressString}`);
-                return addressString;
-            }, pxeURL, privKey.toString());
-            const accounts = await testClient.getRegisteredAccounts();
-            const stringAccounts = accounts.map((acc)=>acc.address.toString());
-            expect(stringAccounts.includes(result)).toBeTruthy();
-        });
-        it('Deploys Token contract', async ()=>{
-            await deployTokenContract();
-        });
-        it('Can access CompleteAddress class in browser', async ()=>{
-            const result = await page.evaluate(async ()=>{
-                const completeAddress = await window.AztecJs.CompleteAddress.fromString('0x2401bfdad7ac9282bd612e8a6bb0f6ce125b08e317e24dc04ddbba24694ac2e7261249d8b3ad8ad9ed075257eede1dcd8356bfd55e1518f07717c47609194b6500c926582f07fda6a53e3600251f2aa1401c0cd377cef064f3f59045222194541acc5f62d8907a6dc98b85e32f8097a152c3c795bb3981c64e576b014f23005e0891d109aa087560cf8720ae94098827aa009a0bcee09f98fd2a05a7cbc6185402a53516a379d7856d26e3bb5542f1fe57f1ee5a0e4c60f7a463205aa19e2f8e00bce110b9a89857b79e3f70777e38a262b04cf80c56bd833a3c4b58dde7dbdc25c807c4012229e08651fd0d48cf9d966d9ab18826692f48a4cf934bef78614023e9cb95711f532786c7c78e72c3752f03f2a4cafc1846ad9df47324e2b7683f0faaa2e6fe44f3ff68646ce7d8538cb6935ce25472c4c75a244ab0c5d2e3b74d');
-                // NOTE: browser does not know how to serialize CompleteAddress for return, so return a string
-                // otherwise returning a CompleteAddress makes result undefined.
-                return completeAddress.toString();
-            });
-            expect(result).toBe('0x2401bfdad7ac9282bd612e8a6bb0f6ce125b08e317e24dc04ddbba24694ac2e7261249d8b3ad8ad9ed075257eede1dcd8356bfd55e1518f07717c47609194b6500c926582f07fda6a53e3600251f2aa1401c0cd377cef064f3f59045222194541acc5f62d8907a6dc98b85e32f8097a152c3c795bb3981c64e576b014f23005e0891d109aa087560cf8720ae94098827aa009a0bcee09f98fd2a05a7cbc6185402a53516a379d7856d26e3bb5542f1fe57f1ee5a0e4c60f7a463205aa19e2f8e00bce110b9a89857b79e3f70777e38a262b04cf80c56bd833a3c4b58dde7dbdc25c807c4012229e08651fd0d48cf9d966d9ab18826692f48a4cf934bef78614023e9cb95711f532786c7c78e72c3752f03f2a4cafc1846ad9df47324e2b7683f0faaa2e6fe44f3ff68646ce7d8538cb6935ce25472c4c75a244ab0c5d2e3b74d');
-        });
-        it("Gets the owner's balance", async ()=>{
-            const result = await page.evaluate(async (rpcUrl, contractAddress, TokenContractArtifact)=>{
-                const { Contract, AztecAddress, createPXEClient: createPXEClient, getDeployedTestAccountsWallets } = window.AztecJs;
-                const pxe = createPXEClient(rpcUrl);
-                const [wallet] = await getDeployedTestAccountsWallets(pxe);
-                const owner = wallet.getCompleteAddress().address;
-                const contract = await Contract.at(AztecAddress.fromString(contractAddress), TokenContractArtifact, wallet);
-                const balance = await contract.methods.balance_of_private(owner).simulate({
-                    from: owner
-                });
-                return balance;
-            }, pxeURL, (await getTokenAddress()).toString(), TokenContractArtifact);
-            expect(result).toEqual(initialBalance);
-        });
-        it('Sends a transfer TX', async ()=>{
-            const result = await page.evaluate(async (rpcUrl, contractAddress, transferAmount, TokenContractArtifact)=>{
-                console.log(`Starting transfer tx`);
-                const { AztecAddress, Contract, createPXEClient: createPXEClient, getDeployedTestAccountsWallets, getUnsafeSchnorrAccount } = window.AztecJs;
-                const pxe = createPXEClient(rpcUrl);
-                const newReceiverAccountManager = await getUnsafeSchnorrAccount(pxe, AztecJs.Fr.random());
-                const newReceiverAccount = await newReceiverAccountManager.waitSetup();
-                const receiverAddress = newReceiverAccount.getCompleteAddress().address;
-                const [wallet] = await getDeployedTestAccountsWallets(pxe);
-                const contract = await Contract.at(AztecAddress.fromString(contractAddress), TokenContractArtifact, wallet);
-                await contract.methods.transfer(receiverAddress, transferAmount).send().wait();
-                console.log(`Transferred ${transferAmount} tokens to new Account`);
-                return await contract.methods.balance_of_private(receiverAddress).simulate({
-                    from: receiverAddress
-                });
-            }, pxeURL, (await getTokenAddress()).toString(), transferAmount, TokenContractArtifact);
-            expect(result).toEqual(transferAmount);
-        });
-        const deployTokenContract = async ()=>{
-            const [txHash, tokenAddress] = await page.evaluate(async (rpcUrl, initialBalance, serializedTokenContractArtifact)=>{
-                const { DeployMethod, createPXEClient, getSchnorrAccount, Contract, getDeployedTestAccountsWallets, INITIAL_TEST_SECRET_KEYS, INITIAL_TEST_SIGNING_KEYS, INITIAL_TEST_ACCOUNT_SALTS, Buffer, contractArtifactFromBuffer } = window.AztecJs;
-                // We serialize the artifact since buffers (used for bytecode) do not cross well from one realm to another
-                const TokenContractArtifact = await contractArtifactFromBuffer(Buffer.from(serializedTokenContractArtifact, 'base64'));
-                const pxe = createPXEClient(rpcUrl);
-                // we need to ensure that a known account is present in order to create a wallet
-                const knownAccounts = await getDeployedTestAccountsWallets(pxe);
-                if (!knownAccounts.length) {
-                    const newAccountManager = await getSchnorrAccount(pxe, INITIAL_TEST_SECRET_KEYS[0], INITIAL_TEST_SIGNING_KEYS[0], INITIAL_TEST_ACCOUNT_SALTS[0]);
-                    const newAccount = await newAccountManager.waitSetup();
-                    knownAccounts.push(newAccount);
-                }
-                const owner = knownAccounts[0];
-                const tx = new DeployMethod(owner.getCompleteAddress().publicKeys, owner, TokenContractArtifact, (a)=>Contract.at(a, TokenContractArtifact, owner), [
-                    owner.getCompleteAddress(),
-                    'TokenName',
-                    'TKN',
-                    18
-                ]).send();
-                const { contract: token, txHash } = await tx.wait();
-                console.log(`Contract Deployed: ${token.address}`);
-                // We mint tokens to the owner
-                const from = owner.getAddress(); // we are setting from to owner here because of TODO(#9887)
-                await token.methods.mint_to_private(from, owner.getAddress(), initialBalance).send().wait();
-                return [
-                    txHash.toString(),
-                    token.address.toString()
-                ];
-            }, pxeURL, initialBalance, contractArtifactToBuffer(TokenContractArtifact).toString('base64'));
-            const txResult = await testClient.getTxReceipt(AztecJs.TxHash.fromString(txHash));
-            expect(txResult.status).toEqual(AztecJs.TxStatus.SUCCESS);
-            contractAddress = AztecJs.AztecAddress.fromString(tokenAddress);
-        };
-        const getTokenAddress = async ()=>{
-            if (!contractAddress) {
-                await deployTokenContract();
-            }
-            return contractAddress;
-        };
-    });