@aztec/end-to-end 0.0.1-commit.b655e406 → 0.0.1-commit.bf2612ae

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,39 @@
+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.
+ * Tries external IP first, falls back to port-forward.
+ * If CREATE_ETH_DEVNET is false, uses the external RPC url from L1_RPC_URLS_JSON.
+ *
+ * @param env - Test environment config
+ * @param forcePortForward - If true, skip external IP and use port-forward directly
+ * @returns URL, client, and optional process (if port-forward was used). Caller must kill process when done.
+ */
+export declare function getPublicViemClient(env: TestConfig, forcePortForward?: boolean): Promise<{
+    url: string;
+    client: ViemPublicClient;
+    process?: ChildProcess;
+}>;
+/**
+ * Queries an Aztec node for the L1 deployment addresses.
+ *
+ * @param env - Test environment config
+ * @param forcePortForward - If true, skip external IP and use port-forward directly
+ */
+export declare function getL1DeploymentAddresses(env: TestConfig, forcePortForward?: boolean): Promise<L1ContractAddresses>;
+/**
+ * Returns a client to the RPC node.
+ * Tries external IP first, falls back to port-forward.
+ *
+ * @param env - Test environment config
+ * @param forcePortForward - If true, skip external IP and use port-forward directly
+ */
+export declare function getNodeClient(env: TestConfig, forcePortForward?: boolean): Promise<{
+    node: ReturnType<typeof createAztecNodeClient>;
+    url: string;
+    process?: ChildProcess;
+}>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50cy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NwYXJ0YW4vdXRpbHMvY2xpZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBQ2pGLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFOUQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFeEUsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBR2xELE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUs5Qzs7Ozs7Ozs7R0FRRztBQUNILHdCQUFzQixtQkFBbUIsQ0FDdkMsR0FBRyxFQUFFLFVBQVUsRUFDZixnQkFBZ0IsQ0FBQyxFQUFFLE9BQU8sR0FDekIsT0FBTyxDQUFDO0lBQ1QsR0FBRyxFQUFFLE1BQU0sQ0FBQztJQUNaLE1BQU0sRUFBRSxnQkFBZ0IsQ0FBQztJQUN6QixPQUFPLENBQUMsRUFBRSxZQUFZLENBQUM7Q0FDeEIsQ0FBQyxDQW1CRDtBQUVEOzs7OztHQUtHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxHQUFHLEVBQUUsVUFBVSxFQUNmLGdCQUFnQixDQUFDLEVBQUUsT0FBTyxHQUN6QixPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FjOUI7QUFFRDs7Ozs7O0dBTUc7QUFDSCx3QkFBc0IsYUFBYSxDQUNqQyxHQUFHLEVBQUUsVUFBVSxFQUNmLGdCQUFnQixDQUFDLEVBQUUsT0FBTyxHQUN6QixPQUFPLENBQUM7SUFBRSxJQUFJLEVBQUUsVUFBVSxDQUFDLE9BQU8scUJBQXFCLENBQUMsQ0FBQztJQUFDLEdBQUcsRUFBRSxNQUFNLENBQUM7SUFBQyxPQUFPLENBQUMsRUFBRSxZQUFZLENBQUE7Q0FBRSxDQUFDLENBYWxHIn0=

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;AAK9C;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,UAAU,EACf,gBAAgB,CAAC,EAAE,OAAO,GACzB,OAAO,CAAC;IACT,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB,CAAC,CAmBD;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,UAAU,EACf,gBAAgB,CAAC,EAAE,OAAO,GACzB,OAAO,CAAC,mBAAmB,CAAC,CAc9B;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,UAAU,EACf,gBAAgB,CAAC,EAAE,OAAO,GACzB,OAAO,CAAC;IAAE,IAAI,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,YAAY,CAAA;CAAE,CAAC,CAalG"}

package/dest/spartan/utils/clients.js

