@aztec/end-to-end 0.0.1-commit.9ef841308 → 0.0.1-commit.a89ec08

package/src/fixtures/get_bb_config.ts

@@ -13,10 +13,8 @@ const {
   BB_SKIP_CLEANUP = '',
   TEMP_DIR = tmpdir(),
   BB_WORKING_DIRECTORY = '',
-  BB_NUM_IVC_VERIFIERS = '8',
+  BB_NUM_IVC_VERIFIERS = '1',
   BB_IVC_CONCURRENCY = '1',
-  BB_CHONK_VERIFY_MAX_BATCH = '16',
-  BB_CHONK_VERIFY_BATCH_CONCURRENCY = '6',
 } = process.env;
 
 export const getBBConfig = async (
@@ -43,15 +41,16 @@ export const getBBConfig = async (
     const bbSkipCleanup = ['1', 'true'].includes(BB_SKIP_CLEANUP);
     const cleanup = bbSkipCleanup ? () => Promise.resolve() : () => tryRmDir(directoryToCleanup);
 
+    const numIvcVerifiers = Number(BB_NUM_IVC_VERIFIERS);
+    const ivcConcurrency = Number(BB_IVC_CONCURRENCY);
+
     return {
       bbSkipCleanup,
       bbBinaryPath,
       bbWorkingDirectory,
       cleanup,
-      numConcurrentIVCVerifiers: Number(BB_NUM_IVC_VERIFIERS),
-      bbIVCConcurrency: Number(BB_IVC_CONCURRENCY),
-      bbChonkVerifyMaxBatch: Number(BB_CHONK_VERIFY_MAX_BATCH),
-      bbChonkVerifyConcurrency: Number(BB_CHONK_VERIFY_BATCH_CONCURRENCY),
+      numConcurrentIVCVerifiers: numIvcVerifiers,
+      bbIVCConcurrency: ivcConcurrency,
     };
   } catch (err) {
     logger.error(`Native BB not available, error: ${err}`);

package/src/fixtures/setup.ts

@@ -30,8 +30,7 @@ import {
   deployAztecL1Contracts,
 } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import type { Delayer } from '@aztec/ethereum/l1-tx-utils';
-import { EthCheatCodes, EthCheatCodesWithState, startAnvil } from '@aztec/ethereum/test';
-import type { Anvil } from '@aztec/ethereum/test';
+import { type Anvil, EthCheatCodes, EthCheatCodesWithState, startAnvil } from '@aztec/ethereum/test';
 import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto/random';
@@ -49,7 +48,7 @@ import type { ProverNodeConfig } from '@aztec/prover-node';
 import { type PXEConfig, getPXEConfig } from '@aztec/pxe/server';
 import type { SequencerClient } from '@aztec/sequencer-client';
 import { type ContractInstanceWithAddress, getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
-import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import type { AztecNodeAdmin, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import {
@@ -210,7 +209,7 @@ export type EndToEndContext = {
   /** The Anvil instance (only set if anvil was started locally). */
   anvil: Anvil | undefined;
   /** The Aztec Node service or client a connected to it. */
-  aztecNode: AztecNode;
+  aztecNode: AztecNode & AztecNodeDebug;
   /** The Aztec Node as a service. */
   aztecNodeService: AztecNodeService;
   /** Client to the Aztec Node admin interface. */

package/src/fixtures/token_utils.ts

@@ -6,8 +6,11 @@ import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger) {
   logger.info(`Deploying Token contract...`);
-  const { contract, instance } = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
+  const {
+    receipt: { contract, instance },
+  } = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18).send({
     from: admin,
+    wait: { returnReceipt: true },
   });
 
   if (initialAdminBalance > 0n) {

package/src/forward-compatibility/wallet_rpc_client.ts

@@ -0,0 +1,14 @@
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { WalletSchema } from '@aztec/aztec.js/wallet';
+import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+
+/**
+ * Creates a JSON-RPC client that connects to a remote wallet service.
+ * The returned object implements the {@link Wallet} interface, proxying all calls over HTTP to the specified URL.
+ */
+export function createWalletClient(url: string): Wallet {
+  return createSafeJsonRpcClient<Wallet>(url, WalletSchema, {
+    namespaceMethods: 'wallet',
+    fetch: makeFetch([1, 2, 3], false),
+  });
+}

package/src/forward-compatibility/wallet_service.ts

@@ -0,0 +1,104 @@
+#!/usr/bin/env -S node --no-warnings
+/**
+ * Standalone entrypoint that spins up a local Aztec network (L1 + node) and exposes a {@link NodeEmbeddedWallet} over
+ * JSON-RPC.
+ *
+ * Intended for forward-compatibility testing: an **old** release image runs this script so that **new** tests can send
+ * new artifacts to old runtime code (loadContractArtifact, ACIR simulator, class-ID computation, entrypoint encoding,
+ * etc.).
+ */
+import { getSchnorrAccountContractAddress } from '@aztec/accounts/schnorr';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { createLocalNetwork } from '@aztec/aztec';
+import { Fr } from '@aztec/aztec.js/fields';
+import { WalletSchema } from '@aztec/aztec.js/wallet';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import { createNamespacedSafeJsonRpcServer, startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
+import { createLogger } from '@aztec/foundation/log';
+import { AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
+
+const logger = createLogger('wallet-service');
+
+const { ETHEREUM_HOSTS = 'http://localhost:8545', NODE_PORT = '8080', WALLET_PORT = '8081' } = process.env;
+
+async function main() {
+  const l1RpcUrls = ETHEREUM_HOSTS.split(',').map(url => url.trim());
+
+  // Some tests (e.g. AMM) need 4 accounts but only 3 are funded via genesis. Generate deterministic keys for a 4th
+  // account so we can compute its address before network startup and include it in genesis funding. We cannot do this
+  // in the test because Wallet interface does not expose account creation functionality (only TestWallet exposes that
+  // but that's not used in forward compatibility testing).
+  const extraAccountSecret = Fr.fromHexString('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+  const extraAccountSalt = Fr.ZERO;
+  const extraAccountSigningKey = GrumpkinScalar.random();
+  const extraAccountAddress = await getSchnorrAccountContractAddress(
+    extraAccountSecret,
+    extraAccountSalt,
+    extraAccountSigningKey,
+  );
+
+  logger.info('Starting wallet service...', { l1RpcUrls });
+
+  // createLocalNetwork deploys L1 contracts, starts the node, and optionally deploys funded test accounts (when
+  // TEST_ACCOUNTS=true via env). We are not proving anything just like is done when local network is started by
+  // the `aztecStart` function. The extra account address is passed via prefundAddresses so it gets fee juice at genesis.
+  const { node, stop: stopNetwork } = await createLocalNetwork(
+    { l1RpcUrls, realProofs: false, prefundAddresses: [extraAccountAddress.toString()] },
+    logger.info,
+  );
+
+  // Create an ephemeral embedded wallet backed by the local node.
+  const wallet = await EmbeddedWallet.create(node, { ephemeral: true });
+
+  // Re-register the initial test accounts so they are available via wallet.getAccounts(). createLocalNetwork deploys
+  // them onchain but uses a temporary wallet that is then stopped.
+  //
+  // We use the non-lazy import path (@aztec/accounts/testing, not /lazy) to avoid the dynamic JSON import that is
+  // incompatible with Node.js import attribute enforcement.
+  const testAccountsData = await getInitialTestAccountsData();
+  const accounts = await Promise.all(
+    testAccountsData.map(({ secret, salt, signingKey }) => wallet.createSchnorrAccount(secret, salt, signingKey)),
+  );
+
+  // Register and deploy the 4th account.
+  const extraAccount = await wallet.createSchnorrAccount(extraAccountSecret, extraAccountSalt, extraAccountSigningKey);
+  const deployMethod = await extraAccount.getDeployMethod();
+  await deployMethod.send({ from: accounts[0].address });
+
+  logger.info('Embedded wallet created', {
+    accounts: [...accounts, extraAccount].map(a => a.address.toString()),
+  });
+
+  // Contract artifacts are large, so allow generous body sizes for RPC requests.
+  const rpcOptions = { maxBodySizeBytes: '50mb' };
+
+  // Serve node RPC
+  const nodeRpcServer = createNamespacedSafeJsonRpcServer({ node: [node, AztecNodeApiSchema] }, rpcOptions);
+  const nodeHttpServer = await startHttpRpcServer(nodeRpcServer, { port: NODE_PORT });
+  logger.info(`Node JSON-RPC server listening on port ${nodeHttpServer.port}`);
+
+  // Serve wallet RPC
+  const walletRpcServer = createNamespacedSafeJsonRpcServer({ wallet: [wallet, WalletSchema] }, rpcOptions);
+  const walletHttpServer = await startHttpRpcServer(walletRpcServer, { port: WALLET_PORT });
+  logger.info(`Wallet JSON-RPC server listening on port ${walletHttpServer.port}`);
+
+  const shutdown = async () => {
+    logger.info('Shutting down...');
+    nodeHttpServer.close();
+    walletHttpServer.close();
+    await wallet.stop();
+    await stopNetwork();
+    process.exit(0);
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  process.once('SIGINT', shutdown);
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  process.once('SIGTERM', shutdown);
+}
+
+main().catch(err => {
+  logger.error('Wallet service failed to start', err);
+  process.exit(1);
+});

package/src/legacy-jest-resolver.cjs

@@ -0,0 +1,135 @@
+// Custom Jest resolver. When CONTRACT_ARTIFACTS_VERSION is set, redirects *only* JSON artifact files under
+// @aztec/noir-contracts.js/artifacts/, @aztec/noir-test-contracts.js/artifacts/, and @aztec/accounts/artifacts/ to a local cache of the pinned
+// legacy versions. TypeScript wrapper classes (e.g. Token.ts) continue to load from the current workspace and use the
+// current @aztec/aztec.js — only the artifact JSON (the deployed-contract ABI / bytecode / notes surface) is swapped.
+//
+// Why JSON-only: the JSON artifact is the actual interchange surface a "deployed contract" exposes. The TS wrapper is
+// generated client-side ergonomics that's tightly coupled to the current @aztec/aztec.js API. Redirecting the wrapper
+// would couple this test to a moving aztec.js surface and break at import time on unrelated breaking changes; we want
+// to fail only on actual artifact-compat regressions.
+//
+// The cache is populated on demand by running `npm install` into .legacy-contracts/<version>/.
+//
+// Activated by env var; passthrough otherwise.
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+const version = process.env.CONTRACT_ARTIFACTS_VERSION;
+const REDIRECTED = ['@aztec/noir-contracts.js', '@aztec/noir-test-contracts.js', '@aztec/accounts'];
+
+// Jest sets rootDir to <e2e>/src; this file lives there too.
+const e2eRoot = path.resolve(__dirname, '..');
+const cacheRoot = version ? path.join(e2eRoot, '.legacy-contracts', version) : null;
+
+function pkgJsonPath(name) {
+  return path.join(cacheRoot, 'node_modules', name, 'package.json');
+}
+
+function ensureCache() {
+  const missing = REDIRECTED.some(p => !fs.existsSync(pkgJsonPath(p)));
+  if (!missing) {
+    return;
+  }
+  fs.mkdirSync(cacheRoot, { recursive: true });
+  // Seed a standalone package.json so `npm install --prefix` treats cacheRoot as its own project. Without this, npm
+  // walks up and finds the yarn-project workspace root, which breaks on `workspace:` protocol deps and risks
+  // clobbering the monorepo's node_modules.
+  const seed = path.join(cacheRoot, 'package.json');
+  if (!fs.existsSync(seed)) {
+    fs.writeFileSync(seed, JSON.stringify({ name: 'legacy-contracts-cache', private: true }));
+  }
+
+  const specs = REDIRECTED.map(p => `${p}@${version}`).join(' ');
+  process.stderr.write(`[legacy-contracts] installing ${specs} into ${cacheRoot}\n`);
+  // --prefix: install into cacheRoot instead of cwd, so the cache is isolated from the monorepo.
+  // --no-save: don't write the installed packages back to the seeded package.json.
+  // --ignore-scripts: skip lifecycle scripts (preinstall/postinstall) of the legacy packages and their transitive
+  //   deps; we only want the files on disk, not to run any build steps.
+  // --legacy-peer-deps: tolerate peer-dependency mismatches between the pinned legacy @aztec/* graph and whatever
+  //   current versions npm would otherwise try to reconcile.
+  execSync(`npm install --prefix "${cacheRoot}" --no-save --ignore-scripts --legacy-peer-deps ${specs}`, {
+    stdio: 'inherit',
+  });
+
+  // Verify versions on disk match the requested version.
+  for (const p of REDIRECTED) {
+    const onDisk = JSON.parse(fs.readFileSync(pkgJsonPath(p), 'utf8')).version;
+    if (onDisk !== version) {
+      throw new Error(`[legacy-contracts] ${p} on disk is ${onDisk}, expected ${version}`);
+    }
+  }
+}
+
+if (version) {
+  ensureCache();
+}
+
+let bannerPrinted = false;
+const seen = new Set();
+
+function printBannerOnce() {
+  if (bannerPrinted || !version) {
+    return;
+  }
+  bannerPrinted = true;
+  const lines = ['='.repeat(60), `[legacy-contracts][jest] CONTRACT_ARTIFACTS_VERSION=${version}`];
+  for (const p of REDIRECTED) {
+    const v = JSON.parse(fs.readFileSync(pkgJsonPath(p), 'utf8')).version;
+    if (v !== version) {
+      throw new Error(`[legacy-contracts] ${p} on disk is ${v}, expected ${version}`);
+    }
+    lines.push(`[legacy-contracts][jest] redirecting ${p}/artifacts/*.json -> .legacy-contracts/${version}/...`);
+  }
+  lines.push('='.repeat(60));
+  process.stderr.write(lines.join('\n') + '\n');
+}
+
+// Match a resolved absolute path against the workspace artifacts dirs and return the legacy cache equivalent, or null
+// if it's not an artifact path we should redirect.
+function legacyArtifactPath(resolved) {
+  if (!resolved.endsWith('.json')) {
+    return null;
+  }
+  for (const pkg of REDIRECTED) {
+    // pkg = '@aztec/noir-contracts.js' -> match '/noir-contracts.js/artifacts/'
+    const dirName = pkg.split('/')[1];
+    const marker = `/${dirName}/artifacts/`;
+    const idx = resolved.indexOf(marker);
+    if (idx === -1) {
+      continue;
+    }
+    const basename = resolved.slice(idx + marker.length);
+    return path.join(cacheRoot, 'node_modules', pkg, 'artifacts', basename);
+  }
+  return null;
+}
+
+module.exports = function legacyResolver(request, options) {
+  // Always run the default resolver first. We only inspect (and possibly rewrite) the *result*; this catches both
+  // bare-specifier imports of `@aztec/noir-contracts.js/artifacts/foo.json` and the relative `../artifacts/foo.json`
+  // imports inside the workspace TS wrapper classes — both resolve to the same workspace artifact path that we then
+  // redirect.
+  const resolved = options.defaultResolver(request, options);
+  if (!version) {
+    return resolved;
+  }
+  printBannerOnce();
+  const legacy = legacyArtifactPath(resolved);
+  if (!legacy) {
+    return resolved;
+  }
+  if (!fs.existsSync(legacy)) {
+    throw new Error(
+      `[legacy-contracts] artifact ${path.basename(legacy)} not present in legacy cache @${version}; ` +
+        `the contract may have been added after that release. Pin a newer CONTRACT_ARTIFACTS_VERSION or skip this test.`,
+    );
+  }
+  if (!seen.has(resolved)) {
+    seen.add(resolved);
+    process.stderr.write(`[legacy-contracts][jest] redirected ${path.basename(legacy)} -> ${legacy}\n`);
+  }
+  return legacy;
+};

package/src/shared/jest_setup.ts

@@ -1,19 +1,8 @@
 import { createLogger } from '@aztec/aztec.js/log';
 
-import { afterAll, afterEach, beforeEach, expect } from '@jest/globals';
-import { readlinkSync } from 'fs';
+import { beforeEach, expect } from '@jest/globals';
 import { basename } from 'path';
 
-import { EluMonitor } from '../fixtures/elu_monitor.js';
-
-const eluMonitor = process.env.ELU_MONITOR_FILE
-  ? new EluMonitor(process.env.ELU_MONITOR_FILE, Number(process.env.ELU_MONITOR_INTERVAL_MS) || undefined)
-  : undefined;
-
-if (eluMonitor) {
-  process.on('exit', () => eluMonitor.stop());
-}
-
 beforeEach(() => {
   const { testPath, currentTestName } = expect.getState();
   if (!testPath || !currentTestName) {
@@ -21,43 +10,4 @@ beforeEach(() => {
   }
   const logger = createLogger(`e2e:${basename(testPath).replace('.test.ts', '')}`);
   logger.info(`Running test: ${currentTestName}`);
-  eluMonitor?.startTest(currentTestName);
-});
-
-afterEach(() => {
-  eluMonitor?.stopTest();
-});
-
-// Log leaked handles after all tests complete. This runs after test-level afterAll hooks,
-// so any handles still alive at this point were not properly cleaned up during teardown.
-// This diagnostic helps identify the source of exit hangs without masking them.
-afterAll(() => {
-  const handles = (process as any)._getActiveHandles();
-  if (handles.length > 0) {
-    const details = handles.map((h: any) => {
-      const type = h?.constructor?.name ?? typeof h;
-      const fd = h?.fd ?? h?._handle?.fd ?? '?';
-      const destroyed = h?.destroyed ?? '?';
-      const hasRef = typeof h?.hasRef === 'function' ? h.hasRef() : '?';
-      const localAddr = h?.localAddress ?? '';
-      const remoteAddr = h?.remoteAddress ?? '';
-      const localPort = h?.localPort ?? '';
-      const remotePort = h?.remotePort ?? '';
-      const proto = Object.getPrototypeOf(h)?.constructor?.name ?? '?';
-      const keys = Object.keys(h).slice(0, 10).join(',');
-      let fdTarget = '';
-      if (typeof fd === 'number') {
-        try {
-          fdTarget = ` -> ${readlinkSync(`/proc/self/fd/${fd}`)}`;
-        } catch {
-          // ignore
-        }
-      }
-      return `  ${type}(fd=${fd}, destroyed=${destroyed}, hasRef=${hasRef}${fdTarget}) proto=${proto} addr=${localAddr}:${localPort}->${remoteAddr}:${remotePort} keys=[${keys}]`;
-    });
-    process.stderr.write(
-      `\n[jest_setup] WARNING: ${handles.length} handle(s) still active after teardown:\n${details.join('\n')}\n` +
-        `These may prevent Jest from exiting. Investigate and fix the leak.\n\n`,
-    );
-  }
 });

package/src/shared/submit-transactions.ts

@@ -19,7 +19,10 @@ export const submitTxsTo = async (
     times(numTxs, async () => {
       const accountManager = await wallet.createSchnorrAccount(Fr.random(), Fr.random(), GrumpkinScalar.random());
       const deployMethod = await accountManager.getDeployMethod();
-      const { txHash } = await deployMethod.send({ from: submitter, wait: NO_WAIT });
+      const { txHash } = await deployMethod.send({
+        from: submitter,
+        wait: NO_WAIT,
+      });
 
       logger.info(`Tx sent with hash ${txHash}`);
       const receipt: TxReceipt = await wallet.getTxReceipt(txHash);

package/src/simulators/token_simulator.ts

@@ -110,7 +110,7 @@ export class TokenSimulator {
         chunk(calls, 5).map(batch => new BatchCall(this.defaultWallet, batch).simulate({ from: this.defaultAddress })),
       )
     )
-      .flatMap(r => r.result)
+      .flat()
       .map(r => r.result);
     expect(results[0]).toEqual(this.totalSupply);
 

package/src/spartan/setup_test_wallets.ts

@@ -11,7 +11,7 @@ import type { Wallet } from '@aztec/aztec.js/wallet';
 import { createEthereumChain } from '@aztec/ethereum/chain';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
 import type { Logger } from '@aztec/foundation/log';
-import { makeBackoff, retry, retryUntil } from '@aztec/foundation/retry';
+import { retryUntil } from '@aztec/foundation/retry';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { registerInitialLocalNetworkAccountsInWallet } from '@aztec/wallets/testing';
@@ -139,8 +139,8 @@ async function deployAccountWithDiagnostics(
 ): Promise<void> {
   const deployMethod = await account.getDeployMethod();
   let txHash;
-  let gasSettings: any;
   try {
+    let gasSettings;
     if (estimateGas) {
       const sim = await deployMethod.simulate({ from: NO_FROM, fee: { paymentMethod } });
       gasSettings = sim.estimatedGas;
@@ -170,51 +170,6 @@ async function deployAccountWithDiagnostics(
     });
     throw error;
   }
-
-  // Track the tx hash across retries so we don't re-send when the previous tx is still pending.
-  let sentTxHash: { txHash: any } | undefined;
-
-  await retry(
-    async () => {
-      // Check if already deployed (handles case where previous attempt succeeded but waitForTx timed out)
-      const existing = await aztecNode.getContract(account.address);
-      if (existing) {
-        logger.info(`${accountLabel} already deployed at ${account.address}, skipping`);
-        return;
-      }
-
-      // If we already sent a tx, check if it was dropped before deciding to re-send.
-      if (sentTxHash) {
-        const prevReceipt = await aztecNode.getTxReceipt(sentTxHash.txHash);
-        if (prevReceipt.isDropped()) {
-          logger.info(`${accountLabel} previous tx ${sentTxHash.txHash} was dropped, re-sending`);
-          sentTxHash = undefined;
-        } else {
-          logger.info(`${accountLabel} previous tx ${sentTxHash.txHash} still pending, waiting again...`);
-        }
-      }
-
-      if (!sentTxHash) {
-        const deployResult = await deployMethod.send({
-          from: AztecAddress.ZERO,
-          fee: { paymentMethod, gasSettings },
-          wait: NO_WAIT,
-        });
-        sentTxHash = { txHash: deployResult.txHash };
-        logger.info(`${accountLabel} tx sent`, { txHash: sentTxHash.txHash.toString() });
-      }
-
-      const receipt = await waitForTx(aztecNode, sentTxHash.txHash, { timeout: 600 });
-      if (receipt.isDropped()) {
-        sentTxHash = undefined;
-        throw new Error(`${accountLabel} tx was dropped, retrying...`);
-      }
-      logger.info(`${accountLabel} deployed at ${account.address}`);
-    },
-    `deploy ${accountLabel}`,
-    makeBackoff([1, 2, 4, 8, 16]),
-    logger,
-  );
 }
 
 async function deployAccountsInBatches(
@@ -391,18 +346,14 @@ async function deployTokenAndMint(
   logger: Logger,
 ) {
   logger.verbose(`Deploying TokenContract...`);
-  const { contract: tokenContract } = await TokenContract.deploy(
-    wallet,
-    admin,
-    TOKEN_NAME,
-    TOKEN_SYMBOL,
-    TOKEN_DECIMALS,
-  ).send({
+  const {
+    receipt: { contract: tokenContract },
+  } = await TokenContract.deploy(wallet, admin, TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS).send({
     from: admin,
     fee: {
       paymentMethod,
     },
-    wait: { timeout: 600 },
+    wait: { timeout: 600, returnReceipt: true },
   });
 
   const tokenAddress = tokenContract.address;

package/src/spartan/tx_metrics.ts

@@ -296,7 +296,7 @@ export class TxInclusionMetrics {
           value: stats.mean,
         },
         {
-          name: `${group}/p50_inclusion`,
+          name: `${group}/median_inclusion`,
           unit: 's',
           value: stats.median,
         },

package/src/spartan/utils/config.ts

@@ -8,7 +8,6 @@ const logger = createLogger('e2e:k8s-utils');
 const testConfigSchema = z.object({
   NAMESPACE: z.string().default('scenario'),
   REAL_VERIFIER: schemas.Boolean.optional().default(true),
-  DEBUG_FORCE_TX_PROOF_VERIFICATION: 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(),
@@ -17,7 +16,6 @@ const testConfigSchema = z.object({
   AZTEC_PROOF_SUBMISSION_WINDOW: z.coerce.number().optional().default(5),
   AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: z.coerce.number().optional().default(2),
   FUNDING_PRIVATE_KEY: z.string().optional(),
-  AZTEC_ADMIN_API_KEY: z.string().optional(),
 });
 
 export type TestConfig = z.infer<typeof testConfigSchema>;

package/src/spartan/utils/index.ts

@@ -66,6 +66,3 @@ export { getPublicViemClient, getL1DeploymentAddresses, getNodeClient } from './
 
 // Health checks
 export { ChainHealth, type ChainHealthSnapshot } from './health.js';
-
-// Pod log extraction
-export { type BlockBuiltLogEntry, fetchBlockBuiltLogs } from './pod_logs.js';

package/src/spartan/utils/nodes.ts

@@ -173,7 +173,7 @@ export async function withSequencersAdmin<T>(env: TestConfig, fn: (node: AztecNo
           if (statusRes.status !== 200) {
             throw new Error(`Admin endpoint returned status ${statusRes.status}`);
           }
-          const client = createAztecNodeAdminClient(url, {}, undefined, env.AZTEC_ADMIN_API_KEY);
+          const client = createAztecNodeAdminClient(url);
           return { result: await fn(client), process };
         } catch (err) {
           // Kill the port-forward before retrying
@@ -255,18 +255,21 @@ export async function initHADb(namespace: string): Promise<void> {
 }
 
 /**
- * Sets probabilistic transaction dropping on validators and waits for rollout.
- * Use probability=0 to disable. Wired to env var P2P_DROP_TX_CHANCE via Helm values.
+ * 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: log,
 }: {
   namespace: string;
+  enabled: boolean;
   probability: number;
   logger: Logger;
 }) {
+  const drop = enabled ? 'true' : 'false';
   const prob = String(probability);
 
   const selectors = ['app.kubernetes.io/name=validator', 'app.kubernetes.io/component=validator', 'app=validator'];
@@ -281,7 +284,7 @@ export async function setValidatorTxDrop({
       if (names.length === 0) {
         continue;
       }
-      const cmd = `kubectl set env statefulset -l ${selector} -n ${namespace} P2P_DROP_TX_CHANCE=${prob}`;
+      const cmd = `kubectl set env statefulset -l ${selector} -n ${namespace} P2P_DROP_TX=${drop} P2P_DROP_TX_CHANCE=${prob}`;
       log.info(`command: ${cmd}`);
       await execAsync(cmd);
       updated = true;
@@ -363,24 +366,16 @@ export async function enableValidatorDynamicBootNode(
  */
 export async function rollAztecPods(namespace: string, clearState: boolean = false) {
   // Pod components use 'validator', but StatefulSets and PVCs use 'sequencer-node' for validators
-  // RPC nodes have nodeType='rpc-node' in Helm values, so their component label is 'rpc-node' (not 'rpc')
   const podComponents = [
     'p2p-bootstrap',
     'prover-node',
     'prover-broker',
     'prover-agent',
     'sequencer-node',
-    'rpc-node',
-    'validator-ha-db',
-  ];
-  const pvcComponents = [
-    'p2p-bootstrap',
-    'prover-node',
-    'prover-broker',
-    'sequencer-node',
-    'rpc-node',
+    'rpc',
     'validator-ha-db',
   ];
+  const pvcComponents = ['p2p-bootstrap', 'prover-node', 'prover-broker', 'sequencer-node', 'rpc', 'validator-ha-db'];
   // StatefulSet components that need to be scaled down before PVC deletion
   // Note: validators use 'sequencer-node' as component label, not 'validator'
   const statefulSetComponents = [
@@ -388,7 +383,7 @@ export async function rollAztecPods(namespace: string, clearState: boolean = fal
     'prover-node',
     'prover-broker',
     'sequencer-node',
-    'rpc-node',
+    'rpc',
     'validator-ha-db',
   ];