@aztec/stdlib 6.0.0-nightly.20260812 → 6.0.0-nightly.20260821

package/src/interfaces/archiver.ts

@@ -25,6 +25,7 @@ import {
 import { L1RollupConstantsSchema } from '../epoch-helpers/index.js';
 import { LogResultSchema } from '../logs/log_result.js';
 import { PrivateLogsQuerySchema, PublicLogsQuerySchema } from '../logs/logs_query.js';
+import { InboxBucketSchema } from '../messaging/inbox_bucket.js';
 import type { L1ToL2MessageSource } from '../messaging/l1_to_l2_message_source.js';
 import { L2ToL1MembershipWitnessSchema } from '../messaging/l2_to_l1_membership.js';
 import { optional, schemas } from '../schemas/schemas.js';
@@ -72,7 +73,7 @@ export type ArchiverSpecificConfig = {
   /**
    * Preload the standard contracts (AuthRegistry, PublicChecks, HandshakeRegistry) into the contract store at block 0.
    * For test environments only: it must only be set when genesis also seeds the matching registration/deployment
-   * nullifiers, otherwise a later on-chain publish of a preloaded class would collide with the block-0 preload.
+   * nullifiers, otherwise a later onchain publish of a preloaded class would collide with the block-0 preload.
    */
   testPreloadStandardContracts?: boolean;
 };
@@ -135,8 +136,24 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   }),
   getContractClassIds: z.function({ input: z.tuple([]), output: z.array(schemas.Fr) }),
   registerContractFunctionSignatures: z.function({ input: z.tuple([z.array(z.string())]), output: z.void() }),
-  getL1ToL2Messages: z.function({ input: z.tuple([CheckpointNumberSchema]), output: z.array(schemas.Fr) }),
   getL1ToL2MessageIndex: z.function({ input: z.tuple([schemas.Fr]), output: schemas.BigInt.optional() }),
