@aztec/end-to-end 0.0.1-commit.5914bae → 0.0.1-commit.59a0419c6

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

@@ -40,6 +40,7 @@ import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 import { BaseWallet, type SimulateViaEntrypointOptions } from '@aztec/wallet-sdk/base-wallet';
 import type { AccountType } from '@aztec/wallets/embedded';
 
+import { DEFAULT_MIN_FEE_PADDING } from '../fixtures/fixtures.js';
 import { AztecNodeProxy, ProvenTx } from './utils.js';
 
 /**
@@ -63,6 +64,7 @@ export class TestWallet extends BaseWallet {
     private readonly nodeRef: AztecNodeProxy,
   ) {
     super(pxe, nodeRef);
+    this.minFeePadding = DEFAULT_MIN_FEE_PADDING;
   }
 
   static async create(
@@ -178,7 +180,7 @@ export class TestWallet extends BaseWallet {
   }
 
   setMinFeePadding(value?: number) {
-    this.minFeePadding = value ?? 0.5;
+    this.minFeePadding = value ?? DEFAULT_MIN_FEE_PADDING;
   }
 
   protected getAccountFromAddress(address: AztecAddress): Promise<Account> {
@@ -258,7 +260,7 @@ export class TestWallet extends BaseWallet {
     executionPayload: ExecutionPayload,
     opts: SimulateViaEntrypointOptions,
   ): Promise<TxSimulationResultWithAppOffset> {
-    const { from, feeOptions, additionalScopes, skipTxValidation, skipFeeEnforcement } = opts;
+    const { from, feeOptions, additionalScopes, skipTxValidation, skipFeeEnforcement, sendMessagesAs } = opts;
     const scopes = this.scopesFrom(from, additionalScopes);
     const skipKernels = this.simulationMode !== 'full';
     const useOverride = this.simulationMode === 'kernelless-override';
@@ -308,6 +310,7 @@ export class TestWallet extends BaseWallet {
       skipTxValidation,
       overrides,
       scopes,
+      senderForTags: this.senderForTagsFrom(from, sendMessagesAs),
     });
     const appCallOffset = await this.computeAppCallOffset(from, feeOptions);
     return TxSimulationResultWithAppOffset.fromResultAndOffset(result, appCallOffset);
@@ -320,7 +323,10 @@ export class TestWallet extends BaseWallet {
       gasSettings: 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));
+    const txProvingResult = await this.pxe.proveTx(txRequest, {
+      scopes: this.scopesFrom(opts.from, opts.additionalScopes),
+      senderForTags: this.senderForTagsFrom(opts.from, opts.sendMessagesAs),
+    });
     return new ProvenTx(
       this.aztecNode,
       await txProvingResult.toTx(),