@aztec/stdlib 4.0.0-nightly.20260116 → 4.0.0-nightly.20260117

package/src/interfaces/validator.ts

@@ -1,3 +1,4 @@
+import type { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import type { SecretValue } from '@aztec/foundation/config';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
@@ -14,6 +15,7 @@ import type {
 } from '@aztec/stdlib/p2p';
 import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
+import { type ValidatorHASignerConfig, ValidatorHASignerConfigSchema } from '@aztec/validator-ha-signer/config';
 
 import type { PeerId } from '@libp2p/interface';
 import { z } from 'zod';
@@ -24,7 +26,7 @@ import { AllowedElementSchema } from './allowed_element.js';
 /**
  * Validator client configuration
  */
-export interface ValidatorClientConfig {
+export type ValidatorClientConfig = ValidatorHASignerConfig & {
   /** The private keys of the validators participating in attestation duties */
   validatorPrivateKeys?: SecretValue<`0x${string}`[]>;
 
@@ -56,7 +58,7 @@ export interface ValidatorClientConfig {
   // TODO(palla/mbps): Change default to false once block sync is stable
   /** Skip pushing re-executed blocks to archiver (default: true) */
   skipPushProposedBlocksToArchiver?: boolean;
-}
+};
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
   Pick<SequencerConfig, 'txPublicSetupAllowList' | 'broadcastInvalidBlockProposal'> &
@@ -69,7 +71,7 @@ export type ValidatorClientFullConfig = ValidatorClientConfig &
   };
 
 export const ValidatorClientConfigSchema = zodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>()(
-  z.object({
+  ValidatorHASignerConfigSchema.extend({
     validatorAddresses: z.array(schemas.EthAddress).optional(),
     disableValidator: z.boolean(),
     disabledValidators: z.array(schemas.EthAddress),
@@ -144,5 +146,7 @@ export interface Validator {
   signAttestationsAndSigners(
     attestationsAndSigners: CommitteeAttestationsAndSigners,
     proposer: EthAddress,
+    slot: SlotNumber,
+    blockNumber: BlockNumber | CheckpointNumber,
   ): Promise<Signature>;
 }

package/src/p2p/block_proposal.ts

@@ -6,6 +6,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
 
 import type { L2Block } from '../block/l2_block.js';
 import type { L2BlockInfo } from '../block/l2_block_info.js';
@@ -125,7 +126,7 @@ export class BlockProposal extends Gossipable {
     archiveRoot: Fr,
     txHashes: TxHash[],
     txs: Tx[] | undefined,
-    payloadSigner: (payload: Buffer32) => Promise<Signature>,
+    payloadSigner: (payload: Buffer32, context: SigningContext) => Promise<Signature>,
   ): Promise<BlockProposal> {
     // Create a temporary proposal to get the payload to sign
     const tempProposal = new BlockProposal(
@@ -137,13 +138,23 @@ export class BlockProposal extends Gossipable {
       Signature.empty(),
     );
 
+    // Create the block signing context
+    const blockContext: SigningContext = {
+      slot: blockHeader.globalVariables.slotNumber,
+      blockNumber: blockHeader.globalVariables.blockNumber,
+      blockIndexWithinCheckpoint: indexWithinCheckpoint,
+      dutyType: DutyType.BLOCK_PROPOSAL,
+    };
+
     const hashed = getHashedSignaturePayload(tempProposal, SignatureDomainSeparator.blockProposal);
-    const sig = await payloadSigner(hashed);
+    const sig = await payloadSigner(hashed, blockContext);
 
     // If txs are provided, sign them as well
     let signedTxs: SignedTxs | undefined;
     if (txs) {
-      signedTxs = await SignedTxs.createFromSigner(txs, payloadSigner);
+      const txsSigningContext: SigningContext = { dutyType: DutyType.TXS };
+      const txsSigner = (payload: Buffer32) => payloadSigner(payload, txsSigningContext);
+      signedTxs = await SignedTxs.createFromSigner(txs, txsSigner);
     }
 
     return new BlockProposal(blockHeader, indexWithinCheckpoint, inHash, archiveRoot, txHashes, sig, signedTxs);

package/src/p2p/checkpoint_proposal.ts

@@ -6,6 +6,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
 
 import type { L2BlockInfo } from '../block/l2_block_info.js';
 import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
@@ -152,13 +153,18 @@ export class CheckpointProposal extends Gossipable {
     checkpointHeader: CheckpointHeader,
     archiveRoot: Fr,
     lastBlockInfo: CheckpointLastBlockData | undefined,
-    payloadSigner: (payload: Buffer32) => Promise<Signature>,
+    payloadSigner: (payload: Buffer32, context: SigningContext) => Promise<Signature>,
   ): Promise<CheckpointProposal> {
-    // Sign the checkpoint payload
+    // Sign the checkpoint payload with CHECKPOINT_PROPOSAL duty type
     const tempProposal = new CheckpointProposal(checkpointHeader, archiveRoot, Signature.empty(), undefined);
-
     const checkpointHash = getHashedSignaturePayload(tempProposal, SignatureDomainSeparator.checkpointProposal);
-    const checkpointSignature = await payloadSigner(checkpointHash);
+
+    const checkpointContext: SigningContext = {
+      slot: checkpointHeader.slotNumber,
+      blockNumber: lastBlockInfo?.blockHeader?.globalVariables.blockNumber ?? BlockNumber(0),
+      dutyType: DutyType.CHECKPOINT_PROPOSAL,
+    };
+    const checkpointSignature = await payloadSigner(checkpointHash, checkpointContext);
 
     if (!lastBlockInfo) {
       return new CheckpointProposal(checkpointHeader, archiveRoot, checkpointSignature);

package/src/tests/mocks.ts

@@ -400,6 +400,7 @@ export async function mockCheckpointAndMessages(
   {
     startBlockNumber = BlockNumber(1),
     numBlocks = 1,
+    blocks,
     numTxsPerBlock = 1,
     numL1ToL2Messages = 1,
     makeBlockOptions = () => ({}),
@@ -412,6 +413,7 @@ export async function mockCheckpointAndMessages(
     numL1ToL2Messages?: number;
     makeBlockOptions?: (blockNumber: BlockNumber) => Partial<Parameters<typeof L2BlockNew.random>[1]>;
     previousArchive?: AppendOnlyTreeSnapshot;
+    blocks?: L2BlockNew[];
   } & Partial<Parameters<typeof Checkpoint.random>[1]> &
     Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
 ) {
@@ -420,18 +422,20 @@ export async function mockCheckpointAndMessages(
   // Track the previous block's archive to ensure consecutive blocks have consistent archive roots.
   // The current block's header.lastArchive must equal the previous block's archive.
   let lastArchive: AppendOnlyTreeSnapshot | undefined = previousArchive;
-  for (let i = 0; i < numBlocks; i++) {
+  for (let i = 0; i < (blocks?.length ?? numBlocks); i++) {
     const blockNumber = BlockNumber(startBlockNumber + i);
     const { block, messages } = {
-      block: await L2BlockNew.random(blockNumber, {
-        checkpointNumber,
-        indexWithinCheckpoint: i,
-        txsPerBlock: numTxsPerBlock,
-        slotNumber,
-        ...options,
-        ...makeBlockOptions(blockNumber),
-        ...(lastArchive ? { lastArchive } : {}),
-      }),
+      block:
+        blocks?.[i] ??
+        (await L2BlockNew.random(blockNumber, {
+          checkpointNumber,
+          indexWithinCheckpoint: i,
+          txsPerBlock: numTxsPerBlock,
+          slotNumber,
+          ...options,
+          ...makeBlockOptions(blockNumber),
+          ...(lastArchive ? { lastArchive } : {}),
+        })),
       messages: mockL1ToL2Messages(numL1ToL2Messages),
     };
     // Update lastArchive for the next block
@@ -565,7 +569,7 @@ export const makeBlockProposal = (options?: MakeBlockProposalOptions): Promise<B
     archiveRoot,
     txHashes,
     txs,
-    payload => Promise.resolve(signer.signMessage(payload)),
+    (_payload, _context) => Promise.resolve(signer.signMessage(_payload)),
   );
 };
 

package/src/tx/block_header.ts

@@ -168,6 +168,11 @@ export class BlockHeader {
     return this._cachedHash;
   }
 
+  /** Manually set the hash for this block header if already computed */
+  setHash(hashed: Fr) {
+    this._cachedHash = Promise.resolve(hashed);
+  }
+
   static random(overrides: Partial<FieldsOf<BlockHeader>> & Partial<FieldsOf<GlobalVariables>> = {}): BlockHeader {
     return BlockHeader.from({
       lastArchive: AppendOnlyTreeSnapshot.random(),

package/src/tx/private_execution_result.ts

@@ -79,7 +79,7 @@ export class CountedContractClassLog implements IsEmpty {
 export class PrivateExecutionResult {
   constructor(
     public entrypoint: PrivateCallExecutionResult,
-    /** The first non revertible nullifier, or zero if there was none. */
+    /** The first non-revertible nullifier emitted by any private call, or the protocol nullifier if there was none. */
     public firstNullifier: Fr,
     /** An array of calldata for the enqueued public function calls and the teardown function call. */
     public publicFunctionCalldata: HashedValues[],

package/src/tx/profiling.ts

@@ -6,9 +6,35 @@ import { z } from 'zod';
 import type { AztecNode } from '../interfaces/aztec-node.js';
 import { type PrivateExecutionStep, PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
 
-export type NodeStats = Partial<Record<keyof AztecNode, { times: number[] }>>;
+export type RoundTripStats = {
+  /** Number of round trips (times we blocked waiting for node responses) */
+  roundTrips: number;
+  /** Total wall-clock time spent waiting on node (excludes parallel overlap) */
+  totalBlockingTime: number;
+  /** Individual round trip durations */
+  roundTripDurations: number[];
+  /** Methods called in each round trip (parallel calls grouped together) */
+  roundTripMethods: string[][];
+};
+
+const RoundTripStatsSchema = z.object({
+  roundTrips: z.number(),
+  totalBlockingTime: z.number(),
+  roundTripDurations: z.array(z.number()),
+  roundTripMethods: z.array(z.array(z.string())),
+});
+
+export type NodeStats = {
+  /** Per-method call stats */
+  perMethod: Partial<Record<keyof AztecNode, { times: number[] }>>;
+  /** Round trip stats tracking actual blocking waits */
+  roundTrips: RoundTripStats;
+};
 
-const NodeStatsSchema = z.record(z.string(), z.object({ times: z.array(z.number()) }));
+const NodeStatsSchema = z.object({
+  perMethod: z.record(z.string(), z.object({ times: z.array(z.number()) })),
+  roundTrips: RoundTripStatsSchema,
+});
 
 type FunctionTiming = {
   functionName: string;
@@ -105,7 +131,15 @@ export class TxProfileResult {
         },
       ],
       {
-        nodeRPCCalls: { getBlockHeader: { times: [1] } },
+        nodeRPCCalls: {
+          perMethod: { getBlockHeader: { times: [1] } },
+          roundTrips: {
+            roundTrips: 1,
+            totalBlockingTime: 1,
+            roundTripDurations: [1],
+            roundTripMethods: [['getBlockHeader']],
+          },
+        },
         timings: {
           sync: 1,
           proving: 1,
@@ -140,7 +174,15 @@ export class UtilitySimulationResult {
 
   static random(): UtilitySimulationResult {
     return new UtilitySimulationResult([Fr.random()], {
-      nodeRPCCalls: { getBlockHeader: { times: [1] } },
+      nodeRPCCalls: {
+        perMethod: { getBlockHeader: { times: [1] } },
+        roundTrips: {
+          roundTrips: 1,
+          totalBlockingTime: 1,
+          roundTripDurations: [1],
+          roundTripMethods: [['getBlockHeader']],
+        },
+      },
       timings: {
         sync: 1,
         publicSimulation: 1,

package/src/zkpassport/index.ts

@@ -5,14 +5,13 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { withoutHexPrefix } from '@aztec/foundation/string';
 
 export type ViemZkPassportProofParams = {
+  version: `0x${string}`;
   proofVerificationData: {
     vkeyHash: `0x${string}`;
     proof: `0x${string}`;
     publicInputs: `0x${string}`[];
   };
-  commitments: {
-    committedInputs: `0x${string}`;
-  };
+  committedInputs: `0x${string}`;
   serviceConfig: {
     validityPeriodInSeconds: bigint;
     domain: string;
@@ -91,7 +90,7 @@ export class ZkPassportProofParams {
       Buffer32.fromString(params.proofVerificationData.vkeyHash),
       Buffer.from(withoutHexPrefix(params.proofVerificationData.proof), 'hex'),
       params.proofVerificationData.publicInputs.map(input => Fr.fromString(input)),
-      Buffer.from(withoutHexPrefix(params.commitments.committedInputs), 'hex'),
+      Buffer.from(withoutHexPrefix(params.committedInputs), 'hex'),
       params.serviceConfig.validityPeriodInSeconds,
       params.serviceConfig.domain,
       params.serviceConfig.scope,
@@ -99,20 +98,20 @@ export class ZkPassportProofParams {
   }
 
   toViem(): ViemZkPassportProofParams {
+    // Version is set to bytes32(0) as per zkpassport library convention
     return {
-      serviceConfig: {
-        devMode: this.devMode,
-        validityPeriodInSeconds: this.validityPeriodInSeconds,
-        domain: this.domain,
-        scope: this.scope,
-      },
+      version: '0x0000000000000000000000000000000000000000000000000000000000000000',
       proofVerificationData: {
         vkeyHash: this.vkeyHash.toString(),
         proof: `0x${this.proof.toString('hex')}`,
         publicInputs: this.publicInputs.map(input => input.toString()),
       },
-      commitments: {
-        committedInputs: `0x${this.committedInputs.toString('hex')}`,
+      committedInputs: `0x${this.committedInputs.toString('hex')}`,
+      serviceConfig: {
+        devMode: this.devMode,
+        validityPeriodInSeconds: this.validityPeriodInSeconds,
+        domain: this.domain,
+        scope: this.scope,
       },
     };
   }