+  getLatestInboxBucketAtOrBefore: z.function({
+    input: z.tuple([schemas.BigInt]),
+    output: InboxBucketSchema.optional(),
+  }),
+  getInboxBucket: z.function({ input: z.tuple([schemas.BigInt]), output: InboxBucketSchema.optional() }),
+  getInboxBucketByTotalMsgCount: z.function({
+    input: z.tuple([schemas.BigInt]),
+    output: InboxBucketSchema.optional(),
+  }),
+  getL1ToL2MessagesBetweenBuckets: z.function({
+    input: z.tuple([schemas.BigInt, schemas.BigInt]),
+    output: z.array(schemas.Fr),
+  }),
+  getL1ToL2MessagesBetweenLeafCounts: z.function({
+    input: z.tuple([schemas.BigInt, schemas.BigInt]),
+    output: z.array(schemas.Fr),
+  }),
   getDebugFunctionName: z.function({
     input: z.tuple([schemas.AztecAddress, schemas.FunctionSelector]),
     output: optional(z.string()),

package/src/interfaces/aztec-node.ts

@@ -15,7 +15,12 @@ import {
 } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+import {
+  type JsonRpcFetch,
+  type JsonRpcFetchConfig,
+  createSafeJsonRpcClient,
+  makeFetch,
+} from '@aztec/foundation/json-rpc/client';
 import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
 
 import { z } from 'zod';
@@ -200,8 +205,12 @@ export interface AztecNode {
     l1ToL2Message: Fr,
   ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>] | undefined>;
 
-  /** Returns the L2 checkpoint number in which this L1 to L2 message becomes available, or undefined if not found. */
-  getL1ToL2MessageCheckpoint(l1ToL2Message: Fr): Promise<CheckpointNumber | undefined>;
+  /**
+   * Returns the compact leaf index assigned to this L1 to L2 message as soon as the node has ingested it from L1,
+   * before any L2 block consumes it. Returns undefined if the node has not yet seen the message. The message becomes
+   * consumable once a block's L1-to-L2 message tree grows past this index.
+   */
+  getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined>;
 
   /**
    * Returns all the L2 to L1 messages in an epoch.
@@ -609,7 +618,7 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
     output: z.tuple([schemas.BigInt, SiblingPath.schemaFor(L1_TO_L2_MSG_TREE_HEIGHT)]).optional(),
   }),
 
-  getL1ToL2MessageCheckpoint: z.function({ input: z.tuple([schemas.Fr]), output: CheckpointNumberSchema.optional() }),
+  getL1ToL2MessageIndex: z.function({ input: z.tuple([schemas.Fr]), output: schemas.BigInt.optional() }),
 
   getL2ToL1Messages: z.function({
     input: z.tuple([EpochNumberSchema]),
@@ -790,16 +799,28 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
   }),
 };
 
-export function createAztecNodeClient(
-  url: string,
-  versions: Partial<ComponentsVersions> = {},
-  fetch = makeFetch([1, 2, 3], false),
-  batchWindowMS = 0,
-): AztecNode {
+/** Options for an Aztec node JSON-RPC client. */
+export type AztecNodeClientOptions = {
+  /** Expected component versions checked against response headers. */
+  versions?: Partial<ComponentsVersions>;
+  /** Custom JSON-RPC transport. Takes precedence over fetchOptions. */
+  fetch?: JsonRpcFetch;
+  /** Configuration for the default retrying fetch transport. */
+  fetchOptions?: JsonRpcFetchConfig;
+  /** Time in milliseconds to collect calls into a JSON-RPC batch. */
+  batchWindowMS?: number;
+  /** Maximum number of calls sent in one JSON-RPC batch. */
+  maxBatchSize?: number;
+};
+
+export function createAztecNodeClient(url: string, options: AztecNodeClientOptions = {}): AztecNode {
+  const fetch = options.fetch ?? makeFetch([1, 2, 3], false, undefined, options.fetchOptions);
+
   return createSafeJsonRpcClient<AztecNode>(url, AztecNodeApiSchema, {
     namespaceMethods: 'aztec',
     fetch,
-    batchWindowMS,
-    onResponse: getVersioningResponseHandler(versions),
+    batchWindowMS: options.batchWindowMS ?? 0,
+    maxBatchSize: options.maxBatchSize,
+    onResponse: getVersioningResponseHandler(options.versions ?? {}),
   });
 }

package/src/interfaces/block-builder.ts

@@ -56,6 +56,11 @@ export type PublicProcessorLimits = {
 type BlockBuilderOptionsBase = PublicProcessorLimits & {
   /** Minimum number of successfully processed txs required. Block is rejected if fewer succeed. */
   minValidTxs: number;
+  /**
+   * L1-to-L2 message leaves this block consumes, inserted into the fork's L1-to-L2 message tree before the block
+   * header is built. Omitted when the block consumes nothing from the Inbox.
+   */
+  l1ToL2Messages?: Fr[];
 };
 
 /** Proposer mode: redistribution params are required. */
@@ -150,12 +155,16 @@ export interface ICheckpointsBuilder {
    */
   getFork(blockNumber: BlockNumber, blockHash?: BlockHash): Promise<MerkleTreeWriteOperations>;
 
+  /**
+   * Opens a fresh checkpoint. The checkpoint's L1-to-L2 messages are not passed here: each block carries its own
+   * bundle in `buildBlock`'s `l1ToL2Messages`.
+   */
   startCheckpoint(
     checkpointNumber: CheckpointNumber,
     constants: CheckpointGlobalVariables,
     feeAssetPriceModifier: bigint,
-    l1ToL2Messages: Fr[],
     previousCheckpointOutHashes: Fr[],
+    previousInboxRollingHash: Fr,
     fork: MerkleTreeWriteOperations,
     bindings?: LoggerBindings,
   ): Promise<ICheckpointBlockBuilder>;

package/src/interfaces/configs.ts

@@ -133,6 +133,11 @@ export interface SequencerConfig {
   skipBroadcastCheckpointProposal?: boolean;
   /** List of slots for which the sequencer will not produce a proposal (for testing only). Attestation paths are unaffected. */
   pauseProposingForSlots?: SlotNumber[];
+  /**
+   * Minimum number of connected p2p peers required to build and propose a checkpoint. Zero disables the
+   * check. Ignored when p2p is disabled by config.
+   */
+  minPeersToPropose?: number;
 }
 
 export const SequencerConfigSchema = zodFor<SequencerConfig>()(
@@ -186,6 +191,7 @@ export const SequencerConfigSchema = zodFor<SequencerConfig>()(
     skipBroadcastProposals: z.boolean().optional(),
     skipBroadcastCheckpointProposal: z.boolean().optional(),
     pauseProposingForSlots: z.array(SlotNumberSchema).optional(),
+    minPeersToPropose: z.number().nonnegative().optional(),
   }),
 );
 

package/src/interfaces/p2p.ts

@@ -29,6 +29,19 @@ export const PeerInfoSchema = z.discriminatedUnion('status', [
   }),
 ]);
 
+/** Connectivity of the p2p stack: whether it is enabled at all, and how many peers are currently connected. */
+export type P2PConnectivity = {
+  /** False when the node runs without a p2p stack (eg sandbox or single-node setups). */
+  enabled: boolean;
+  /** Number of peers currently connected. Always zero when p2p is disabled. */
+  connectedPeers: number;
+};
+
+export const P2PConnectivitySchema = z.object({
+  enabled: z.boolean(),
+  connectedPeers: z.number(),
+});
+
 /** Exposed API to the P2P module. */
 export interface P2PApi {
   /**
@@ -54,6 +67,13 @@ export interface P2PApi {
    */
   getPeers(includePending?: boolean): Promise<PeerInfo[]>;
 
+  /**
+   * Returns whether the p2p stack is enabled on this node, and the number of peers it is connected to.
+   * Nodes running without p2p report `enabled: false`, so consumers can tell a disabled stack apart from a
+   * stack that is enabled but has no peers.
+   */
+  getP2PConnectivity(): Promise<P2PConnectivity>;
+
   /**
    * Queries the Attestation pool for checkpoint attestations for the given slot.
    *
@@ -116,4 +136,5 @@ export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
   getPendingTxCount: z.function({ input: z.tuple([]), output: schemas.Integer }),
   getEncodedEnr: z.function({ input: z.tuple([]), output: z.string().optional() }),
   getPeers: z.function({ input: z.tuple([optional(z.boolean())]), output: z.array(PeerInfoSchema) }),
+  getP2PConnectivity: z.function({ input: z.tuple([]), output: P2PConnectivitySchema }),
 };

package/src/interfaces/proving-job.ts

@@ -11,18 +11,15 @@ import { z } from 'zod';
 
 import { AvmCircuitInputs } from '../avm/avm.js';
 import { AvmProvingRequestSchema } from '../avm/avm_proving_request.js';
-import { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
+import { InboxParityPrivateInputs } from '../parity/inbox_parity_private_inputs.js';
 import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
-import { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
 import { ProvingRequestType } from '../proofs/proving_request_type.js';
 import { RecursiveProof } from '../proofs/recursive_proof.js';
 import { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
 import { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js';
 import {
-  BlockRootEmptyTxFirstRollupPrivateInputs,
-  BlockRootFirstRollupPrivateInputs,
+  BlockRootNoTxsRollupPrivateInputs,
   BlockRootRollupPrivateInputs,
-  BlockRootSingleTxFirstRollupPrivateInputs,
   BlockRootSingleTxRollupPrivateInputs,
 } from '../rollup/block_root_rollup_private_inputs.js';
 import { CheckpointMergeRollupPrivateInputs } from '../rollup/checkpoint_merge_rollup_private_inputs.js';
@@ -81,8 +78,7 @@ export function makePublicInputsAndRecursiveProof<T, N extends number = typeof N
 
 export const ProvingJobInputs = z.discriminatedUnion('type', [
   AvmProvingRequestSchema,
-  z.object({ type: z.literal(ProvingRequestType.PARITY_BASE), inputs: ParityBasePrivateInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.PARITY_ROOT), inputs: ParityRootPrivateInputs.schema }),
+  z.object({ type: z.literal(ProvingRequestType.INBOX_PARITY), inputs: InboxParityPrivateInputs.schema }),
   z.object({
     type: z.literal(ProvingRequestType.PUBLIC_CHONK_VERIFIER),
     inputs: PublicChonkVerifierPrivateInputs.schema,
@@ -96,23 +92,15 @@ export const ProvingJobInputs = z.discriminatedUnion('type', [
     inputs: PublicTxBaseRollupPrivateInputs.schema,
   }),
   z.object({ type: z.literal(ProvingRequestType.TX_MERGE_ROLLUP), inputs: TxMergeRollupPrivateInputs.schema }),
-  z.object({
-    type: z.literal(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP),
-    inputs: BlockRootFirstRollupPrivateInputs.schema,
-  }),
-  z.object({
-    type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP),
-    inputs: BlockRootSingleTxFirstRollupPrivateInputs.schema,
-  }),
-  z.object({
-    type: z.literal(ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP),
-    inputs: BlockRootEmptyTxFirstRollupPrivateInputs.schema,
-  }),
   z.object({ type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP), inputs: BlockRootRollupPrivateInputs.schema }),
   z.object({
     type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP),
     inputs: BlockRootSingleTxRollupPrivateInputs.schema,
   }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_NO_TXS_ROLLUP),
+    inputs: BlockRootNoTxsRollupPrivateInputs.schema,
+  }),
   z.object({ type: z.literal(ProvingRequestType.BLOCK_MERGE_ROLLUP), inputs: BlockMergeRollupPrivateInputs.schema }),
   z.object({
     type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP),
@@ -145,16 +133,12 @@ export function getProvingJobInputClassFor(type: ProvingRequestType) {
       return PublicTxBaseRollupPrivateInputs;
     case ProvingRequestType.TX_MERGE_ROLLUP:
       return TxMergeRollupPrivateInputs;
-    case ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP:
-      return BlockRootFirstRollupPrivateInputs;
-    case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP:
-      return BlockRootSingleTxFirstRollupPrivateInputs;
-    case ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP:
-      return BlockRootEmptyTxFirstRollupPrivateInputs;
     case ProvingRequestType.BLOCK_ROOT_ROLLUP:
       return BlockRootRollupPrivateInputs;
     case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP:
       return BlockRootSingleTxRollupPrivateInputs;
+    case ProvingRequestType.BLOCK_ROOT_NO_TXS_ROLLUP:
+      return BlockRootNoTxsRollupPrivateInputs;
     case ProvingRequestType.BLOCK_MERGE_ROLLUP:
       return BlockMergeRollupPrivateInputs;
     case ProvingRequestType.CHECKPOINT_ROOT_ROLLUP:
@@ -167,10 +151,8 @@ export function getProvingJobInputClassFor(type: ProvingRequestType) {
       return CheckpointMergeRollupPrivateInputs;
     case ProvingRequestType.ROOT_ROLLUP:
       return RootRollupPrivateInputs;
-    case ProvingRequestType.PARITY_BASE:
-      return ParityBasePrivateInputs;
-    case ProvingRequestType.PARITY_ROOT:
-      return ParityRootPrivateInputs;
+    case ProvingRequestType.INBOX_PARITY:
+      return InboxParityPrivateInputs;
     default: {
       const _exhaustive: never = type;
       throw new Error(`Cannot find circuit inputs class for proving type ${type}`);
@@ -186,19 +168,16 @@ export type ProvingJobInputsMap = {
   [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PrivateTxBaseRollupPrivateInputs;
   [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: PublicTxBaseRollupPrivateInputs;
   [ProvingRequestType.TX_MERGE_ROLLUP]: TxMergeRollupPrivateInputs;
-  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: BlockRootFirstRollupPrivateInputs;
-  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: BlockRootSingleTxFirstRollupPrivateInputs;
-  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: BlockRootEmptyTxFirstRollupPrivateInputs;
   [ProvingRequestType.BLOCK_ROOT_ROLLUP]: BlockRootRollupPrivateInputs;
   [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: BlockRootSingleTxRollupPrivateInputs;
+  [ProvingRequestType.BLOCK_ROOT_NO_TXS_ROLLUP]: BlockRootNoTxsRollupPrivateInputs;
   [ProvingRequestType.BLOCK_MERGE_ROLLUP]: BlockMergeRollupPrivateInputs;
   [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: CheckpointRootRollupPrivateInputs;
   [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: CheckpointRootSingleBlockRollupPrivateInputs;
   [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: CheckpointPaddingRollupPrivateInputs;
   [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: CheckpointMergeRollupPrivateInputs;
   [ProvingRequestType.ROOT_ROLLUP]: RootRollupPrivateInputs;
-  [ProvingRequestType.PARITY_BASE]: ParityBasePrivateInputs;
-  [ProvingRequestType.PARITY_ROOT]: ParityRootPrivateInputs;
+  [ProvingRequestType.INBOX_PARITY]: InboxParityPrivateInputs;
 };
 
 export const ProvingJobResult = z.discriminatedUnion('type', [
@@ -235,35 +214,21 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
     ),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP),
-    result: schemaForPublicInputsAndRecursiveProof(
-      BlockRollupPublicInputs.schema,
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-    ),
-  }),
-  z.object({
-    type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP),
-    result: schemaForPublicInputsAndRecursiveProof(
-      BlockRollupPublicInputs.schema,
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-    ),
-  }),
-  z.object({
-    type: z.literal(ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP),
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
       BlockRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP),
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
       BlockRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP),
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_NO_TXS_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
       BlockRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
@@ -309,13 +274,9 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
     result: schemaForPublicInputsAndRecursiveProof(RootRollupPublicInputs.schema, NESTED_RECURSIVE_PROOF_LENGTH),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.PARITY_BASE),
+    type: z.literal(ProvingRequestType.INBOX_PARITY),
     result: schemaForPublicInputsAndRecursiveProof(ParityPublicInputs.schema, RECURSIVE_PROOF_LENGTH),
   }),
-  z.object({
-    type: z.literal(ProvingRequestType.PARITY_ROOT),
-    result: schemaForPublicInputsAndRecursiveProof(ParityPublicInputs.schema, NESTED_RECURSIVE_PROOF_LENGTH),
-  }),
 ]);
 export type ProvingJobResult = z.infer<typeof ProvingJobResult>;
 export type ProvingJobResultsMap = {
@@ -336,15 +297,7 @@ export type ProvingJobResultsMap = {
     TxRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: PublicInputsAndRecursiveProof<
-    BlockRollupPublicInputs,
-    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-  >;
-  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: PublicInputsAndRecursiveProof<
-    BlockRollupPublicInputs,
-    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-  >;
-  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: PublicInputsAndRecursiveProof<
+  [ProvingRequestType.BLOCK_ROOT_NO_TXS_ROLLUP]: PublicInputsAndRecursiveProof<
     BlockRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
@@ -377,11 +330,7 @@ export type ProvingJobResultsMap = {
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
   [ProvingRequestType.ROOT_ROLLUP]: PublicInputsAndRecursiveProof<RootRollupPublicInputs>;
-  [ProvingRequestType.PARITY_BASE]: PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>;
-  [ProvingRequestType.PARITY_ROOT]: PublicInputsAndRecursiveProof<
-    ParityPublicInputs,
-    typeof NESTED_RECURSIVE_PROOF_LENGTH
-  >;
+  [ProvingRequestType.INBOX_PARITY]: PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>;
 };
 
 export type ProvingRequestResultFor<T extends ProvingRequestType> = { type: T; result: ProvingJobResultsMap[T] };

package/src/interfaces/server_circuit_prover.ts

@@ -6,17 +6,14 @@ import type {
 } from '@aztec/constants';
 
 import type { AvmCircuitInputs } from '../avm/avm.js';
-import type { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
+import type { InboxParityPrivateInputs } from '../parity/inbox_parity_private_inputs.js';
 import type { ParityPublicInputs } from '../parity/parity_public_inputs.js';
-import type { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
 import type { RecursiveProof } from '../proofs/recursive_proof.js';
 import type { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
 import type { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js';
 import type {
-  BlockRootEmptyTxFirstRollupPrivateInputs,
-  BlockRootFirstRollupPrivateInputs,
+  BlockRootNoTxsRollupPrivateInputs,
   BlockRootRollupPrivateInputs,
-  BlockRootSingleTxFirstRollupPrivateInputs,
   BlockRootSingleTxRollupPrivateInputs,
 } from '../rollup/block_root_rollup_private_inputs.js';
 import type { CheckpointMergeRollupPrivateInputs } from '../rollup/checkpoint_merge_rollup_private_inputs.js';
@@ -42,25 +39,16 @@ import type { PublicInputsAndRecursiveProof } from './proving-job.js';
  */
 export interface ServerCircuitProver {
   /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
+   * Creates the checkpoint's single InboxParity proof. The circuit variant (ladder size) is selected from
+   * `inputs.size`.
+   * @param inputs - Input to the circuit.
    */
-  getBaseParityProof(
-    inputs: ParityBasePrivateInputs,
+  getInboxParityProof(
+    inputs: InboxParityPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>>;
 
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */
-  getRootParityProof(
-    inputs: ParityRootPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
-
   getPublicChonkVerifierProof(
     inputs: PublicChonkVerifierPrivateInputs,
     signal?: AbortSignal,
@@ -99,24 +87,6 @@ export interface ServerCircuitProver {
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
    */
-  getBlockRootFirstRollupProof(
-    input: BlockRootFirstRollupPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-
-  getBlockRootSingleTxFirstRollupProof(
-    input: BlockRootSingleTxFirstRollupPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-
-  getBlockRootEmptyTxFirstRollupProof(
-    input: BlockRootEmptyTxFirstRollupPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-
   getBlockRootRollupProof(
     input: BlockRootRollupPrivateInputs,
     signal?: AbortSignal,
@@ -129,6 +99,12 @@ export interface ServerCircuitProver {
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
+  getBlockRootNoTxsRollupProof(
+    input: BlockRootNoTxsRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.

package/src/interfaces/validator.ts

@@ -11,6 +11,8 @@ import type {
   CheckpointAttestation,
   CheckpointProposal,
   CheckpointProposalOptions,
+  ValidatedBlockProposal,
+  ValidatedCheckpointProposalCore,
 } from '@aztec/stdlib/p2p';
 import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
@@ -153,7 +155,6 @@ export interface Validator {
     blockHeader: BlockHeader,
     checkpointNumber: CheckpointNumber,
     indexWithinCheckpoint: number,
-    inHash: Fr,
     archive: Fr,
     txs: Tx[],
     proposerAddress: EthAddress | undefined,
@@ -172,18 +173,18 @@ export interface Validator {
   ): Promise<CheckpointProposal>;
 
   /**
-   * Validate a block proposal from a peer.
+   * Validate a block proposal from a peer that has already passed p2p ingress validation.
    * Note: Validators do NOT attest to individual blocks - attestations are only for checkpoint proposals.
    * @returns true if the proposal is valid, false otherwise
    */
-  validateBlockProposal(proposal: BlockProposal, sender: PeerId): Promise<boolean>;
+  validateBlockProposal(proposal: ValidatedBlockProposal, sender: PeerId): Promise<boolean>;
 
   /**
-   * Validate and attest to a checkpoint proposal from a peer.
+   * Validate and attest to a checkpoint proposal from a peer that has already passed p2p ingress validation.
    * @returns Checkpoint attestations if valid, undefined otherwise
    */
   attestToCheckpointProposal(
-    proposal: CheckpointProposal,
+    proposal: ValidatedCheckpointProposalCore,
     sender: PeerId,
   ): Promise<CheckpointAttestation[] | undefined>;
 

package/src/kernel/private_kernel_reset_dimensions.ts

@@ -78,7 +78,7 @@ export interface ResetCatalogEntry {
   cost: number;
 }
 
-// Must match the config in noir-projects/fnd/noir-protocol-circuits/private_kernel_reset_config.json
+// Must match the shipped private_kernel_reset_config.json, loaded by @aztec/noir-protocol-circuits-types.
 export interface PrivateKernelResetDimensionsConfig {
   // Variants used for mid-tx resets that prevent overflow. Never the last kernel in the chain.
   inner: ResetCatalogEntry[];

package/src/messaging/append_l1_to_l2_messages.ts

@@ -1,21 +1,13 @@
-import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { MerkleTreeWriteOperations } from '../interfaces/merkle_tree_operations.js';
 import { MerkleTreeId } from '../trees/merkle_tree_id.js';
 
 /**
- * Pads `l1ToL2Messages` to `NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP` and appends them to the
- * L1→L2 message tree of `db`. Use whenever a fork at "state before the first block of a
- * checkpoint" needs to mirror what the world-state synchronizer inserts at sync time.
+ * Appends a block's real L1→L2 message leaves (unpadded, at compact indices) to the L1→L2 message tree of `db`.
+ * Use whenever a fork at "state before a block" needs to mirror what the world-state
+ * synchronizer inserts at sync time.
  */
 export async function appendL1ToL2MessagesToTree(db: MerkleTreeWriteOperations, l1ToL2Messages: Fr[]): Promise<void> {
-  const padded = padArrayEnd<Fr, number>(
-    l1ToL2Messages,
-    Fr.ZERO,
-    NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-    'Too many L1 to L2 messages',
-  );
-  await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, padded);
+  await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
 }