@aztec/end-to-end 4.0.0-nightly.20260121 → 4.0.0-nightly.20260122

package/dest/spartan/utils/chaos.js

@@ -0,0 +1,142 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { execHelmCommand } from './helm.js';
+import { deleteResourceByLabel, getChartDir } from './k8s.js';
+const execAsync = promisify(exec);
+export async function uninstallChaosMesh(instanceName, namespace, log) {
+    // uninstall the helm chart if it exists
+    log.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}`
+        };
+        log.info(`Deleting ${resource} resources for release ${instanceName}`);
+        await deleteResourceByLabel(args).catch((e)=>{
+            log.error(`Error deleting ${resource}: ${e}`);
+            log.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.
+ * @param targetNamespace - The namespace with the resources to be affected by the Helm chart.
+ * @param valuesFile - The values file to use for the Helm chart.
+ * @param chaosMeshNamespace - The namespace to install the Helm chart in.
+ * @param timeout - The timeout for the Helm command.
+ * @param clean - Whether to clean up the Helm chart before installing it.
+ * @returns The stdout of the Helm command.
+ * @throws If the Helm command fails.
+ *
+ * Example usage:
+ * ```typescript
+ * const stdout = await installChaosMeshChart({ instanceName: 'force-reorg', targetNamespace: 'smoke', valuesFile: 'prover-failure.yaml'});
+ * console.log(stdout);
+ * ```
+ */ export async function installChaosMeshChart({ instanceName, targetNamespace, valuesFile, helmChartDir, timeout = '10m', clean = true, values = {}, logger: log }) {
+    if (clean) {
+        await uninstallChaosMesh(instanceName, targetNamespace, log);
+    }
+    return execHelmCommand({
+        instanceName,
+        helmChartDir,
+        namespace: targetNamespace,
+        valuesFile,
+        timeout,
+        values: {
+            ...values,
+            'global.targetNamespace': targetNamespace
+        }
+    });
+}
+export function applyProverFailure({ namespace, spartanDir, durationSeconds, logger: log }) {
+    return installChaosMeshChart({
+        instanceName: 'prover-failure',
+        targetNamespace: namespace,
+        valuesFile: 'prover-failure.yaml',
+        helmChartDir: getChartDir(spartanDir, 'aztec-chaos-scenarios'),
+        values: {
+            'proverFailure.duration': `${durationSeconds}s`
+        },
+        logger: log
+    });
+}
+export function applyValidatorFailure({ namespace, spartanDir, logger: log, values, instanceName }) {
+    return installChaosMeshChart({
+        instanceName: instanceName ?? 'validator-failure',
+        targetNamespace: namespace,
+        valuesFile: 'validator-failure.yaml',
+        helmChartDir: getChartDir(spartanDir, 'aztec-chaos-scenarios'),
+        values,
+        logger: log
+    });
+}
+export function applyProverKill({ namespace, spartanDir, logger: log, values }) {
+    return installChaosMeshChart({
+        instanceName: 'prover-kill',
+        targetNamespace: namespace,
+        valuesFile: 'prover-kill.yaml',
+        helmChartDir: getChartDir(spartanDir, 'aztec-chaos-scenarios'),
+        chaosMeshNamespace: namespace,
+        clean: true,
+        logger: log,
+        values
+    });
+}
+export function applyProverBrokerKill({ namespace, spartanDir, logger: log, values }) {
+    return installChaosMeshChart({
+        instanceName: 'prover-broker-kill',
+        targetNamespace: namespace,
+        valuesFile: 'prover-broker-kill.yaml',
+        helmChartDir: getChartDir(spartanDir, 'aztec-chaos-scenarios'),
+        clean: true,
+        logger: log,
+        values
+    });
+}
+export function applyBootNodeFailure({ instanceName = 'boot-node-failure', namespace, spartanDir, durationSeconds, logger: log, values }) {
+    return installChaosMeshChart({
+        instanceName,
+        targetNamespace: namespace,
+        valuesFile: 'boot-node-failure.yaml',
+        helmChartDir: getChartDir(spartanDir, 'aztec-chaos-scenarios'),
+        values: {
+            'bootNodeFailure.duration': `${durationSeconds}s`,
+            ...values ?? {}
+        },
+        logger: log
+    });
+}
+export function applyValidatorKill({ instanceName = 'validator-kill', namespace, spartanDir, logger: log, values, clean = true }) {
+    return installChaosMeshChart({
+        instanceName: instanceName ?? 'validator-kill',
+        targetNamespace: namespace,
+        valuesFile: 'validator-kill.yaml',
+        helmChartDir: getChartDir(spartanDir, 'aztec-chaos-scenarios'),
+        clean,
+        logger: log,
+        values
+    });
+}
+export function applyNetworkShaping({ instanceName = 'network-shaping', valuesFile, namespace, spartanDir, logger: log }) {
+    return installChaosMeshChart({
+        instanceName,
+        targetNamespace: namespace,
+        valuesFile,
+        helmChartDir: getChartDir(spartanDir, 'aztec-chaos-scenarios'),
+        logger: log
+    });
+}

package/dest/spartan/utils/clients.d.ts

@@ -0,0 +1,25 @@
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
+import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import type { ChildProcess } from 'child_process';
+import type { TestConfig } from './config.js';
+/**
+ * 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 declare function getPublicViemClient(env: TestConfig, 
+/** If set, will push the new process into it */
+processes?: ChildProcess[]): Promise<{
+    url: string;
+    client: ViemPublicClient;
+    process?: ChildProcess;
+}>;
+/** Queries an Aztec node for the L1 deployment addresses */
+export declare function getL1DeploymentAddresses(env: TestConfig): Promise<L1ContractAddresses>;
+/** Returns a client to the RPC of the given sequencer (defaults to first) */
+export declare function getNodeClient(env: TestConfig, index?: number): Promise<{
+    node: ReturnType<typeof createAztecNodeClient>;
+    port: number;
+    process: ChildProcess;
+}>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50cy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NwYXJ0YW4vdXRpbHMvY2xpZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBQ2pGLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFOUQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFeEUsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBR2xELE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQU05Qzs7O0dBR0c7QUFDSCx3QkFBc0IsbUJBQW1CLENBQ3ZDLEdBQUcsRUFBRSxVQUFVO0FBQ2YsZ0RBQWdEO0FBQ2hELFNBQVMsQ0FBQyxFQUFFLFlBQVksRUFBRSxHQUN6QixPQUFPLENBQUM7SUFBRSxHQUFHLEVBQUUsTUFBTSxDQUFDO0lBQUMsTUFBTSxFQUFFLGdCQUFnQixDQUFDO0lBQUMsT0FBTyxDQUFDLEVBQUUsWUFBWSxDQUFBO0NBQUUsQ0FBQyxDQXlCNUU7QUFFRCw0REFBNEQ7QUFDNUQsd0JBQXNCLHdCQUF3QixDQUFDLEdBQUcsRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBc0I1RjtBQUVELDZFQUE2RTtBQUM3RSx3QkFBc0IsYUFBYSxDQUNqQyxHQUFHLEVBQUUsVUFBVSxFQUNmLEtBQUssR0FBRSxNQUFVLEdBQ2hCLE9BQU8sQ0FBQztJQUFFLElBQUksRUFBRSxVQUFVLENBQUMsT0FBTyxxQkFBcUIsQ0FBQyxDQUFDO0lBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQztJQUFDLE9BQU8sRUFBRSxZQUFZLENBQUE7Q0FBRSxDQUFDLENBMEJsRyJ9

package/dest/spartan/utils/clients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../../src/spartan/utils/clients.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAExE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGlD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAM9C;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,UAAU;AACf,gDAAgD;AAChD,SAAS,CAAC,EAAE,YAAY,EAAE,GACzB,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,gBAAgB,CAAC;IAAC,OAAO,CAAC,EAAE,YAAY,CAAA;CAAE,CAAC,CAyB5E;AAED,4DAA4D;AAC5D,wBAAsB,wBAAwB,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAsB5F;AAED,6EAA6E;AAC7E,wBAAsB,aAAa,CACjC,GAAG,EAAE,UAAU,EACf,KAAK,GAAE,MAAU,GAChB,OAAO,CAAC;IAAE,IAAI,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC,CA0BlG"}

package/dest/spartan/utils/clients.js

@@ -0,0 +1,101 @@
+import { createLogger } from '@aztec/aztec.js/log';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import { createPublicClient, fallback, http } from 'viem';
+import { startPortForward } from './k8s.js';
+import { getSequencers } from './nodes.js';
+const logger = createLogger('e2e:k8s-utils');
+/**
+ * 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, 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, {
+                    batch: false
+                })
+            ])
+        });
+        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 = createPublicClient({
+            transport: fallback([
+                http(L1_RPC_URLS_JSON, {
+                    batch: false
+                })
+            ])
+        });
+        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, 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();
+    }
+}
+/** 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, 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
+    };
+}

package/dest/spartan/utils/config.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+declare const testConfigSchema: z.ZodObject<{
+    NAMESPACE: z.ZodDefault<z.ZodString>;
+    REAL_VERIFIER: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodEffects<z.ZodEffects<z.ZodNumber, 0 | 1, number>, boolean, number>, z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, boolean, string>]>>>;
+    CREATE_ETH_DEVNET: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodEffects<z.ZodEffects<z.ZodNumber, 0 | 1, number>, boolean, number>, z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, boolean, string>]>>>;
+    L1_RPC_URLS_JSON: z.ZodOptional<z.ZodString>;
+    L1_ACCOUNT_MNEMONIC: z.ZodOptional<z.ZodString>;
+    AZTEC_SLOT_DURATION: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    AZTEC_EPOCH_DURATION: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    AZTEC_PROOF_SUBMISSION_WINDOW: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    NAMESPACE: string;
+    REAL_VERIFIER: boolean;
+    CREATE_ETH_DEVNET: boolean;
+    L1_RPC_URLS_JSON?: string | undefined;
+    L1_ACCOUNT_MNEMONIC?: string | undefined;
+    AZTEC_SLOT_DURATION: number;
+    AZTEC_EPOCH_DURATION: number;
+    AZTEC_PROOF_SUBMISSION_WINDOW: number;
+    AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: number;
+}, {
+    NAMESPACE?: string | undefined;
+    REAL_VERIFIER?: string | number | boolean | undefined;
+    CREATE_ETH_DEVNET?: string | number | boolean | undefined;
+    L1_RPC_URLS_JSON?: string | undefined;
+    L1_ACCOUNT_MNEMONIC?: string | undefined;
+    AZTEC_SLOT_DURATION?: number | undefined;
+    AZTEC_EPOCH_DURATION?: number | undefined;
+    AZTEC_PROOF_SUBMISSION_WINDOW?: number | undefined;
+    AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET?: number | undefined;
+}>;
+export type TestConfig = z.infer<typeof testConfigSchema>;
+export declare function setupEnvironment(env: unknown): TestConfig;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3BhcnRhbi91dGlscy9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUl4QixRQUFBLE1BQU0sZ0JBQWdCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7RUFVcEIsQ0FBQztBQUVILE1BQU0sTUFBTSxVQUFVLEdBQUcsQ0FBQyxDQUFDLEtBQUssQ0FBQyxPQUFPLGdCQUFnQixDQUFDLENBQUM7QUFFMUQsd0JBQWdCLGdCQUFnQixDQUFDLEdBQUcsRUFBRSxPQUFPLEdBQUcsVUFBVSxDQUl6RCJ9

package/dest/spartan/utils/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/spartan/utils/config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUpB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,CAIzD"}

package/dest/spartan/utils/config.js

@@ -0,0 +1,20 @@
+import { createLogger } from '@aztec/aztec.js/log';
+import { schemas } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+const logger = createLogger('e2e:k8s-utils');
+const testConfigSchema = z.object({
+    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(),
+    L1_ACCOUNT_MNEMONIC: z.string().optional(),
+    AZTEC_SLOT_DURATION: z.coerce.number().optional().default(24),
+    AZTEC_EPOCH_DURATION: z.coerce.number().optional().default(32),
+    AZTEC_PROOF_SUBMISSION_WINDOW: z.coerce.number().optional().default(5),
+    AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: z.coerce.number().optional().default(2)
+});
+export function setupEnvironment(env) {
+    const config = testConfigSchema.parse(env);
+    logger.warn(`Loaded env config`, config);
+    return config;
+}

package/dest/spartan/utils/health.d.ts

@@ -0,0 +1,63 @@
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Logger } from '@aztec/foundation/log';
+/**
+ * Snapshot of chain state captured during setup for comparison in teardown.
+ */
+export interface ChainHealthSnapshot {
+    blockNumber: number;
+    checkpointNumber: CheckpointNumber;
+    timestamp: number;
+}
+/**
+ * Pre-flight and post-flight health checks for the Aztec network.
+ *
+ * Use in beforeAll/afterAll to validate the chain is healthy before tests run
+ * and verify it continued progressing during the test.
+ *
+ * @example
+ * ```typescript
+ * const health = new ChainHealth(config.NAMESPACE, logger);
+ *
+ * beforeAll(async () => {
+ *   await health.setup();
+ * });
+ *
+ * afterAll(async () => {
+ *   await health.teardown();
+ * });
+ * ```
+ */
+export declare class ChainHealth {
+    private namespace;
+    private logger;
+    private snapshot?;
+    constructor(namespace: string, logger: Logger);
+    /**
+     * Pre-flight health check. Validates chain is in a testable state and captures
+     * initial state for comparison in teardown.
+     *
+     * Checks performed:
+     * - Node is reachable and returns valid info
+     * - ENR exists
+     * - L1 is accessible
+     * - At least 1 L2 block has been mined
+     * - Committee exists
+     * - At least 1 checkpoint has been reached
+     *
+     * @throws Error if any health check fails
+     */
+    setup(): Promise<void>;
+    /**
+     * Post-flight health check. Verifies the chain continued progressing during the test.
+     *
+     * For tests that ran longer than the threshold, checks:
+     * - Block number increased since setup
+     * - Checkpoint number increased since setup
+     *
+     * For shorter tests, skips the check.
+     *
+     * @throws Error if chain did not progress
+     */
+    teardown(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhbHRoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3BhcnRhbi91dGlscy9oZWFsdGgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbkUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFPcEQ7O0dBRUc7QUFDSCxNQUFNLFdBQVcsbUJBQW1CO0lBQ2xDLFdBQVcsRUFBRSxNQUFNLENBQUM7SUFDcEIsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUM7SUFDbkMsU0FBUyxFQUFFLE1BQU0sQ0FBQztDQUNuQjtBQUVEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FrQkc7QUFDSCxxQkFBYSxXQUFXO0lBQ3RCLE9BQU8sQ0FBQyxTQUFTLENBQVM7SUFDMUIsT0FBTyxDQUFDLE1BQU0sQ0FBUztJQUN2QixPQUFPLENBQUMsUUFBUSxDQUFDLENBQXNCO0lBRXZDLFlBQVksU0FBUyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUc1QztJQUVEOzs7Ozs7Ozs7Ozs7O09BYUc7SUFDRyxLQUFLLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQW1HM0I7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ0csUUFBUSxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0E4RTlCO0NBQ0YifQ==

package/dest/spartan/utils/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../../src/spartan/utils/health.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAOpD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,CAAsB;IAEvC,YAAY,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAG5C;IAED;;;;;;;;;;;;;OAaG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAmG3B;IAED;;;;;;;;;;OAUG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CA8E9B;CACF"}

package/dest/spartan/utils/health.js

@@ -0,0 +1,202 @@
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { createPublicClient, fallback, http } from 'viem';
+import { startPortForwardForEthereum, startPortForwardForRPC } from './k8s.js';
+/**
+ * Pre-flight and post-flight health checks for the Aztec network.
+ *
+ * Use in beforeAll/afterAll to validate the chain is healthy before tests run
+ * and verify it continued progressing during the test.
+ *
+ * @example
+ * ```typescript
+ * const health = new ChainHealth(config.NAMESPACE, logger);
+ *
+ * beforeAll(async () => {
+ *   await health.setup();
+ * });
+ *
+ * afterAll(async () => {
+ *   await health.teardown();
+ * });
+ * ```
+ */ export class ChainHealth {
+    namespace;
+    logger;
+    snapshot;
+    constructor(namespace, logger){
+        this.namespace = namespace;
+        this.logger = logger;
+    }
+    /**
+   * Pre-flight health check. Validates chain is in a testable state and captures
+   * initial state for comparison in teardown.
+   *
+   * Checks performed:
+   * - Node is reachable and returns valid info
+   * - ENR exists
+   * - L1 is accessible
+   * - At least 1 L2 block has been mined
+   * - Committee exists
+   * - At least 1 checkpoint has been reached
+   *
+   * @throws Error if any health check fails
+   */ async setup() {
+        const processes = [];
+        try {
+            // Establish temporary connections
+            const { process: rpcProcess, port: rpcPort } = await startPortForwardForRPC(this.namespace);
+            processes.push(rpcProcess);
+            const { process: ethProcess, port: ethPort } = await startPortForwardForEthereum(this.namespace);
+            processes.push(ethProcess);
+            const nodeUrl = `http://127.0.0.1:${rpcPort}`;
+            const ethereumUrl = `http://127.0.0.1:${ethPort}`;
+            // Create clients
+            const node = createAztecNodeClient(nodeUrl);
+            // Check 1: Node is reachable
+            let nodeInfo;
+            try {
+                nodeInfo = await node.getNodeInfo();
+            } catch (err) {
+                throw new Error(`Health check failed: Node is not reachable at ${nodeUrl}. Error: ${err}`);
+            }
+            if (!nodeInfo) {
+                throw new Error('Health check failed: Node returned empty info');
+            }
+            // Check 2: ENR exists (P2P identity)
+            if (!nodeInfo.enr || !nodeInfo.enr.startsWith('enr:-')) {
+                throw new Error(`Health check failed: Invalid or missing ENR. Got: ${nodeInfo.enr}`);
+            }
+            // Check 3: L1 is accessible
+            const chain = createEthereumChain([
+                ethereumUrl
+            ], nodeInfo.l1ChainId);
+            const ethereumClient = createPublicClient({
+                chain: chain.chainInfo,
+                transport: fallback([
+                    http(ethereumUrl, {
+                        batch: false
+                    })
+                ])
+            });
+            try {
+                await ethereumClient.getBlockNumber();
+            } catch (err) {
+                throw new Error(`Health check failed: L1 is not accessible at ${ethereumUrl}. Error: ${err}`);
+            }
+            // Check 4: At least 1 L2 block mined
+            let l2BlockNumber;
+            try {
+                l2BlockNumber = await node.getBlockNumber();
+            } catch (err) {
+                throw new Error(`Health check failed: Could not get L2 block number. Error: ${err}`);
+            }
+            if (l2BlockNumber < 1) {
+                throw new Error(`Health check failed: No L2 blocks mined yet. Block number: ${l2BlockNumber}`);
+            }
+            // Check 5: Committee exists
+            const rollup = new RollupContract(ethereumClient, nodeInfo.l1ContractAddresses.rollupAddress);
+            let committee;
+            try {
+                committee = await rollup.getCurrentEpochCommittee();
+            } catch (err) {
+                throw new Error(`Health check failed: Could not get committee. Error: ${err}`);
+            }
+            if (!committee || committee.length === 0) {
+                throw new Error('Health check failed: No committee exists. Validators may not be registered yet.');
+            }
+            // Check 6: At least 1 checkpoint reached
+            let checkpointNumber;
+            try {
+                checkpointNumber = await rollup.getCheckpointNumber();
+            } catch (err) {
+                throw new Error(`Health check failed: Could not get checkpoint number. Error: ${err}`);
+            }
+            if (checkpointNumber < CheckpointNumber(1)) {
+                throw new Error(`Health check failed: No checkpoint reached yet. Checkpoint number: ${checkpointNumber}. ` + 'The proving pipeline may not have completed a proof yet.');
+            }
+            // Capture snapshot for teardown comparison
+            this.snapshot = {
+                blockNumber: l2BlockNumber,
+                checkpointNumber,
+                timestamp: Date.now()
+            };
+            this.logger.info('Pre-flight health check passed');
+        } finally{
+            processes.forEach((p)=>p.kill());
+        }
+    }
+    /**
+   * Post-flight health check. Verifies the chain continued progressing during the test.
+   *
+   * For tests that ran longer than the threshold, checks:
+   * - Block number increased since setup
+   * - Checkpoint number increased since setup
+   *
+   * For shorter tests, skips the check.
+   *
+   * @throws Error if chain did not progress
+   */ async teardown() {
+        if (!this.snapshot) {
+            this.logger.warn('Teardown called without setup - skipping chain progress check');
+            return;
+        }
+        const processes = [];
+        // Minimum test duration to check chain progression
+        const PROGRESS_CHECK_THRESHOLD_SECONDS = 120;
+        try {
+            const elapsedSeconds = Math.round((Date.now() - this.snapshot.timestamp) / 1000);
+            // Skip progress check for short tests
+            if (elapsedSeconds <= PROGRESS_CHECK_THRESHOLD_SECONDS) {
+                this.logger.info('Post-flight health check passed (skipped progress check - test too short)');
+                return;
+            }
+            const { process: rpcProcess, port: rpcPort } = await startPortForwardForRPC(this.namespace);
+            processes.push(rpcProcess);
+            const { process: ethProcess, port: ethPort } = await startPortForwardForEthereum(this.namespace);
+            processes.push(ethProcess);
+            const nodeUrl = `http://127.0.0.1:${rpcPort}`;
+            const ethereumUrl = `http://127.0.0.1:${ethPort}`;
+            const node = createAztecNodeClient(nodeUrl);
+            // Check that block number increased
+            let currentBlockNumber;
+            try {
+                currentBlockNumber = await node.getBlockNumber();
+            } catch (err) {
+                throw new Error(`Teardown health check failed: Could not get block number. Error: ${err}`);
+            }
+            if (currentBlockNumber <= this.snapshot.blockNumber) {
+                throw new Error(`Chain did not progress during test. ` + `Block number at setup: ${this.snapshot.blockNumber}, ` + `Block number at teardown: ${currentBlockNumber}, ` + `Elapsed time: ${elapsedSeconds}s. ` + `The chain may have stalled during the test.`);
+            }
+            // Check that checkpoint number increased
+            const nodeInfo = await node.getNodeInfo();
+            const chain = createEthereumChain([
+                ethereumUrl
+            ], nodeInfo.l1ChainId);
+            const ethereumClient = createPublicClient({
+                chain: chain.chainInfo,
+                transport: fallback([
+                    http(ethereumUrl, {
+                        batch: false
+                    })
+                ])
+            });
+            const rollup = new RollupContract(ethereumClient, nodeInfo.l1ContractAddresses.rollupAddress);
+            let currentCheckpoint;
+            try {
+                currentCheckpoint = await rollup.getCheckpointNumber();
+            } catch (err) {
+                throw new Error(`Teardown health check failed: Could not get checkpoint number. Error: ${err}`);
+            }
+            if (currentCheckpoint <= this.snapshot.checkpointNumber) {
+                throw new Error(`Proving pipeline did not progress during test. ` + `Checkpoint at setup: ${this.snapshot.checkpointNumber}, ` + `Checkpoint at teardown: ${currentCheckpoint}, ` + `Elapsed time: ${elapsedSeconds}s. ` + `The proving pipeline may have stalled during the test.`);
+            }
+            this.logger.info('Post-flight health check passed');
+        } finally{
+            processes.forEach((p)=>p.kill());
+            this.snapshot = undefined;
+        }
+    }
+}

