@aztec/end-to-end 2.0.0-nightly.20250903 → 2.0.0-rc.1

package/src/spartan/DEVELOP.md

@@ -0,0 +1,116 @@
+The flow is as follows:
+
+1. Install/start KIND locally
+2. Bootstrap (to build an aztec image)
+3. Load image into kind
+4. Deploy networks
+5. Run tests in `yarn-project/end-to-end/src/spartan`
+
+# Setup KIND
+
+KIND is a kubernetes cluster that runs locally out of docker containers.
+
+You can just
+
+```bash
+spartan/bootstrap.sh kind
+```
+
+You only need to do that once. If you do it again, it will destroy the cluster and recreate it (which you almost never need to do).
+
+Now you’ll likely want some visibility into your cluster. You can
+
+```bash
+spartan/scripts/create_k8s_dashboard.sh
+```
+
+And after ~30 seconds or so you can
+
+```bash
+spartan/scripts/forward_k8s_dashboard.sh
+```
+
+That will run a port forward to your port `8443` . If you’re running in a remote environment (e.g. the mainframe), you’ll need to subsequently forward that back to your local machine. Cursor/VSCode have built in port forwarding (cmd/ctrl shift P, “forward”)
+
+Open the forwarded page, and copy/paste the token that was generated when you forwarded the dashboard.
+
+# Build an aztecprotocol:aztec image
+
+```bash
+./bootstrap.sh
+export AZTEC_DOCKER_IMAGE="aztecprotocol/aztec:$(docker images "aztecprotocol/aztec" --format json | \
+  jq -r 'select(.Tag != "latest") | .Tag' | \
+  head -1)"
+kind load docker-image $AZTEC_DOCKER_IMAGE
+```
+
+If you just changed typescript, you can (after the initial bootstrap)
+
+```bash
+./yarn-project/bootstrap.sh
+./release-image/bootstrap.sh
+export AZTEC_DOCKER_IMAGE="aztecprotocol/aztec:$(docker images "aztecprotocol/aztec" --format json | \
+  jq -r 'select(.Tag != "latest") | .Tag' | \
+  head -1)"
+kind load docker-image $AZTEC_DOCKER_IMAGE
+```
+
+The export is important there. The `AZTEC_DOCKER_IMAGE` env var is used as both:
+
+- the container that runs the rollup contract deployment
+- the containers for the aztec infrastructure (validators, provers, etc)
+
+# Deploy stuff
+
+```bash
+./spartan/bootstrap.sh network_deploy scenario.local.env
+```
+
+That will take 1-3 minutes. But at the end you should have everything you need.
+
+You can (`k` is just an alias over `kubectl`)
+
+```bash
+❯ k get pods -n scenario
+NAME                                              READY   STATUS    RESTARTS   AGE
+deploy-rollup-contracts-2025-08-31-1511-w2dlb   0/1     Completed   0          2m34s
+scenario-eth-beacon-0                           1/1     Running     0          39m
+scenario-eth-execution-0                        1/1     Running     0          39m
+scenario-eth-validator-0                        1/1     Running     0          39m
+scenario-p2p-bootstrap-node-5cbf9658b9-6vd9b    1/1     Running     0          20m
+scenario-prover-agent-59bd96899d-46k5s          1/1     Running     0          116s
+scenario-prover-agent-59bd96899d-vzvkd          1/1     Running     0          116s
+scenario-prover-broker-0                        1/1     Running     0          116s
+scenario-prover-node-0                          1/1     Running     0          116s
+scenario-rpc-aztec-node-0                       1/1     Running     0          116s
+scenario-validator-0                            1/1     Running     0          116s
+scenario-validator-1                            1/1     Running     0          116s
+scenario-validator-2                            1/1     Running     0          116s
+scenario-validator-3                            1/1     Running     0          116s
+```
+
+For example, you can forward back the ethereum node with
+
+```bash
+ k port-forward -n scenario services/eth-devnet-eth-execution 8545:8545
+```
+
+And then do whatever you like with it.
+
+# Run tests
+
+With the cluster running, you can now easily run tests.
+
+```bash
+# run one
+./spartan/bootstrap.sh single_test scenario.local.env spartan/smoke.test.ts
+
+# run all (serially)
+./spartan/bootstrap.sh network_tests scenario.local.env
+```
+
+Right now, I recommend running the smoke test first, always, as it waits for the committee to exist.
+
+# Teardown
+
+You can just `k delete namespace scenario`. That will destroy everything in your kind cluster. To destroy the associated terraform state that was stored locally, just `./spartan/terraform/purge_local_state.sh`.

