@aztec/end-to-end 3.0.0-canary.a9708bd → 3.0.0-devnet.20251212

package/dest/spartan/utils.js

@@ -1,16 +1,24 @@
-import { createLogger, sleep } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/aztec.js/log';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { schemas } from '@aztec/foundation/schemas';
-import { createAztecNodeAdminClient } from '@aztec/stdlib/interfaces/client';
+import { sleep } from '@aztec/foundation/sleep';
+import { createAztecNodeAdminClient, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
 import { exec, execSync, spawn } from 'child_process';
 import path from 'path';
 import { promisify } from 'util';
+import { createPublicClient, fallback, http } from 'viem';
 import { z } from 'zod';
 const execAsync = promisify(exec);
 const logger = createLogger('e2e:k8s-utils');
 const testConfigSchema = z.object({
     NAMESPACE: z.string().default('scenario'),
-    REAL_VERIFIER: schemas.Boolean.optional().default(true)
+    REAL_VERIFIER: schemas.Boolean.optional().default(true),
+    CREATE_ETH_DEVNET: schemas.Boolean.optional().default(false),
+    L1_RPC_URLS_JSON: z.string().optional(),
+    L1_ACCOUNT_MNEMONIC: z.string().optional(),
+    AZTEC_SLOT_DURATION: z.coerce.number().optional().default(24),
+    AZTEC_PROOF_SUBMISSION_WINDOW: z.coerce.number().optional().default(5)
 });
 export function setupEnvironment(env) {
     const config = testConfigSchema.parse(env);
@@ -66,7 +74,7 @@ export function runProjectScript(script, args, logger, env) {
 }
 export async function startPortForward({ resource, namespace, containerPort, hostPort }) {
     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 process1 = spawn('kubectl', [
         'port-forward',
         '-n',
@@ -88,20 +96,20 @@ export async function startPortForward({ resource, namespace, containerPort, hos
             const str = data.toString();
             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);
             }
         });
         process1.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,
@@ -111,16 +119,16 @@ export async function startPortForward({ resource, namespace, containerPort, hos
         process1.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);
             }
         });
         process1.on('error', (error)=>{
-            logger.error(`Port forward error: ${error}`);
+            logger.error(`Port forward for ${resource} error: ${error}`);
             resolve(0);
         });
         process1.on('exit', (code)=>{
-            logger.info(`Port forward exited with code ${code}`);
+            logger.verbose(`Port forward for ${resource} exited with code ${code}`);
             resolve(0);
         });
     });
@@ -130,9 +138,35 @@ export async function startPortForward({ resource, namespace, containerPort, hos
         port
     };
 }