package/dest/spartan/utils/helm.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from '@aztec/foundation/log';
+export declare function createHelmCommand({ instanceName, helmChartDir, namespace, valuesFile, timeout, values, reuseValues }: {
+    instanceName: string;
+    helmChartDir: string;
+    namespace: string;
+    valuesFile: string | undefined;
+    timeout: string;
+    values: Record<string, string | number | boolean>;
+    reuseValues?: boolean;
+}): string;
+export declare function execHelmCommand(args: Parameters<typeof createHelmCommand>[0]): Promise<string>;
+export declare function getHelmReleaseStatus(instanceName: string, namespace: string): Promise<string | undefined>;
+export declare function forceDeleteHelmReleaseRecord(instanceName: string, namespace: string, log?: Logger): Promise<void>;
+export declare function hasDeployedHelmRelease(instanceName: string, namespace: string): Promise<boolean>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVsbS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NwYXJ0YW4vdXRpbHMvaGVsbS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQXdCcEQsd0JBQWdCLGlCQUFpQixDQUFDLEVBQ2hDLFlBQVksRUFDWixZQUFZLEVBQ1osU0FBUyxFQUNULFVBQVUsRUFDVixPQUFPLEVBQ1AsTUFBTSxFQUNOLFdBQW1CLEVBQ3BCLEVBQUU7SUFDRCxZQUFZLEVBQUUsTUFBTSxDQUFDO0lBQ3JCLFlBQVksRUFBRSxNQUFNLENBQUM7SUFDckIsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQixVQUFVLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUMvQixPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLE1BQU0sRUFBRSxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsT0FBTyxDQUFDLENBQUM7SUFDbEQsV0FBVyxDQUFDLEVBQUUsT0FBTyxDQUFDO0NBQ3ZCLFVBTUE7QUFFRCx3QkFBc0IsZUFBZSxDQUFDLElBQUksRUFBRSxVQUFVLENBQUMsT0FBTyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxtQkFLbEY7QUFFRCx3QkFBc0Isb0JBQW9CLENBQUMsWUFBWSxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBVy9HO0FBRUQsd0JBQXNCLDRCQUE0QixDQUFDLFlBQVksRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxHQUFHLENBQUMsRUFBRSxNQUFNLGlCQUt2RztBQUVELHdCQUFzQixzQkFBc0IsQ0FBQyxZQUFZLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQU90RyJ9

package/dest/spartan/utils/helm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helm.d.ts","sourceRoot":"","sources":["../../../src/spartan/utils/helm.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAwBpD,wBAAgB,iBAAiB,CAAC,EAChC,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,UAAU,EACV,OAAO,EACP,MAAM,EACN,WAAmB,EACpB,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IAClD,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,UAMA;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC,mBAKlF;AAED,wBAAsB,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAW/G;AAED,wBAAsB,4BAA4B,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,iBAKvG;AAED,wBAAsB,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOtG"}