chore: merge staging to v4-next (#22463)

Triggering this manually to get a few things in before 4.2.0 cutoff

Author: benesjan

docs/docs-operate/operators/reference/cli-reference.md

@@ -49,10 +49,7 @@ tags:
   LOCAL NETWORK
 
     --local-network
-          Starts Aztec local network
-
-    --local-network.noPXE                                                                                                                        ($NO_PXE)
-          Do not expose PXE service on local network start
+          Starts Aztec local network (also exposes the AztecNodeDebug endpoints on the node - just like if --node-debug was set)
 
     --local-network.l1Mnemonic <value>                                             (default: test test test test test test test test test test test junk)($MNEMONIC)
           Mnemonic for L1 accounts. Will be used
@@ -65,6 +62,9 @@ tags:
     --admin-port <value>                                                     (default: 8880)                                               ($AZTEC_ADMIN_PORT)
           Port to run admin APIs of Aztec Services on
 
+    --node-debug                                                             (default: false)                                              ($AZTEC_NODE_DEBUG)
+          Expose debug endpoints (e.g. mineBlock) on the main RPC port
+
     --api-prefix <value>                                                                                                                   ($API_PREFIX)
           Prefix for API routes on any service that is started
 

yarn-project/aztec-node/src/aztec-node/server.test.ts

@@ -13,7 +13,7 @@ import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import type { P2P } from '@aztec/p2p';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
-import type { GlobalVariableBuilder, SequencerClient } from '@aztec/sequencer-client';
+import type { GlobalVariableBuilder, Sequencer, SequencerClient } from '@aztec/sequencer-client';
 import type { SlasherClientInterface } from '@aztec/slasher';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { BlockHash, type BlockParameter, CheckpointedL2Block, L2Block, type L2BlockSource } from '@aztec/stdlib/block';
@@ -948,6 +948,67 @@ describe('aztec node', () => {
     });
   });
 