@@ -0,0 +1,90 @@
+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 { getEthereumEndpoint, getRPCEndpoint } from './k8s.js';
+const logger = createLogger('e2e:k8s-utils');
+/**
+ * Returns a public viem client to the eth execution node.
+ * Tries external IP first, falls back to port-forward.
+ * If CREATE_ETH_DEVNET is false, uses the external RPC url from L1_RPC_URLS_JSON.
+ *
+ * @param env - Test environment config
+ * @param forcePortForward - If true, skip external IP and use port-forward directly
+ * @returns URL, client, and optional process (if port-forward was used). Caller must kill process when done.
+ */ export async function getPublicViemClient(env, forcePortForward) {
+    const { NAMESPACE, CREATE_ETH_DEVNET, L1_RPC_URLS_JSON } = env;
+    if (CREATE_ETH_DEVNET) {
+        logger.info(`Connecting to eth execution node in namespace ${NAMESPACE}`);
+        const endpoint = await getEthereumEndpoint(NAMESPACE, forcePortForward);
+        const client = createPublicClient({
+            transport: fallback([
+                http(endpoint.url, {
+                    batch: false
+                })
+            ])
+        });
+        return {
+            url: endpoint.url,
+            client,
+            process: endpoint.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.
+ *
+ * @param env - Test environment config
+ * @param forcePortForward - If true, skip external IP and use port-forward directly
+ */ export async function getL1DeploymentAddresses(env, forcePortForward) {
+    let endpoint;
+    try {
+        endpoint = await getRPCEndpoint(env.NAMESPACE, forcePortForward);
+        const node = createAztecNodeClient(endpoint.url);
+        return await retry(()=>node.getNodeInfo().then((i)=>i.l1ContractAddresses), 'get node info', makeBackoff([
+            1,
+            3,
+            6
+        ]), logger);
+    } finally{
+        endpoint?.process?.kill();
+    }
+}
+/**
+ * Returns a client to the RPC node.
+ * Tries external IP first, falls back to port-forward.
+ *
+ * @param env - Test environment config
+ * @param forcePortForward - If true, skip external IP and use port-forward directly
+ */ export async function getNodeClient(env, forcePortForward) {
+    const namespace = env.NAMESPACE;
+    const endpoint = await getRPCEndpoint(namespace, forcePortForward);
+    await retry(()=>fetch(`${endpoint.url}/status`).then((res)=>res.status === 200), 'check RPC endpoint', makeBackoff([
+        1,
+        1,
+        2,
+        6
+    ]), logger, true);
+    const client = createAztecNodeClient(endpoint.url);
+    return {
+        node: client,
+        url: endpoint.url,
+        process: endpoint.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhbHRoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3BhcnRhbi91dGlscy9oZWFsdGgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbkUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFNcEQ7O0dBRUc7QUFDSCxNQUFNLFdBQVcsbUJBQW1CO0lBQ2xDLFdBQVcsRUFBRSxNQUFNLENBQUM7SUFDcEIsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUM7SUFDbkMsU0FBUyxFQUFFLE1BQU0sQ0FBQztDQUNuQjtBQUVEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FrQkc7QUFDSCxxQkFBYSxXQUFXO0lBQ3RCLE9BQU8sQ0FBQyxTQUFTLENBQVM7SUFDMUIsT0FBTyxDQUFDLE1BQU0sQ0FBUztJQUN2QixPQUFPLENBQUMsUUFBUSxDQUFDLENBQXNCO0lBRXZDLFlBQVksU0FBUyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUc1QztJQUVEOzs7Ozs7Ozs7Ozs7O09BYUc7SUFDRyxLQUFLLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQW1HM0I7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ0csUUFBUSxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0E4RTlCO0NBQ0YifQ==

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;AAMpD;;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 { getEthereumEndpoint, getRPCEndpoint } 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 endpoints = [];
+        try {
+            // Establish connections (LB or port-forward)
+            const rpcEndpoint = await getRPCEndpoint(this.namespace);
+            endpoints.push(rpcEndpoint);
+            const ethEndpoint = await getEthereumEndpoint(this.namespace);
+            endpoints.push(ethEndpoint);
+            const nodeUrl = rpcEndpoint.url;
+            const ethereumUrl = ethEndpoint.url;
+            // 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{
+            endpoints.forEach((e)=>e.process?.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 endpoints = [];
+        // 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 rpcEndpoint = await getRPCEndpoint(this.namespace);
+            endpoints.push(rpcEndpoint);
+            const ethEndpoint = await getEthereumEndpoint(this.namespace);
+            endpoints.push(ethEndpoint);
+            const nodeUrl = rpcEndpoint.url;
+            const ethereumUrl = ethEndpoint.url;
+            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{
+            endpoints.forEach((e)=>e.process?.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"}