@aztec/end-to-end 0.0.1-commit.3d8f95d → 0.0.1-commit.3f296a7d2

package/src/spartan/utils/bot.ts

@@ -34,7 +34,8 @@ export async function installTransferBot({
   logger: log,
   replicas = 1,
   txIntervalSeconds = 10,
-  followChain = 'PENDING',
+  followChain = 'CHECKPOINTED',
+  pxeSyncChainTip = 'proposed',
   mnemonic = process.env.LABS_INFRA_MNEMONIC ?? 'test test test test test test test test test test test junk',
   mnemonicStartIndex,
   botPrivateKey = process.env.BOT_TRANSFERS_L2_PRIVATE_KEY ?? '0xcafe01',
@@ -49,6 +50,7 @@ export async function installTransferBot({
   replicas?: number;
   txIntervalSeconds?: number;
   followChain?: string;
+  pxeSyncChainTip?: string;
   mnemonic?: string;
   mnemonicStartIndex?: number | string;
   botPrivateKey?: string;
@@ -67,6 +69,7 @@ export async function installTransferBot({
     'bot.replicaCount': replicas,
     'bot.txIntervalSeconds': txIntervalSeconds,
     'bot.followChain': followChain,
+    'bot.pxeSyncChainTip': pxeSyncChainTip,
     'bot.botPrivateKey': botPrivateKey,
     'bot.nodeUrl': resolvedNodeUrl,
     'bot.mnemonic': mnemonic,

package/src/spartan/utils/config.ts

@@ -8,6 +8,7 @@ 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(),
@@ -16,6 +17,7 @@ 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

@@ -25,6 +25,7 @@ export {
   getRPCEndpoint,
   getEthereumEndpoint,
   createResilientPrometheusConnection,
+  scaleProverAgents,
 } from './k8s.js';
 
 // Chaos Mesh
@@ -40,6 +41,9 @@ export {
   applyNetworkShaping,
 } from './chaos.js';
 
+// Helm
+export { hasDeployedHelmRelease } from './helm.js';
+
 // Bot management
 export { restartBot, installTransferBot, uninstallTransferBot } from './bot.js';
 
@@ -62,3 +66,6 @@ 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/k8s.ts

@@ -522,6 +522,14 @@ export function createResilientPrometheusConnection(
   return { connect, runAlertCheck };
 }
 
+/** Scales the prover-agent Deployment to the given number of replicas. */
+export async function scaleProverAgents(namespace: string, replicas: number, log: Logger): Promise<void> {
+  const label = 'app.kubernetes.io/component=prover-agent';
+  const command = `kubectl scale deployment -l ${label} -n ${namespace} --replicas=${replicas} --timeout=2m`;
+  log.info(`Scaling prover agents to ${replicas}: ${command}`);
+  await execAsync(command);
+}
+
 export function getChartDir(spartanDir: string, chartName: string) {
   return path.join(spartanDir.trim(), chartName);
 }

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);
+          const client = createAztecNodeAdminClient(url, {}, undefined, env.AZTEC_ADMIN_API_KEY);
           return { result: await fn(client), process };
         } catch (err) {
           // Kill the port-forward before retrying
@@ -255,21 +255,18 @@ export async function initHADb(namespace: string): Promise<void> {
 }
 
 /**
- * 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.
+ * 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.
  */
 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'];
@@ -284,7 +281,7 @@ export async function setValidatorTxDrop({
       if (names.length === 0) {
         continue;
       }
-      const cmd = `kubectl set env statefulset -l ${selector} -n ${namespace} P2P_DROP_TX=${drop} P2P_DROP_TX_CHANCE=${prob}`;
+      const cmd = `kubectl set env statefulset -l ${selector} -n ${namespace} P2P_DROP_TX_CHANCE=${prob}`;
       log.info(`command: ${cmd}`);
       await execAsync(cmd);
       updated = true;
@@ -366,16 +363,24 @@ 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',
+    'rpc-node',
+    'validator-ha-db',
+  ];
+  const pvcComponents = [
+    'p2p-bootstrap',
+    'prover-node',
+    'prover-broker',
+    'sequencer-node',
+    'rpc-node',
     '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 = [
@@ -383,7 +388,7 @@ export async function rollAztecPods(namespace: string, clearState: boolean = fal
     'prover-node',
     'prover-broker',
     'sequencer-node',
-    'rpc',
+    'rpc-node',
     'validator-ha-db',
   ];
 

package/src/spartan/utils/pod_logs.ts

@@ -0,0 +1,99 @@
+import type { Logger } from '@aztec/foundation/log';
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+import { getSequencers } from './nodes.js';
+
+const execAsync = promisify(exec);
+
+/** Parsed l2-block-built stats from a sequencer pod log line. */
+export type BlockBuiltLogEntry = {
+  blockNumber: number;
+  txCount: number;
+  duration: number;
+  publicProcessDuration: number;
+  manaPerSec: number;
+  privateLogCount: number;
+  publicLogCount: number;
+  contractClassLogCount: number;
+  contractClassLogSize: number;
+};
+
+const FIELDS: (keyof BlockBuiltLogEntry)[] = [
+  'blockNumber',
+  'txCount',
+  'duration',
+  'publicProcessDuration',
+  'manaPerSec',
+  'privateLogCount',
+  'publicLogCount',
+  'contractClassLogCount',
+  'contractClassLogSize',
+];
+
+/**
+ * Fetches l2-block-built log entries from sequencer pods for given block numbers.
+ * Queries all validator pods (only the proposer will have the log for a given block).
+ *
+ * @param namespace - Kubernetes namespace
+ * @param sinceTime - ISO 8601 timestamp to limit log search (e.g., from before block building was re-enabled)
+ * @param blockNumbers - Set of block numbers to filter for
+ * @param logger - Logger instance
+ * @returns Array of parsed BlockBuiltLogEntry, de-duplicated by blockNumber, sorted ascending
+ */
+export async function fetchBlockBuiltLogs(
+  namespace: string,
+  sinceTime: string,
+  blockNumbers: Set<number>,
+  logger: Logger,
+): Promise<BlockBuiltLogEntry[]> {
+  const pods = await getSequencers(namespace);
+  const entriesByBlock = new Map<number, BlockBuiltLogEntry>();
+
+  // Subtract 60s from sinceTime to account for clock skew between test runner and k8s pods.
+  // Block number filtering ensures we only match the right blocks, so extra lines are harmless.
+  const sinceDate = new Date(new Date(sinceTime).getTime() - 60_000);
+  const sinceFlag = sinceDate.toISOString();
+
+  for (const pod of pods) {
+    try {
+      const cmd = `kubectl logs ${pod} -n ${namespace} -c aztec --since-time=${sinceFlag}`;
+      logger.info(`Fetching logs: ${cmd}`);
+      const { stdout } = await execAsync(cmd, { maxBuffer: 10 * 1024 * 1024 });
+
+      const lines = stdout.split('\n');
+      const matchingLines = lines.filter(l => l.includes('l2-block-built'));
+      logger.info(`Pod ${pod}: ${lines.length} log lines, ${matchingLines.length} contain l2-block-built`);
+
+      for (const line of matchingLines) {
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.eventName !== 'l2-block-built' || !blockNumbers.has(parsed.blockNumber)) {
+            continue;
+          }
+          if (entriesByBlock.has(parsed.blockNumber)) {
+            continue;
+          }
+          const entry: BlockBuiltLogEntry = {} as BlockBuiltLogEntry;
+          for (const field of FIELDS) {
+            entry[field] = parsed[field] ?? 0;
+          }
+          entriesByBlock.set(entry.blockNumber, entry);
+          logger.verbose(`Parsed l2-block-built log for block ${entry.blockNumber}`, entry);
+        } catch {
+          // Not valid JSON, skip
+        }
+      }
+    } catch (err) {
+      logger.warn(`Failed to fetch logs from pod ${pod}: ${err}`);
+    }
+  }
+
+  if (entriesByBlock.size < blockNumbers.size) {
+    const missing = [...blockNumbers].filter(bn => !entriesByBlock.has(bn));
+    logger.warn(`Missing l2-block-built logs for block(s): ${missing.join(', ')}`);
+  }
+
+  return [...entriesByBlock.values()].sort((a, b) => a.blockNumber - b.blockNumber);
+}

package/src/test-wallet/test_wallet.ts

@@ -0,0 +1,301 @@
+import { EcdsaKAccountContract, EcdsaRAccountContract } from '@aztec/accounts/ecdsa';
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
+import { type Account, type AccountContract, NO_FROM } from '@aztec/aztec.js/account';
+import {
+  type CallIntent,
+  type ContractFunctionInteractionCallIntent,
+  type IntentInnerHash,
+  SetPublicAuthwitContractInteraction,
+  computeInnerAuthWitHashFromAction,
+  isContractFunctionInteractionCallIntent,
+  lookupValidity,
+} from '@aztec/aztec.js/authorization';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { AccountManager, type SendOptions } from '@aztec/aztec.js/wallet';
+import type { DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
+import { DefaultEntrypoint } from '@aztec/entrypoints/default';
+import { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import type { NotesFilter } from '@aztec/pxe/client/lazy';
+import { type PXEConfig, getPXEConfig } from '@aztec/pxe/config';
+import { PXE, type PXECreationOptions, createPXE } from '@aztec/pxe/server';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+import type { NoteDao } from '@aztec/stdlib/note';
+import type {
+  BlockHeader,
+  SimulationOverrides,
+  TxExecutionRequest,
+  TxHash,
+  TxReceipt,
+  TxSimulationResult,
+} from '@aztec/stdlib/tx';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
+import { BaseWallet, type SimulateViaEntrypointOptions } from '@aztec/wallet-sdk/base-wallet';
+
+import { AztecNodeProxy, ProvenTx } from './utils.js';
+
+/**
+ * Data for generating an account.
+ */
+export interface AccountData {
+  secret: Fr;
+  salt: Fr;
+  contract: AccountContract;
+}
+
+/**
+ * Wallet implementation that stores accounts in memory and provides extra debugging
+ * utilities
+ * It is intended to be used in e2e tests.
+ */
+export class TestWallet extends BaseWallet {
+  constructor(
+    pxe: PXE,
+    private readonly nodeRef: AztecNodeProxy,
+  ) {
+    super(pxe, nodeRef);
+  }
+
+  static async create(
+    node: AztecNode,
+    overridePXEConfig?: Partial<PXEConfig>,
+    options: PXECreationOptions = { loggers: {} },
+  ): Promise<TestWallet> {
+    const nodeRef = new AztecNodeProxy(node);
+    const pxeConfig = Object.assign(getPXEConfig(), {
+      proverEnabled: overridePXEConfig?.proverEnabled ?? false,
+      ...overridePXEConfig,
+    });
+    const pxe = await createPXE(nodeRef, pxeConfig, options);
+    return new TestWallet(pxe, nodeRef);
+  }
+
+  /**
+   * Updates the underlying node that this wallet and its PXE communicate with.
+   * @param node - The new AztecNode to forward all calls to.
+   */
+  updateNode(node: AztecNode): void {
+    this.nodeRef.updateTargetNode(node);
+  }
+
+  createSchnorrAccount(secret: Fr, salt: Fr, signingKey?: Fq): Promise<AccountManager> {
+    signingKey = signingKey ?? deriveSigningKey(secret);
+    const accountData = {
+      secret,
+      salt,
+      contract: new SchnorrAccountContract(signingKey),
+    };
+    return this.createAccount(accountData);
+  }
+
+  createECDSARAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<AccountManager> {
+    const accountData = {
+      secret,
+      salt,
+      contract: new EcdsaRAccountContract(signingKey),
+    };
+    return this.createAccount(accountData);
+  }
+
+  createECDSAKAccount(secret: Fr, salt: Fr, signingKey: Buffer): Promise<AccountManager> {
+    const accountData = {
+      secret,
+      salt,
+      contract: new EcdsaKAccountContract(signingKey),
+    };
+    return this.createAccount(accountData);
+  }
+
+  async getFakeAccountDataFor(address: AztecAddress) {
+    const originalAccount = await this.getAccountFromAddress(address);
+    const originalAddress = originalAccount.getCompleteAddress();
+    const contractInstance = await this.pxe.getContractInstance(originalAddress.address);
+    if (!contractInstance) {
+      throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+    }
+    const stubAccount = createStubAccount(originalAddress);
+    const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
+      salt: Fr.random(),
+    });
+    return {
+      account: stubAccount,
+      instance,
+      artifact: StubAccountContractArtifact,
+    };
+  }
+  protected accounts: Map<string, Account> = new Map();
+
+  /**
+   * Controls how the test wallet simulates transactions:
+   * - `kernelless`: Skips kernel circuits but uses the real account contract. Default.
+   * - `kernelless-override`: Skips kernels and replaces the account with a stub that doesn't do authwit validation.
+   * - `full`: Uses real kernel circuits and real account contracts. Slow!
+   */
+  private simulationMode: 'kernelless' | 'kernelless-override' | 'full' = 'kernelless';
+
+  setSimulationMode(mode: 'kernelless' | 'kernelless-override' | 'full') {
+    this.simulationMode = mode;
+  }
+
+  setMinFeePadding(value?: number) {
+    this.minFeePadding = value ?? 0.5;
+  }
+
+  protected getAccountFromAddress(address: AztecAddress): Promise<Account> {
+    const account = this.accounts.get(address?.toString() ?? '');
+
+    if (!account) {
+      throw new Error(`Account not found in wallet for address: ${address}`);
+    }
+
+    return Promise.resolve(account);
+  }
+
+  getAccounts() {
+    return Promise.resolve(Array.from(this.accounts.values()).map(acc => ({ alias: '', item: acc.getAddress() })));
+  }
+
+  async createAccount(accountData?: AccountData): Promise<AccountManager> {
+    const secret = accountData?.secret ?? Fr.random();
+    const salt = accountData?.salt ?? Fr.random();
+    const contract = accountData?.contract ?? new SchnorrAccountContract(GrumpkinScalar.random());
+
+    const accountManager = await AccountManager.create(this, secret, contract, salt);
+
+    const instance = accountManager.getInstance();
+    const artifact = await contract.getContractArtifact();
+
+    await this.registerContract(instance, artifact, secret);
+
+    this.accounts.set(accountManager.address.toString(), await accountManager.getAccount());
+
+    return accountManager;
+  }
+
+  lookupValidity(
+    onBehalfOf: AztecAddress,
+    intent: IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+    witness: AuthWitness,
+  ): Promise<{
+    isValidInPrivate: boolean;
+    isValidInPublic: boolean;
+  }> {
+    return lookupValidity(this, onBehalfOf, intent, witness);
+  }
+
+  public setPublicAuthWit(
+    from: AztecAddress,
+    messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+    authorized: boolean,
+  ): Promise<SetPublicAuthwitContractInteraction> {
+    return SetPublicAuthwitContractInteraction.create(this, from, messageHashOrIntent, authorized);
+  }
+
+  public override async createAuthWit(
+    from: AztecAddress,
+    intent: IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent,
+  ): Promise<AuthWitness> {
+    const account = await this.getAccountFromAddress(from);
+    const chainInfo = await this.getChainInfo();
+    let intentInnerHash: IntentInnerHash;
+    if ('caller' in intent) {
+      const call = isContractFunctionInteractionCallIntent(intent)
+        ? await intent.action.getFunctionCall()
+        : intent.call;
+      const innerHash = await computeInnerAuthWitHashFromAction(intent.caller, call);
+      intentInnerHash = { innerHash, consumer: call.to };
+    } else {
+      intentInnerHash = intent;
+    }
+    return account.createAuthWit(intentInnerHash, chainInfo);
+  }
+
+  protected override async simulateViaEntrypoint(
+    executionPayload: ExecutionPayload,
+    opts: SimulateViaEntrypointOptions,
+  ): Promise<TxSimulationResult> {
+    const { from, feeOptions, scopes, skipTxValidation, skipFeeEnforcement } = opts;
+    const skipKernels = this.simulationMode !== 'full';
+    const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
+    const finalExecutionPayload = feeExecutionPayload
+      ? mergeExecutionPayloads([feeExecutionPayload, executionPayload])
+      : executionPayload;
+    const chainInfo = await this.getChainInfo();
+
+    let overrides: SimulationOverrides | undefined;
+    let txRequest: TxExecutionRequest;
+    if (from === NO_FROM) {
+      const entrypoint = new DefaultEntrypoint();
+      txRequest = await entrypoint.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo);
+    } else {
+      const useOverride = this.simulationMode === 'kernelless-override';
+      let fromAccount: Account;
+      if (useOverride) {
+        const { account, instance, artifact } = await this.getFakeAccountDataFor(from);
+        fromAccount = account;
+        overrides = {
+          contracts: { [from.toString()]: { instance, artifact } },
+        };
+      } else {
+        fromAccount = await this.getAccountFromAddress(from);
+      }
+      const executionOptions: DefaultAccountEntrypointOptions = {
+        txNonce: Fr.random(),
+        cancellable: this.cancellableTransactions,
+        // If from is an address, feeOptions include the way the account contract should handle the fee payment
+        feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions!,
+      };
+      txRequest = await fromAccount.createTxExecutionRequest(
+        finalExecutionPayload,
+        feeOptions.gasSettings,
+        chainInfo,
+        executionOptions,
+      );
+    }
+
+    return this.pxe.simulateTx(txRequest, {
+      simulatePublic: true,
+      skipKernels,
+      skipFeeEnforcement,
+      skipTxValidation,
+      overrides,
+      scopes,
+    });
+  }
+
+  async proveTx(exec: ExecutionPayload, opts: Omit<SendOptions, 'wait'>): Promise<ProvenTx> {
+    const fee = await this.completeFeeOptions(opts.from, exec.feePayer, opts.fee?.gasSettings);
+    const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(exec, opts.from, fee);
+    const txProvingResult = await this.pxe.proveTx(txRequest, this.scopesFrom(opts.from, opts.additionalScopes));
+    return new ProvenTx(
+      this.aztecNode,
+      await txProvingResult.toTx(),
+      txProvingResult.getOffchainEffects(),
+      txProvingResult.stats,
+    );
+  }
+
+  getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
+    return this.aztecNode.getTxReceipt(txHash);
+  }
+
+  getNotes(filter: NotesFilter): Promise<NoteDao[]> {
+    return this.pxe.debug.getNotes(filter);
+  }
+
+  getSyncedBlockHeader(): Promise<BlockHeader> {
+    return this.pxe.getSyncedBlockHeader();
+  }
+
+  sync(): Promise<void> {
+    return this.pxe.debug.sync();
+  }
+
+  stop(): Promise<void> {
+    return this.pxe.stop();
+  }
+}

package/src/test-wallet/utils.ts

@@ -0,0 +1,112 @@
+import {
+  ContractFunctionInteraction,
+  DeployMethod,
+  type DeployOptions,
+  NO_WAIT,
+  type NoWait,
+  type SendInteractionOptions,
+  type WaitOpts,
+  toSendOptions,
+} from '@aztec/aztec.js/contracts';
+import { type AztecNode, waitForTx } from '@aztec/aztec.js/node';
+import { SimulationError } from '@aztec/stdlib/errors';
+import { type OffchainEffect, type ProvingStats, Tx, TxHash, type TxReceipt } from '@aztec/stdlib/tx';
+
+import { inspect } from 'util';
+
+import type { TestWallet } from './test_wallet.js';
+
+export type ProvenTxSendOpts = {
+  wait?: NoWait | WaitOpts;
+};
+
+export type ProvenTxSendReturn<T extends NoWait | WaitOpts | undefined> = T extends NoWait ? TxHash : TxReceipt;
+
+export class ProvenTx extends Tx {
+  constructor(
+    private node: AztecNode,
+    tx: Tx,
+    public offchainEffects: OffchainEffect[],
+    public stats?: ProvingStats,
+  ) {
+    super(tx.getTxHash(), tx.data, tx.chonkProof, tx.contractClassLogFields, tx.publicFunctionCalldata);
+  }
+
+  send(options?: Omit<ProvenTxSendOpts, 'wait'>): Promise<TxReceipt>;
+  send<W extends ProvenTxSendOpts['wait']>(options: ProvenTxSendOpts & { wait: W }): Promise<ProvenTxSendReturn<W>>;
+  async send(options?: ProvenTxSendOpts): Promise<TxHash | TxReceipt> {
+    const txHash = this.getTxHash();
+    await this.node.sendTx(this).catch(err => {
+      throw this.contextualizeError(err, inspect(this));
+    });
+
+    if (options?.wait === NO_WAIT) {
+      return txHash;
+    }
+
+    const waitOpts = typeof options?.wait === 'object' ? options.wait : undefined;
+    return await waitForTx(this.node, txHash, waitOpts);
+  }
+
+  private contextualizeError(err: Error, ...context: string[]): Error {
+    let contextStr = '';
+    if (context.length > 0) {
+      contextStr = `\nContext:\n${context.join('\n')}`;
+    }
+    if (err instanceof SimulationError) {
+      err.setAztecContext(contextStr);
+    }
+    return err;
+  }
+}
+
+export async function proveInteraction(
+  wallet: TestWallet,
+  interaction: ContractFunctionInteraction | DeployMethod,
+  options: SendInteractionOptions | DeployOptions,
+) {
+  let execPayload;
+  if (interaction instanceof DeployMethod) {
+    execPayload = await interaction.request(interaction.convertDeployOptionsToRequestOptions(options));
+  } else {
+    execPayload = await interaction.request(options);
+  }
+  return wallet.proveTx(execPayload, toSendOptions(options));
+}
+
+/**
+ * Extends AztecNode via declaration merging so instances can be used wherever AztecNode is expected.
+ * The actual method forwarding is handled by a Proxy in the class constructor.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+export interface AztecNodeProxy extends AztecNode {}
+
+/**
+ * Mutable wrapper around an AztecNode that forwards all calls to the current target.
+ * Allows swapping the underlying node at runtime via updateTargetNode, which is useful
+ * for tests that need to redirect a wallet from one node to another without recreating it.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+export class AztecNodeProxy {
+  constructor(private target: AztecNode) {
+    return new Proxy(this, {
+      get: (obj, prop, receiver) => {
+        // Own properties and methods (updateTargetNode, target) are served directly.
+        if (Reflect.has(obj, prop)) {
+          return Reflect.get(obj, prop, receiver);
+        }
+        // Everything else is forwarded to the current target node.
+        const val = (obj.target as unknown as Record<string | symbol, unknown>)[prop];
+        return typeof val === 'function' ? val.bind(obj.target) : val;
+      },
+    });
+  }
+
+  /**
+   * Updates the underlying node that this reference points to.
+   * @param node - The new node to forward calls to.
+   */
+  updateTargetNode(node: AztecNode): void {
+    this.target = node;
+  }
+}