+  describe('mineBlock', () => {
+    const INITIAL_MIN_TXS_PER_BLOCK = 1;
+
+    let sequencerClient: MockProxy<SequencerClient>;
+    let nodeWithSequencer: AztecNodeService;
+
+    /** Simulates block number advancing from `from` to `to` after the first call. */
+    const mockBlockNumberAdvancing = (from: number, to: number) => {
+      let callCount = 0;
+      l2BlockSource.getBlockNumber.mockImplementation(() => {
+        callCount++;
+        return Promise.resolve(callCount > 1 ? BlockNumber(to) : BlockNumber(from));
+      });
+    };
+
+    beforeEach(() => {
+      const sequencer = mock<Sequencer>();
+      sequencer.getConfig.mockReturnValue({ minTxsPerBlock: INITIAL_MIN_TXS_PER_BLOCK } as any);
+
+      sequencerClient = mock<SequencerClient>();
+      sequencerClient.getSequencer.mockReturnValue(sequencer);
+      sequencerClient.trigger.mockReturnValue(Promise.resolve());
+
+      nodeWithSequencer = new AztecNodeService(
+        nodeConfig,
+        p2p,
+        l2BlockSource,
+        mock(),
+        mock(),
+        mock(),
+        worldState,
+        sequencerClient,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        12345,
+        rollupVersion.toNumber(),
+        globalVariablesBuilder,
+        epochCache,
+        getPackageVersion() ?? '',
+        new TestCircuitVerifier(),
+      );
+    });
+
+    it('throws when no sequencer is running', async () => {
+      await expect(node.mineBlock()).rejects.toThrow('Cannot mine block: no sequencer is running');
+    });
+
+    it('restores minTxsPerBlock after successful block production', async () => {
+      mockBlockNumberAdvancing(5, 6);
+
+      await nodeWithSequencer.mineBlock();
+
+      const updateCalls = sequencerClient.updateConfig.mock.calls;
+      expect(updateCalls[0][0]).toEqual({ minTxsPerBlock: 0 });
+      // Last call to update calls should revert the value to the original
+      expect(updateCalls[1][0]).toEqual({ minTxsPerBlock: INITIAL_MIN_TXS_PER_BLOCK });
+    });
+  });
+
   describe('getL2ToL1Messages', () => {
     const makeCheckpointedBlock = (slotNumber: number, l2ToL1MsgsByTx: Fr[][]): CheckpointedL2Block => {
       const block = L2Block.empty(

yarn-project/aztec-node/src/aztec-node/server.ts

@@ -14,6 +14,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { BadRequestError } from '@aztec/foundation/json-rpc';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
 import { count } from '@aztec/foundation/string';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
 import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
@@ -64,6 +65,7 @@ import {
   type AztecNodeAdmin,
   type AztecNodeAdminConfig,
   AztecNodeAdminConfigSchema,
+  type AztecNodeDebug,
   type GetContractClassLogsResponse,
   type GetPublicLogsResponse,
 } from '@aztec/stdlib/interfaces/client';
@@ -124,7 +126,7 @@ import { NodeMetrics } from './node_metrics.js';
 /**
  * The aztec node.
  */
-export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
+export class AztecNodeService implements AztecNode, AztecNodeAdmin, AztecNodeDebug, Traceable {
   private metrics: NodeMetrics;
   private initialHeaderHashPromise: Promise<BlockHash> | undefined = undefined;
 
@@ -1600,6 +1602,40 @@ export class AztecNodeService implements AztecNode, AztecNodeAdmin, Traceable {
     this.log.info('Keystore reloaded: coinbase, feeRecipient, and attester keys updated');
   }
 
+  public async mineBlock(): Promise<void> {
+    if (!this.sequencer) {
+      throw new BadRequestError('Cannot mine block: no sequencer is running');
+    }
+
+    const currentBlockNumber = await this.getBlockNumber();
+
+    // Use slot duration + 50% buffer as the timeout so this works on running networks too
+    const { slotDuration } = await this.blockSource.getL1Constants();
+    const timeoutSeconds = Math.ceil(slotDuration * 1.5);
+
+    // Temporarily set minTxsPerBlock to 0 so the sequencer produces a block even with no txs
+    const originalMinTxsPerBlock = this.sequencer.getSequencer().getConfig().minTxsPerBlock;
+    this.sequencer.updateConfig({ minTxsPerBlock: 0 });
+
+    try {
+      // Trigger the sequencer to produce a block immediately
+      void this.sequencer.trigger();
+
+      // Wait for the new L2 block to appear
+      await retryUntil(
+        async () => {
+          const newBlockNumber = await this.getBlockNumber();
+          return newBlockNumber > currentBlockNumber ? true : undefined;
+        },
+        'mineBlock',
+        timeoutSeconds,
+        0.1,
+      );
+    } finally {
+      this.sequencer.updateConfig({ minTxsPerBlock: originalMinTxsPerBlock });
+    }
+  }
+
   #getInitialHeaderHash(): Promise<BlockHash> {
     if (!this.initialHeaderHashPromise) {
       this.initialHeaderHashPromise = this.worldStateSynchronizer.getCommitted().getInitialHeader().hash();

yarn-project/aztec/src/cli/aztec_start_action.ts

@@ -7,7 +7,7 @@ import {
 } from '@aztec/foundation/json-rpc/server';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import type { ChainConfig } from '@aztec/stdlib/config';
-import { AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
+import { AztecNodeAdminApiSchema, AztecNodeApiSchema, AztecNodeDebugApiSchema } from '@aztec/stdlib/interfaces/client';
 import { getPackageVersion } from '@aztec/stdlib/update-checker';
 import { getVersioningMiddleware } from '@aztec/stdlib/versioning';
 import { getOtelJsonRpcPropagationMiddleware } from '@aztec/telemetry-client';
@@ -50,6 +50,8 @@ export async function aztecStart(options: any, userLog: LogFn, debugLogger: Logg
     // Start Node and PXE JSON-RPC server
     signalHandlers.push(stop);
     services.node = [node, AztecNodeApiSchema];
+    adminServices.node = [node, AztecNodeAdminApiSchema];
+    services.nodeDebug = [node, AztecNodeDebugApiSchema];
   } else {
     // Route --prover-node through startNode
     if (options.proverNode && !options.node) {
@@ -60,6 +62,9 @@ export async function aztecStart(options: any, userLog: LogFn, debugLogger: Logg
       const { startNode } = await import('./cmds/start_node.js');
       const networkName = getActiveNetworkName(options.network);
       ({ config } = await startNode(options, signalHandlers, services, adminServices, userLog, networkName));
+      if (options.nodeDebug && services.node) {
+        services.nodeDebug = [services.node[0], AztecNodeDebugApiSchema];
+      }
     } else if (options.bot) {
       const { startBot } = await import('./cmds/start_bot.js');
       await startBot(options, signalHandlers, services, userLog);

yarn-project/aztec/src/cli/aztec_start_options.ts

@@ -165,6 +165,13 @@ export const aztecStartOptions: { [key: string]: AztecStartOption[] } = {
       env: 'AZTEC_RESET_ADMIN_API_KEY',
       parseVal: val => val === 'true' || val === '1',
     },
+    {
+      flag: '--node-debug',
+      description: 'Expose debug endpoints (e.g. mineBlock) on the main RPC port',
+      defaultValue: false,
+      env: 'AZTEC_NODE_DEBUG',
+      parseVal: val => val === undefined || val === 'true' || val === '1',
+    },
     {
       flag: '--api-prefix <value>',
       description: 'Prefix for API routes on any service that is started',

yarn-project/aztec/src/testing/cheat_codes.ts

@@ -1,9 +1,8 @@
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { retryUntil } from '@aztec/foundation/retry';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { SequencerClient } from '@aztec/sequencer-client';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode, AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 /**
  * A class that provides utility functions for interacting with the chain.
@@ -12,6 +11,8 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/client';
  * codes, please consider whether it makes sense to just introduce new utils in your tests instead.
  */
 export class CheatCodes {
+  private logger = createLogger('aztecjs:cheat_codes');
+
   constructor(
     /** Cheat codes for L1.*/
     public eth: EthCheatCodes,
@@ -30,50 +31,55 @@ export class CheatCodes {
 
   /**
    * Warps the L1 timestamp to a target timestamp and mines an L2 block that advances the L2 timestamp to at least
-   * the target timestamp. L2 timestamp is not advanced exactly to the target timestamp because it is determined
-   * by the slot number, which advances in fixed intervals.
-   * This is useful for testing time-dependent contract behavior.
-   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
-   * @param node - The Aztec node used to query if a new block has been mined.
+   * the target timestamp. If the target timestamp falls within the current L2 slot (which already has a block),
+   * the timestamp is automatically adjusted forward to the start of the next slot so that `mineBlock()` succeeds.
+   * @param node - The Aztec node used to force an empty block to be mined.
    * @param targetTimestamp - The target timestamp to warp to (in seconds)
    */
-  async warpL2TimeAtLeastTo(sequencerClient: SequencerClient, node: AztecNode, targetTimestamp: bigint | number) {
-    const currentL2BlockNumber: BlockNumber = await node.getBlockNumber();
+  async warpL2TimeAtLeastTo(node: AztecNodeDebug, targetTimestamp: bigint | number) {
+    const targetBigInt = BigInt(targetTimestamp);
+    const currentTimestamp = BigInt(await this.eth.lastBlockTimestamp());
 
-    // We warp the L1 timestamp
-    await this.eth.warp(targetTimestamp, { resetBlockInterval: true });
+    if (targetBigInt <= currentTimestamp) {
+      throw new Error(
+        `warpL2TimeAtLeastTo: target timestamp ${targetBigInt} is not in the future (current L1 timestamp is ${currentTimestamp}).`,
+      );
+    }
 
-    // Wait until an L2 block is mined
-    const sequencer = sequencerClient.getSequencer();
-    const minTxsPerBlock = sequencer.getConfig().minTxsPerBlock;
-    sequencer.updateConfig({ minTxsPerBlock: 0 });
+    const currentSlot = await this.rollup.getSlot();
+    const targetSlot = await this.rollup.getSlotAt(targetBigInt);
 
-    await retryUntil(
-      async () => {
-        const newL2BlockNumber: BlockNumber = await node.getBlockNumber();
-        return newL2BlockNumber > currentL2BlockNumber;
-      },
-      'new block after warping L2 time',
-      36,
-      1,
-    );
+    let effectiveTimestamp = targetBigInt;
 
-    // Restore original minTxsPerBlock
-    sequencer.updateConfig({ minTxsPerBlock });
+    if (targetSlot <= currentSlot) {
+      // Target lands in the same (or earlier) slot — auto-adjust to the next slot's start.
+      const nextSlot = SlotNumber(currentSlot + 1);
+      const nextSlotTimestamp = await this.rollup.getTimestampForSlot(nextSlot);
+      this.logger.warn(
+        `warpL2TimeAtLeastTo: target timestamp ${targetBigInt} falls in current slot ${currentSlot}. ` +
+          `Auto-adjusting to start of slot ${nextSlot} at timestamp ${nextSlotTimestamp}.`,
+      );
+      effectiveTimestamp = nextSlotTimestamp;
+    }
+
+    await this.eth.warp(effectiveTimestamp, { resetBlockInterval: true });
+    await node.mineBlock();
   }
 
   /**
    * Warps the L1 timestamp forward by a specified duration and mines an L2 block that advances the L2 timestamp at
-   * least by the duration. L2 timestamp is not advanced exactly by the duration because it is determined by the slot
-   * number, which advances in fixed intervals.
-   * This is useful for testing time-dependent contract behavior.
-   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
-   * @param node - The Aztec node used to query if a new block has been mined.
+   * least by the duration. If the duration is too short to cross an L2 slot boundary, the warp is automatically
+   * extended to the start of the next slot so that `mineBlock()` succeeds.
+   * @param node - The Aztec node used to force an empty block to be mined.
    * @param duration - The duration to advance time by (in seconds)
    */
-  async warpL2TimeAtLeastBy(sequencerClient: SequencerClient, node: AztecNode, duration: bigint | number) {
+  async warpL2TimeAtLeastBy(node: AztecNodeDebug, duration: bigint | number) {
+    if (BigInt(duration) <= 0n) {
+      throw new Error(`warpL2TimeAtLeastBy: duration must be positive, got ${duration} seconds.`);
+    }
+
     const currentTimestamp = await this.eth.lastBlockTimestamp();
     const targetTimestamp = BigInt(currentTimestamp) + BigInt(duration);
-    await this.warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp);
+    await this.warpL2TimeAtLeastTo(node, targetTimestamp);
   }
 }