@aztec/end-to-end 0.0.1-commit.7cf39cb55 → 0.0.1-commit.808bf7f90

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

@@ -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/test-wallet/test_wallet.ts

@@ -16,13 +16,14 @@ import { AccountManager, type SendOptions } from '@aztec/aztec.js/wallet';
 import type { DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
 import { Fq, Fr } from '@aztec/foundation/curves/bn254';
 import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import type { AccessScopes, 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, NotesFilter } from '@aztec/stdlib/note';
+import type { NoteDao } from '@aztec/stdlib/note';
 import type { BlockHeader, TxHash, TxReceipt, TxSimulationResult } from '@aztec/stdlib/tx';
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 import { BaseWallet, type FeeOptions } from '@aztec/wallet-sdk/base-wallet';
@@ -227,18 +228,18 @@ export class TestWallet extends BaseWallet {
     executionPayload: ExecutionPayload,
     from: AztecAddress,
     feeOptions: FeeOptions,
+    scopes: AccessScopes,
     skipTxValidation?: boolean,
     skipFeeEnforcement?: boolean,
-    scopes?: AztecAddress[],
   ): Promise<TxSimulationResult> {
     if (!this.simulatedSimulations) {
       return super.simulateViaEntrypoint(
         executionPayload,
         from,
         feeOptions,
+        scopes,
         skipTxValidation,
         skipFeeEnforcement,
-        scopes,
       );
     }
 
@@ -274,7 +275,7 @@ export class TestWallet extends BaseWallet {
   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.scopesFor(opts.from));
+    const txProvingResult = await this.pxe.proveTx(txRequest, this.scopesFrom(opts.from, opts.additionalScopes));
     return new ProvenTx(
       this.aztecNode,
       await txProvingResult.toTx(),

package/src/test-wallet/wallet_worker_script.ts

@@ -0,0 +1,60 @@
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import type { SendOptions } from '@aztec/aztec.js/wallet';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import type { ApiSchema, Fr } from '@aztec/foundation/schemas';
+import { parseWithOptionals, schemaHasMethod } from '@aztec/foundation/schemas';
+import { NodeListener, TransportServer } from '@aztec/foundation/transport';
+import { ExecutionPayload, Tx } from '@aztec/stdlib/tx';
+
+import { workerData } from 'worker_threads';
+
+import { TestWallet } from './test_wallet.js';
+import { WorkerWalletSchema } from './worker_wallet_schema.js';
+
+const logger = createLogger('e2e:test-wallet:worker');
+
+try {
+  const { nodeUrl, pxeConfig } = workerData as { nodeUrl: string; pxeConfig?: Record<string, unknown> };
+
+  logger.info('Initializing worker wallet', { nodeUrl });
+  const node = createAztecNodeClient(nodeUrl);
+  const wallet = await TestWallet.create(node, pxeConfig);
+  logger.info('Worker wallet initialized');
+
+  const customMethods = {
+    proveTx: async (exec: ExecutionPayload, opts: Omit<SendOptions, 'wait'>) => {
+      const provenTx = await wallet.proveTx(exec, opts);
+      return new Tx(
+        provenTx.getTxHash(),
+        provenTx.data,
+        provenTx.chonkProof,
+        provenTx.contractClassLogFields,
+        provenTx.publicFunctionCalldata,
+      );
+    },
+    registerAccount: async (secret: Fr, salt: Fr) => {
+      const manager = await wallet.createSchnorrAccount(secret, salt);
+      return manager.address;
+    },
+  };
+
+  const schema = WorkerWalletSchema as ApiSchema;
+  const listener = new NodeListener();
+  const server = new TransportServer<{ fn: string; args: string }>(listener, async msg => {
+    if (!schemaHasMethod(schema, msg.fn)) {
+      throw new Error(`Unknown method: ${msg.fn}`);
+    }
+    const jsonParams = JSON.parse(msg.args) as unknown[];
+    const args: any[] = await parseWithOptionals(jsonParams, schema[msg.fn].parameters());
+    // we have to erase the fn type in order to be able to spread ...args
+    const handler: ((...args: any[]) => Promise<any>) | undefined =
+      msg.fn in customMethods ? customMethods[msg.fn as keyof typeof customMethods] : undefined;
+    const result = handler ? await handler(...args) : await (wallet as any)[msg.fn](...args);
+    return jsonStringify(result);
+  });
+  server.start();
+} catch (err: unknown) {
+  logger.error('Worker wallet initialization failed', { error: err instanceof Error ? err.stack : String(err) });
+  process.exit(1);
+}

package/src/test-wallet/worker_wallet.ts

@@ -0,0 +1,213 @@
+import type { CallIntent, IntentInnerHash } from '@aztec/aztec.js/authorization';
+import type { InteractionWaitOptions, SendReturn } from '@aztec/aztec.js/contracts';
+import type {
+  Aliased,
+  AppCapabilities,
+  BatchResults,
+  BatchedMethod,
+  ContractClassMetadata,
+  ContractMetadata,
+  ExecuteUtilityOptions,
+  PrivateEvent,
+  PrivateEventFilter,
+  ProfileOptions,
+  SendOptions,
+  SimulateOptions,
+  Wallet,
+  WalletCapabilities,
+} from '@aztec/aztec.js/wallet';
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import type { ApiSchema } from '@aztec/foundation/schemas';
+import { sleep } from '@aztec/foundation/sleep';
+import { NodeConnector, TransportClient } from '@aztec/foundation/transport';
+import type { PXEConfig } from '@aztec/pxe/config';
+import type { ContractArtifact, EventMetadataDefinition, FunctionCall } from '@aztec/stdlib/abi';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { ExecutionPayload, TxProfileResult, TxSimulationResult, UtilityExecutionResult } from '@aztec/stdlib/tx';
+import { Tx } from '@aztec/stdlib/tx';
+
+import { Worker } from 'worker_threads';
+
+import { WorkerWalletSchema } from './worker_wallet_schema.js';
+
+type WorkerMsg = { fn: string; args: string };
+
+const log = createLogger('e2e:test-wallet:worker-wallet');
+
+const WORKER_READY_TIMEOUT_MS = 120_000;
+
+/**
+ * Wallet implementation that offloads all work to a worker thread.
+ * Implements the Wallet interface by proxying calls over a transport layer
+ * using JSON serialization with Zod schema parsing on both ends.
+ */
+export class WorkerWallet implements Wallet {
+  private constructor(
+    private worker: Worker,
+    private client: TransportClient<WorkerMsg>,
+  ) {}
+
+  /**
+   * Creates a WorkerWallet by spawning a worker thread that creates a TestWallet internally.
+   * @param nodeUrl - URL of the Aztec node to connect to.
+   * @param pxeConfig - Optional PXE configuration overrides.
+   * @returns A WorkerWallet ready to use.
+   */
+  static async create(nodeUrl: string, pxeConfig?: Partial<PXEConfig>): Promise<WorkerWallet> {
+    // replace stc/ with dest/ so the wallet works in Jest tests
+    const workerUrl = new URL('./wallet_worker_script.js', import.meta.url);
+    workerUrl.pathname = workerUrl.pathname.replace('/src/', '/dest/');
+    // remove JEST_WORKER_ID so the worker uses pino-pretty transport instead of Jest's raw output.
+    const { JEST_WORKER_ID: _, ...parentEnv } = process.env;
+    const worker = new Worker(workerUrl, {
+      workerData: { nodeUrl, pxeConfig },
+      env: {
+        ...parentEnv,
+        ...(process.stderr.isTTY || process.env.FORCE_COLOR ? { FORCE_COLOR: '1' } : {}),
+        LOG_LEVEL: process.env.WORKER_LOG_LEVEL ?? 'warning',
+      },
+    });
+
+    const connector = new NodeConnector(worker);
+    const client = new TransportClient<WorkerMsg>(connector);
+    await client.open();
+
+    const wallet = new WorkerWallet(worker, client);
+
+    const { promise: workerDied, reject: rejectWorkerDied } = promiseWithResolvers<void>();
+    // reject if the worker exits or errors before the warmup completes.
+    const onError = (err: Error): void => {
+      worker.off('exit', onExit!);
+      rejectWorkerDied(new Error(`Worker wallet thread error: ${err.message}`));
+    };
+
+    const onExit = (code: number): void => {
+      worker.off('error', onError!);
+      rejectWorkerDied(new Error(`Worker wallet thread exited with code ${code} before becoming ready`));
+    };
+
+    worker.once('error', onError);
+    worker.once('exit', onExit);
+
+    const timeout = sleep(WORKER_READY_TIMEOUT_MS).then(() => {
+      throw new Error(`Worker wallet creation timed out after ${WORKER_READY_TIMEOUT_MS / 1000}s`);
+    });
+
+    try {
+      // wait for worker wallet to start
+      await Promise.race([wallet.getChainInfo(), workerDied, timeout]);
+    } catch (err) {
+      log.error('Worker wallet creation failed, cleaning up', { error: String(err) });
+      client.close();
+      await worker.terminate();
+      throw err;
+    } finally {
+      worker.off('error', onError);
+      worker.off('exit', onExit);
+    }
+
+    return wallet;
+  }
+
+  private async callRaw(fn: string, ...args: any[]): Promise<string> {
+    const argsJson = jsonStringify(args);
+    return (await this.client.request({ fn, args: argsJson })) as string;
+  }
+
+  private async call(fn: string, ...args: any[]): Promise<any> {
+    const resultJson = await this.callRaw(fn, ...args);
+    const methodSchema = (WorkerWalletSchema as ApiSchema)[fn];
+    return methodSchema.returnType().parseAsync(JSON.parse(resultJson));
+  }
+
+  getChainInfo(): Promise<ChainInfo> {
+    return this.call('getChainInfo');
+  }
+
+  getContractMetadata(address: AztecAddress): Promise<ContractMetadata> {
+    return this.call('getContractMetadata', address);
+  }
+
+  getContractClassMetadata(id: Fr): Promise<ContractClassMetadata> {
+    return this.call('getContractClassMetadata', id);
+  }
+
+  getPrivateEvents<T>(
+    eventMetadata: EventMetadataDefinition,
+    eventFilter: PrivateEventFilter,
+  ): Promise<PrivateEvent<T>[]> {
+    return this.call('getPrivateEvents', eventMetadata, eventFilter);
+  }
+
+  registerSender(address: AztecAddress, alias?: string): Promise<AztecAddress> {
+    return this.call('registerSender', address, alias);
+  }
+
+  getAddressBook(): Promise<Aliased<AztecAddress>[]> {
+    return this.call('getAddressBook');
+  }
+
+  getAccounts(): Promise<Aliased<AztecAddress>[]> {
+    return this.call('getAccounts');
+  }
+
+  registerContract(
+    instance: ContractInstanceWithAddress,
+    artifact?: ContractArtifact,
+    secretKey?: Fr,
+  ): Promise<ContractInstanceWithAddress> {
+    return this.call('registerContract', instance, artifact, secretKey);
+  }
+
+  simulateTx(exec: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult> {
+    return this.call('simulateTx', exec, opts);
+  }
+
+  executeUtility(call: FunctionCall, opts: ExecuteUtilityOptions): Promise<UtilityExecutionResult> {
+    return this.call('executeUtility', call, opts);
+  }
+
+  profileTx(exec: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult> {
+    return this.call('profileTx', exec, opts);
+  }
+
+  sendTx<W extends InteractionWaitOptions = undefined>(
+    exec: ExecutionPayload,
+    opts: SendOptions<W>,
+  ): Promise<SendReturn<W>> {
+    return this.call('sendTx', exec, opts);
+  }
+
+  proveTx(exec: ExecutionPayload, opts: Omit<SendOptions, 'wait'>): Promise<Tx> {
+    return this.call('proveTx', exec, opts);
+  }
+
+  /** Registers an account inside the worker's TestWallet, populating its accounts map. */
+  registerAccount(secret: Fr, salt: Fr): Promise<AztecAddress> {
+    return this.call('registerAccount', secret, salt);
+  }
+
+  createAuthWit(from: AztecAddress, messageHashOrIntent: IntentInnerHash | CallIntent): Promise<AuthWitness> {
+    return this.call('createAuthWit', from, messageHashOrIntent);
+  }
+
+  requestCapabilities(manifest: AppCapabilities): Promise<WalletCapabilities> {
+    return this.call('requestCapabilities', manifest);
+  }
+
+  batch<const T extends readonly BatchedMethod[]>(methods: T): Promise<BatchResults<T>> {
+    return this.call('batch', methods);
+  }
+
+  /** Shuts down the worker thread and closes the transport. */
+  async stop(): Promise<void> {
+    this.client.close();
+    await this.worker.terminate();
+  }
+}

package/src/test-wallet/worker_wallet_schema.ts

@@ -0,0 +1,13 @@
+import { ExecutionPayloadSchema, SendOptionsSchema, WalletSchema } from '@aztec/aztec.js/wallet';
+import { schemas } from '@aztec/foundation/schemas';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Tx } from '@aztec/stdlib/tx';
+
+import { z } from 'zod';
+
+/** Schema for the WorkerWallet API — extends WalletSchema with proveTx and registerAccount. */
+export const WorkerWalletSchema = {
+  ...WalletSchema,
+  proveTx: z.function().args(ExecutionPayloadSchema, SendOptionsSchema).returns(Tx.schema),
+  registerAccount: z.function().args(schemas.Fr, schemas.Fr).returns(AztecAddress.schema),
+};