package/src/spartan/utils.ts

@@ -1,38 +1,38 @@
 import { createLogger, sleep } from '@aztec/aztec.js';
 import type { RollupCheatCodes } from '@aztec/aztec/testing';
+import type { L1ContractAddresses, ViemPublicClient } from '@aztec/ethereum';
 import type { Logger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
-import { type AztecNodeAdminConfig, createAztecNodeAdminClient } from '@aztec/stdlib/interfaces/client';
+import { schemas } from '@aztec/foundation/schemas';
+import {
+  type AztecNodeAdmin,
+  type AztecNodeAdminConfig,
+  createAztecNodeAdminClient,
+  createAztecNodeClient,
+} from '@aztec/stdlib/interfaces/client';
 
 import { ChildProcess, exec, execSync, spawn } from 'child_process';
 import path from 'path';
 import { promisify } from 'util';
+import { createPublicClient, fallback, http } from 'viem';
 import { z } from 'zod';
 
-export const RPC_SERVICE_NAME = 'services/aztec-infra-rpc-aztec-node';
-
 const execAsync = promisify(exec);
 
 const logger = createLogger('e2e:k8s-utils');
 
 const testConfigSchema = z.object({
-  NAMESPACE: z.string().min(1, 'NAMESPACE env variable must be set'),
-  L1_ACCOUNT_MNEMONIC: z.string().default('test test test test test test test test test test test junk'),
-  K8S_CLUSTER: z.string().min(1, 'K8S_CLUSTER env variable must be set'),
-  REGION: z.string().optional(),
-  PROJECT_ID: z.string().optional(),
-  AZTEC_REAL_PROOFS: z.coerce.boolean().default(false),
+  NAMESPACE: z.string().default('scenario'),
+  REAL_VERIFIER: schemas.Boolean.optional().default(true),
+  CREATE_ETH_DEVNET: schemas.Boolean.optional().default(false),
+  L1_RPC_URLS_JSON: z.string().optional(),
 });
 
 export type TestConfig = z.infer<typeof testConfigSchema>;
 
 export function setupEnvironment(env: unknown): TestConfig {
   const config = testConfigSchema.parse(env);
-
-  if (config.K8S_CLUSTER !== 'kind') {
-    const command = `gcloud container clusters get-credentials ${config.K8S_CLUSTER} --region=${config.REGION} --project=${config.PROJECT_ID}`;
-    execSync(command);
-  }
+  logger.warn(`Loaded env config`, config);
   return config;
 }
 
@@ -96,7 +96,7 @@ export async function startPortForward({
 }> {
   const hostPortAsString = hostPort ? hostPort.toString() : '';
 
-  logger.info(`kubectl port-forward -n ${namespace} ${resource} ${hostPortAsString}:${containerPort}`);
+  logger.debug(`kubectl port-forward -n ${namespace} ${resource} ${hostPortAsString}:${containerPort}`);
 
   const process = spawn(
     'kubectl',
@@ -114,20 +114,20 @@ export async function startPortForward({
       const str = data.toString() as string;
       if (!isResolved && str.includes('Forwarding from')) {
         isResolved = true;
-        logger.info(str);
+        logger.debug(`Port forward for ${resource}: ${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.verbose(`Port forwarded for ${resource} at ${portNumber}:${containerPort}`);
         resolve(portNumber);
       } else {
         logger.silent(str);
       }
     });
     process.stderr?.on('data', data => {
-      logger.info(data.toString());
+      logger.verbose(`Port forward for ${resource}: ${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,
@@ -137,16 +137,16 @@ export async function startPortForward({
     process.on('close', () => {
       if (!isResolved) {
         isResolved = true;
-        logger.warn('Port forward closed before connection established');
+        logger.warn(`Port forward for ${resource} closed before connection established`);
         resolve(0);
       }
     });
     process.on('error', error => {
-      logger.error(`Port forward error: ${error}`);
+      logger.error(`Port forward for ${resource} error: ${error}`);
       resolve(0);
     });
     process.on('exit', code => {
-      logger.info(`Port forward exited with code ${code}`);
+      logger.verbose(`Port forward for ${resource} exited with code ${code}`);
       resolve(0);
     });
   });
@@ -158,12 +158,20 @@ export async function startPortForward({
 
 export function startPortForwardForRPC(namespace: string) {
   return startPortForward({
-    resource: RPC_SERVICE_NAME,
+    resource: `services/${namespace}-rpc-aztec-node`,
     namespace,
     containerPort: 8080,
   });
 }
 
+export function startPortForwardForEthereum(namespace: string) {
+  return startPortForward({
+    resource: `services/${namespace}-eth-execution`,
+    namespace,
+    containerPort: 8545,
+  });
+}
+
 export async function deleteResourceByName({
   resource,
   namespace,
@@ -188,13 +196,17 @@ export async function deleteResourceByLabel({
   namespace,
   label,
   timeout = '5m',
+  force = false,
 }: {
   resource: string;
   namespace: string;
   label: string;
   timeout?: string;
+  force?: boolean;
 }) {
-  const command = `kubectl delete ${resource} -l ${label} -n ${namespace} --ignore-not-found=true --wait=true --timeout=${timeout}`;
+  const command = `kubectl delete ${resource} -l ${label} -n ${namespace} --ignore-not-found=true --wait=true --timeout=${timeout} ${
+    force ? '--force' : ''
+  }`;
   logger.info(`command: ${command}`);
   const { stdout } = await execAsync(command);
   return stdout;
@@ -306,13 +318,13 @@ export async function installChaosMeshChart({
     const deleteArgs = {
       resource: 'podchaos',
       namespace: chaosMeshNamespace,
-      name: `${targetNamespace}-${instanceName}`,
+      label: `app.kubernetes.io/instance=${instanceName}`,
     };
     logger.info(`Deleting podchaos resource`);
-    await deleteResourceByName(deleteArgs).catch(e => {
+    await deleteResourceByLabel(deleteArgs).catch(e => {
       logger.error(`Error deleting podchaos resource: ${e}`);
       logger.info(`Force deleting podchaos resource`);
-      return deleteResourceByName({ ...deleteArgs, force: true });
+      return deleteResourceByLabel({ ...deleteArgs, force: true });
     });
   }
 
@@ -502,44 +514,110 @@ export async function enableValidatorDynamicBootNode(
   logger.info(`Validator dynamic boot node enabled`);
 }
 
-export async function updateSequencerConfig(url: string, config: Partial<AztecNodeAdminConfig>) {
-  const node = createAztecNodeAdminClient(url);
-  // Retry incase the port forward is not ready yet
-  await retry(() => node.setConfig(config), 'Update sequencer config', makeBackoff([1, 3, 6]), logger);
-}
-
 export async function getSequencers(namespace: string) {
-  const command = `kubectl get pods -l app=validator -n ${namespace} -o jsonpath='{.items[*].metadata.name}'`;
+  const command = `kubectl get pods -l app.kubernetes.io/component=validator -n ${namespace} -o jsonpath='{.items[*].metadata.name}'`;
   const { stdout } = await execAsync(command);
-  return stdout.split(' ');
+  const sequencers = stdout.split(' ');
+  logger.verbose(`Found sequencer pods ${sequencers.join(', ')}`);
+  return sequencers;
 }
 
-async function updateK8sSequencersConfig(args: {
-  containerPort: number;
-  namespace: string;
-  config: Partial<AztecNodeAdminConfig>;
-}) {
-  const { containerPort, namespace, config } = args;
+export function updateSequencersConfig(env: TestConfig, config: Partial<AztecNodeAdminConfig>) {
+  return withSequencersAdmin(env, async client => {
+    await client.setConfig(config);
+    return client.getConfig();
+  });
+}
+
+export function getSequencersConfig(env: TestConfig) {
+  return withSequencersAdmin(env, client => client.getConfig());
+}
+
+export async function withSequencersAdmin<T>(env: TestConfig, fn: (node: AztecNodeAdmin) => Promise<T>): Promise<T[]> {
+  const adminContainerPort = 8880;
+  const namespace = env.NAMESPACE;
   const sequencers = await getSequencers(namespace);
+  const results = [];
+
   for (const sequencer of sequencers) {
     const { process, port } = await startPortForward({
       resource: `pod/${sequencer}`,
       namespace,
-      containerPort,
+      containerPort: adminContainerPort,
     });
 
     const url = `http://localhost:${port}`;
-    await updateSequencerConfig(url, config);
+    await retry(
+      () => fetch(`${url}/status`).then(res => res.status === 200),
+      'forward node admin port',
+      makeBackoff([1, 1, 2, 6]),
+      logger,
+      true,
+    );
+    const client = createAztecNodeAdminClient(url);
+    results.push(await fn(client));
     process.kill();
   }
+
+  return results;
 }
 
-export async function updateSequencersConfig(env: TestConfig, config: Partial<AztecNodeAdminConfig>) {
-  await updateK8sSequencersConfig({
-    containerPort: 8880,
-    namespace: env.NAMESPACE,
-    config,
-  });
+/**
+ * Returns a public viem client to the eth execution node. If it was part of a local eth devnet,
+ * it first port-forwards the service and points to it. Otherwise, just uses the external RPC url.
+ */
+export async function getPublicViemClient(
+  env: TestConfig,
+  /** If set, will push the new process into it */
+  processes?: ChildProcess[],
+): Promise<{ url: string; client: ViemPublicClient; process?: ChildProcess }> {
+  const { NAMESPACE, CREATE_ETH_DEVNET, L1_RPC_URLS_JSON } = env;
+  if (CREATE_ETH_DEVNET) {
+    logger.info(`Creating port forward to eth execution node`);
+    const { process, port } = await startPortForward({
+      resource: `svc/${NAMESPACE}-eth-execution`,
+      namespace: NAMESPACE,
+      containerPort: 8545,
+    });
+    const url = `http://127.0.0.1:${port}`;
+    const client: ViemPublicClient = createPublicClient({ transport: fallback([http(url)]) });
+    if (processes) {
+      processes.push(process);
+    }
+    return { url, client, process };
+  } else {
+    logger.info(`Connecting to the eth execution node at ${L1_RPC_URLS_JSON}`);
+    if (!L1_RPC_URLS_JSON) {
+      throw new Error(`L1_RPC_URLS_JSON is not defined`);
+    }
+    const client: ViemPublicClient = createPublicClient({ transport: fallback([http(L1_RPC_URLS_JSON)]) });
+    return { url: L1_RPC_URLS_JSON, client };
+  }
+}
+
+/** Queries an Aztec node for the L1 deployment addresses */
+export async function getL1DeploymentAddresses(env: TestConfig): Promise<L1ContractAddresses> {
+  let forwardProcess: ChildProcess | undefined;
+  try {
+    const [sequencer] = await getSequencers(env.NAMESPACE);
+    const { process, port } = await startPortForward({
+      resource: `pod/${sequencer}`,
+      namespace: env.NAMESPACE,
+      containerPort: 8080,
+    });
+
+    forwardProcess = process;
+    const url = `http://127.0.0.1:${port}`;
+    const node = createAztecNodeClient(url);
+    return await retry(
+      () => node.getNodeInfo().then(i => i.l1ContractAddresses),
+      'get node info',
+      makeBackoff([1, 3, 6]),
+      logger,
+    );
+  } finally {
+    forwardProcess?.kill();
+  }
 }
 
 /**

package/dest/integration_l1_publisher/write_json.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"write_json.d.ts","sourceRoot":"","sources":["../../src/integration_l1_publisher/write_json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAOpD;;;GAGG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,EACd,aAAa,EAAE,EAAE,EAAE,EACnB,KAAK,EAAE,IAAI,EAAE,EACb,WAAW,EAAE,WAAW,EACxB,gBAAgB,EAAE,YAAY,EAC9B,eAAe,EAAE,KAAK,MAAM,EAAE,GAC7B,OAAO,CAAC,IAAI,CAAC,CAqDf"}