-export function startPortForwardForRPC(namespace) {
+export function getExternalIP(namespace, serviceName) {
+    const { promise, resolve, reject } = promiseWithResolvers();
+    const process1 = spawn('kubectl', [
+        'get',
+        'service',
+        '-n',
+        namespace,
+        `${namespace}-${serviceName}`,
+        '--output',
+        "jsonpath='{.status.loadBalancer.ingress[0].ip}'"
+    ], {
+        stdio: 'pipe'
+    });
+    let ip = '';
+    process1.stdout.on('data', (data)=>{
+        ip += data;
+    });
+    process1.on('error', (err)=>{
+        reject(err);
+    });
+    process1.on('exit', ()=>{
+        // kubectl prints JSON. Remove the quotes
+        resolve(ip.replace(/"|'/g, ''));
+    });
+    return promise;
+}
+export function startPortForwardForRPC(namespace, index = 0) {
     return startPortForward({
-        resource: `services/${namespace}-rpc-aztec-node`,
+        resource: `pod/${namespace}-rpc-aztec-node-${index}`,
         namespace,
         containerPort: 8080
     });
@@ -151,6 +185,13 @@ export async function deleteResourceByName({ resource, namespace, name, force =
     return stdout;
 }
 export async function deleteResourceByLabel({ resource, namespace, label, timeout = '5m', force = false }) {
+    // Check if the resource type exists before attempting to delete
+    try {
+        await execAsync(`kubectl api-resources --api-group="" --no-headers -o name | grep -q "^${resource}$" || kubectl api-resources --no-headers -o name | grep -q "^${resource}$"`);
+    } catch (error) {
+        logger.warn(`Resource type '${resource}' not found in cluster, skipping deletion ${error}`);
+        return '';
+    }
     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);
@@ -165,8 +206,12 @@ export async function waitForResourceByLabel({ resource, label, namespace, condi
 export function getChartDir(spartanDir, chartName) {
     return path.join(spartanDir.trim(), chartName);
 }
+function shellQuote(value) {
+    // Single-quote safe shell escaping: ' -> '\''
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
 function valuesToArgs(values) {
-    return Object.entries(values).map(([key, value])=>`--set ${key}=${value}`).join(' ');
+    return Object.entries(values).map(([key, value])=>typeof value === 'number' || typeof value === 'boolean' ? `--set ${key}=${value}` : `--set-string ${key}=${shellQuote(String(value))}`).join(' ');
 }
 function createHelmCommand({ instanceName, helmChartDir, namespace, valuesFile, timeout, values, reuseValues = false }) {
     const valuesFileArgs = valuesFile ? `--values ${helmChartDir}/values/${valuesFile}` : '';
@@ -179,6 +224,33 @@ async function execHelmCommand(args) {
     const { stdout } = await execAsync(helmCommand);
     return stdout;
 }
+export async function uninstallChaosMesh(instanceName, namespace, logger) {
+    // uninstall the helm chart if it exists
+    logger.info(`Uninstalling helm chart ${instanceName}`);
+    await execAsync(`helm uninstall ${instanceName} --namespace ${namespace} --wait --ignore-not-found`);
+    // and delete the chaos-mesh resources created by this release
+    const deleteByLabel = async (resource)=>{
+        const args = {
+            resource,
+            namespace: namespace,
+            label: `app.kubernetes.io/instance=${instanceName}`
+        };
+        logger.info(`Deleting ${resource} resources for release ${instanceName}`);
+        await deleteResourceByLabel(args).catch((e)=>{
+            logger.error(`Error deleting ${resource}: ${e}`);
+            logger.info(`Force deleting ${resource}`);
+            return deleteResourceByLabel({
+                ...args,
+                force: true
+            });
+        });
+    };
+    await deleteByLabel('podchaos');
+    await deleteByLabel('networkchaos');
+    await deleteByLabel('podnetworkchaos');
+    await deleteByLabel('workflows');
+    await deleteByLabel('workflownodes');
+}
 /**
  * Installs a Helm chart with the given parameters.
  * @param instanceName - The name of the Helm chart instance.
@@ -195,31 +267,14 @@ async function execHelmCommand(args) {
  * const stdout = await installChaosMeshChart({ instanceName: 'force-reorg', targetNamespace: 'smoke', valuesFile: 'prover-failure.yaml'});
  * console.log(stdout);
  * ```
- */ export async function installChaosMeshChart({ instanceName, targetNamespace, valuesFile, helmChartDir, chaosMeshNamespace = 'chaos-mesh', timeout = '5m', clean = true, values = {}, logger }) {
+ */ export async function installChaosMeshChart({ instanceName, targetNamespace, valuesFile, helmChartDir, timeout = '10m', clean = true, values = {}, logger }) {
     if (clean) {
-        // uninstall the helm chart if it exists
-        logger.info(`Uninstalling helm chart ${instanceName}`);
-        await execAsync(`helm uninstall ${instanceName} --namespace ${chaosMeshNamespace} --wait --ignore-not-found`);
-        // and delete the podchaos resource
-        const deleteArgs = {
-            resource: 'podchaos',
-            namespace: chaosMeshNamespace,
-            label: `app.kubernetes.io/instance=${instanceName}`
-        };
-        logger.info(`Deleting podchaos resource`);
-        await deleteResourceByLabel(deleteArgs).catch((e)=>{
-            logger.error(`Error deleting podchaos resource: ${e}`);
-            logger.info(`Force deleting podchaos resource`);
-            return deleteResourceByLabel({
-                ...deleteArgs,
-                force: true
-            });
-        });
+        await uninstallChaosMesh(instanceName, targetNamespace, logger);
     }
     return execHelmCommand({
         instanceName,
         helmChartDir,
-        namespace: chaosMeshNamespace,
+        namespace: targetNamespace,
         valuesFile,
         timeout,
         values: {
@@ -291,19 +346,19 @@ export function applyNetworkShaping({ valuesFile, namespace, spartanDir, logger
         logger
     });
 }
-export async function awaitL2BlockNumber(rollupCheatCodes, blockNumber, timeoutSeconds, logger) {
-    logger.info(`Waiting for L2 Block ${blockNumber}`);
+export async function awaitCheckpointNumber(rollupCheatCodes, checkpointNumber, timeoutSeconds, logger) {
+    logger.info(`Waiting for checkpoint ${checkpointNumber}`);
     let tips = await rollupCheatCodes.getTips();
     const endTime = Date.now() + timeoutSeconds * 1000;
-    while(tips.pending < blockNumber && Date.now() < endTime){
-        logger.info(`At L2 Block ${tips.pending}`);
+    while(tips.pending < checkpointNumber && Date.now() < endTime){
+        logger.info(`At checkpoint ${tips.pending}`);
         await sleep(1000);
         tips = await rollupCheatCodes.getTips();
     }
-    if (tips.pending < blockNumber) {
-        throw new Error(`Timeout waiting for L2 Block ${blockNumber}, only reached ${tips.pending}`);
+    if (tips.pending < checkpointNumber) {
+        throw new Error(`Timeout waiting for checkpoint ${checkpointNumber}, only reached ${tips.pending}`);
     } else {
-        logger.info(`Reached L2 Block ${tips.pending}`);
+        logger.info(`Reached checkpoint ${tips.pending}`);
     }
 }
 export async function restartBot(namespace, logger) {
@@ -311,16 +366,189 @@ export async function restartBot(namespace, logger) {
     await deleteResourceByLabel({
         resource: 'pods',
         namespace,
-        label: 'app=bot'
+        label: 'app.kubernetes.io/name=bot'
     });
     await sleep(10 * 1000);
+    // Some bot images may take time to report Ready due to heavy boot-time proving.
+    // Waiting for PodReadyToStartContainers ensures the pod is scheduled and starting without blocking on full readiness.
     await waitForResourceByLabel({
         resource: 'pods',
         namespace,
-        label: 'app=bot'
+        label: 'app.kubernetes.io/name=bot',
+        condition: 'PodReadyToStartContainers'
     });
     logger.info(`Bot restarted`);
 }
+/**
+ * Installs or upgrades the transfer bot Helm release for the given namespace.
+ * Intended for test setup to enable L2 traffic generation only when needed.
+ */ export async function installTransferBot({ namespace, spartanDir, logger, replicas = 1, txIntervalSeconds = 10, followChain = 'PENDING', mnemonic = process.env.LABS_INFRA_MNEMONIC ?? 'test test test test test test test test test test test junk', mnemonicStartIndex, botPrivateKey = process.env.BOT_TRANSFERS_L2_PRIVATE_KEY ?? '0xcafe01', nodeUrl, timeout = '15m', reuseValues = true, aztecSlotDuration = Number(process.env.AZTEC_SLOT_DURATION ?? 12) }) {
+    const instanceName = `${namespace}-bot-transfers`;
+    const helmChartDir = getChartDir(spartanDir, 'aztec-bot');
+    const resolvedNodeUrl = nodeUrl ?? `http://${namespace}-rpc-aztec-node.${namespace}.svc.cluster.local:8080`;
+    logger.info(`Installing/upgrading transfer bot: replicas=${replicas}, followChain=${followChain}`);
+    const values = {
+        'bot.replicaCount': replicas,
+        'bot.txIntervalSeconds': txIntervalSeconds,
+        'bot.followChain': followChain,
+        'bot.botPrivateKey': botPrivateKey,
+        'bot.nodeUrl': resolvedNodeUrl,
+        'bot.mnemonic': mnemonic,
+        'bot.feePaymentMethod': 'fee_juice',
+        'aztec.slotDuration': aztecSlotDuration,
+        // Ensure bot can reach its own PXE started in-process (default rpc.port is 8080)
+        // Note: since aztec-bot depends on aztec-node with alias `bot`, env vars go under `bot.node.env`.
+        'bot.node.env.BOT_PXE_URL': 'http://127.0.0.1:8080',
+        // Provide L1 execution RPC for bridging fee juice
+        'bot.node.env.ETHEREUM_HOSTS': `http://${namespace}-eth-execution.${namespace}.svc.cluster.local:8545`,
+        // Provide L1 mnemonic for bridging (falls back to labs mnemonic)
+        'bot.node.env.BOT_L1_MNEMONIC': mnemonic
+    };
+    // Ensure we derive a funded L1 key (index 0 is funded on anvil default mnemonic)
+    if (mnemonicStartIndex === undefined) {
+        values['bot.mnemonicStartIndex'] = 0;
+    }
+    // Also pass a funded private key directly if available
+    if (process.env.FUNDING_PRIVATE_KEY) {
+        values['bot.node.env.BOT_L1_PRIVATE_KEY'] = process.env.FUNDING_PRIVATE_KEY;
+    }
+    // Align bot image with the running network image: prefer env var, else detect from a validator pod
+    let repositoryFromEnv;
+    let tagFromEnv;
+    const aztecDockerImage = process.env.AZTEC_DOCKER_IMAGE;
+    if (aztecDockerImage && aztecDockerImage.includes(':')) {
+        const lastColon = aztecDockerImage.lastIndexOf(':');
+        repositoryFromEnv = aztecDockerImage.slice(0, lastColon);
+        tagFromEnv = aztecDockerImage.slice(lastColon + 1);
+    }
+    let repository = repositoryFromEnv;
+    let tag = tagFromEnv;
+    if (!repository || !tag) {
+        try {
+            const { stdout } = await execAsync(`kubectl get pods -l app.kubernetes.io/component=validator -n ${namespace} -o jsonpath='{.items[0].spec.containers[?(@.name=="aztec")].image}' | cat`);
+            const image = stdout.trim().replace(/^'|'$/g, '');
+            if (image && image.includes(':')) {
+                const lastColon = image.lastIndexOf(':');
+                repository = image.slice(0, lastColon);
+                tag = image.slice(lastColon + 1);
+            }
+        } catch (err) {
+            logger.warn(`Could not detect aztec image from validator pod: ${String(err)}`);
+        }
+    }
+    if (repository && tag) {
+        values['global.aztecImage.repository'] = repository;
+        values['global.aztecImage.tag'] = tag;
+    }
+    if (mnemonicStartIndex !== undefined) {
+        values['bot.mnemonicStartIndex'] = typeof mnemonicStartIndex === 'string' ? mnemonicStartIndex : Number(mnemonicStartIndex);
+    }
+    await execHelmCommand({
+        instanceName,
+        helmChartDir,
+        namespace,
+        valuesFile: undefined,
+        timeout,
+        values: values,
+        reuseValues
+    });
+    if (replicas > 0) {
+        await waitForResourceByLabel({
+            resource: 'pods',
+            namespace,
+            label: 'app.kubernetes.io/name=bot',
+            condition: 'PodReadyToStartContainers'
+        });
+    }
+}
+/**
+ * Uninstalls the transfer bot Helm release from the given namespace.
+ * Intended for test teardown to clean up bot resources.
+ */ export async function uninstallTransferBot(namespace, logger) {
+    const instanceName = `${namespace}-bot-transfers`;
+    logger.info(`Uninstalling transfer bot release ${instanceName}`);
+    await execAsync(`helm uninstall ${instanceName} --namespace ${namespace} --wait --ignore-not-found`);
+    // Ensure any leftover pods are removed
+    await deleteResourceByLabel({
+        resource: 'pods',
+        namespace,
+        label: 'app.kubernetes.io/name=bot'
+    }).catch(()=>undefined);
+}
+/**
+ * Enables or disables probabilistic transaction dropping on validators and waits for rollout.
+ * Wired to env vars P2P_DROP_TX and P2P_DROP_TX_CHANCE via Helm values.
+ */ export async function setValidatorTxDrop({ namespace, enabled, probability, logger }) {
+    const drop = enabled ? 'true' : 'false';
+    const prob = String(probability);
+    const selectors = [
+        'app=validator',
+        'app.kubernetes.io/component=validator'
+    ];
+    let updated = false;
+    for (const selector of selectors){
+        try {
+            const list = await execAsync(`kubectl get statefulset -l ${selector} -n ${namespace} --no-headers -o name | cat`);
+            const names = list.stdout.split('\n').map((s)=>s.trim()).filter(Boolean);
+            if (names.length === 0) {
+                continue;
+            }
+            const cmd = `kubectl set env statefulset -l ${selector} -n ${namespace} P2P_DROP_TX=${drop} P2P_DROP_TX_CHANCE=${prob}`;
+            logger.info(`command: ${cmd}`);
+            await execAsync(cmd);
+            updated = true;
+        } catch (e) {
+            logger.warn(`Failed to update validators with selector ${selector}: ${String(e)}`);
+        }
+    }
+    if (!updated) {
+        logger.warn(`No validator StatefulSets found in ${namespace}. Skipping tx drop toggle.`);
+        return;
+    }
+    // Restart validator pods to ensure env vars take effect and wait for readiness
+    await restartValidators(namespace, logger);
+}
+export async function restartValidators(namespace, logger) {
+    const selectors = [
+        'app=validator',
+        'app.kubernetes.io/component=validator'
+    ];
+    let any = false;
+    for (const selector of selectors){
+        try {
+            const { stdout } = await execAsync(`kubectl get pods -l ${selector} -n ${namespace} --no-headers -o name | cat`);
+            if (!stdout || stdout.trim().length === 0) {
+                continue;
+            }
+            any = true;
+            await deleteResourceByLabel({
+                resource: 'pods',
+                namespace,
+                label: selector
+            });
+        } catch (e) {
+            logger.warn(`Error restarting validator pods with selector ${selector}: ${String(e)}`);
+        }
+    }
+    if (!any) {
+        logger.warn(`No validator pods found to restart in ${namespace}.`);
+        return;
+    }
+    // Wait for either label to be Ready
+    for (const selector of selectors){
+        try {
+            await waitForResourceByLabel({
+                resource: 'pods',
+                namespace,
+                label: selector
+            });
+            return;
+        } catch  {
+        // try next
+        }
+    }
+    logger.warn(`Validator pods did not report Ready; continuing.`);
+}
 export async function enableValidatorDynamicBootNode(instanceName, namespace, spartanDir, logger) {
     logger.info(`Enabling validator dynamic boot node`);
     await execHelmCommand({
@@ -336,40 +564,108 @@ export async function enableValidatorDynamicBootNode(instanceName, namespace, sp
     });
     logger.info(`Validator dynamic boot node enabled`);
 }
-export async function updateSequencerConfig(url, config) {
-    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) {
-    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) {
-    const { containerPort, namespace, config } = args;
+export function updateSequencersConfig(env, config) {
+    return withSequencersAdmin(env, async (client)=>{
+        await client.setConfig(config);
+        return client.getConfig();
+    });
+}
+export function getSequencersConfig(env) {
+    return withSequencersAdmin(env, (client)=>client.getConfig());
+}
+export async function withSequencersAdmin(env, fn) {
+    const adminContainerPort = 8880;
+    const namespace = env.NAMESPACE;
     const sequencers = await getSequencers(namespace);
+    const results = [];
     for (const sequencer of sequencers){
         const { process: process1, 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));
         process1.kill();
     }
+    return results;
 }
-export async function updateSequencersConfig(env, config) {
-    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, /** If set, will push the new process into it */ processes) {
+    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: process1, port } = await startPortForward({
+            resource: `svc/${NAMESPACE}-eth-execution`,
+            namespace: NAMESPACE,
+            containerPort: 8545
+        });
+        const url = `http://127.0.0.1:${port}`;
+        const client = createPublicClient({
+            transport: fallback([
+                http(url)
+            ])
+        });
+        if (processes) {
+            processes.push(process1);
+        }
+        return {
+            url,
+            client,
+            process: process1
+        };
+    } 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 = 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) {
+    let forwardProcess;
+    try {
+        const [sequencer] = await getSequencers(env.NAMESPACE);
+        const { process: process1, port } = await startPortForward({
+            resource: `pod/${sequencer}`,
+            namespace: env.NAMESPACE,
+            containerPort: 8080
+        });
+        forwardProcess = process1;
+        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();
+    }
 }
 /**
  * Rolls the Aztec pods in the given namespace.
@@ -457,3 +753,30 @@ export async function updateSequencersConfig(env, config) {
         throw new Error(`Failed to determine git project root: ${error}`);
     }
 }
+/** Returns a client to the RPC of the given sequencer (defaults to first) */ export async function getNodeClient(env, index = 0) {
+    const namespace = env.NAMESPACE;
+    const containerPort = 8080;
+    const sequencers = await getSequencers(namespace);
+    const sequencer = sequencers[index];
+    if (!sequencer) {
+        throw new Error(`No sequencer found at index ${index} in namespace ${namespace}`);
+    }
+    const { process: process1, port } = await startPortForward({
+        resource: `pod/${sequencer}`,
+        namespace,
+        containerPort
+    });
+    const url = `http://localhost:${port}`;
+    await retry(()=>fetch(`${url}/status`).then((res)=>res.status === 200), 'forward port', makeBackoff([
+        1,
+        1,
+        2,
+        6
+    ]), logger, true);
+    const client = createAztecNodeClient(url);
+    return {
+        node: client,
+        port,
+        process: process1
+    };
+}