@aztec/validator-client 0.0.1-commit.3469e52 → 0.0.1-commit.350e0a4d

package/README.md

@@ -77,6 +77,8 @@ These rules must always hold:
 2. **Global variables match within checkpoint**: All blocks within the same checkpoint must have identical global variables (except `blockNumber`), which includes the slot number
 3. **inHash is constant**: All blocks in a checkpoint share the same L1-to-L2 messages hash
 4. **Sequential indexWithinCheckpoint**: Block N must have `indexWithinCheckpoint = parent.indexWithinCheckpoint + 1`
+5. **One proposer per slot**: Each slot has exactly one designated proposer. Sending multiple proposals for the same position (slot, indexWithinCheckpoint) with different content is equivocation and slashable
+6. **One attestation per slot**: Validators should only attest to one checkpoint per slot. Attesting to different proposals (different archives) for the same slot is equivocation and slashable
 
 ## Validation Flow
 
@@ -87,15 +89,14 @@ When a `BlockProposal` is received via P2P, the `BlockProposalHandler` performs:
 ```
 1. Verify proposer signature
 2. Check proposal is from current/next slot proposer (via BlockProposalValidator)
-3. Find parent block by archive root (wait/retry if not synced)
-4. Compute checkpoint number from parent
-5. If indexWithinCheckpoint > 0:
-   - Validate global variables match parent (chainId, version, slotNumber,
-     timestamp, coinbase, feeRecipient, gasFees)
-6. Verify inHash matches computed from L1-to-L2 messages
-7. Collect transactions from pool/network/proposal
-8. Re-execute transactions (if enabled)
-9. Compare re-execution result with proposal
+3. Detect duplicate proposals (same slot + indexWithinCheckpoint, different archive) slashing proposer on equivocation
+4. Find parent block by archive root (wait/retry if not synced)
+5. Compute checkpoint number from parent
+6. If indexWithinCheckpoint > 0, then validate global variables match parent (chainId, version, slotNumber, timestamp, coinbase, feeRecipient, gasFees)
+7. Verify inHash matches computed from L1-to-L2 messages
+8. Collect transactions from pool/network/proposal
+9. Re-execute transactions (if enabled)
+10. Compare re-execution result with proposal
 ```
 
 ### Checkpoint Proposal Validation
@@ -155,15 +156,16 @@ Time | Proposer                     | Validator
 
 ## Configuration
 
-| Flag                                  | Purpose                                                               |
-| ------------------------------------- | --------------------------------------------------------------------- |
-| `validatorReexecute`                  | Re-execute transactions to verify proposals                           |
-| `fishermanMode`                       | Validate proposals but don't broadcast attestations (monitoring only) |
-| `alwaysReexecuteBlockProposals`       | Force re-execution even when not in committee                         |
-| `slashBroadcastedInvalidBlockPenalty` | Penalty amount for invalid proposals (0 = disabled)                   |
-| `validatorReexecuteDeadlineMs`        | Time reserved at end of slot for propagation/publishing               |
-| `attestationPollingIntervalMs`        | How often to poll for attestations when collecting                    |
-| `disabledValidators`                  | Validator addresses to exclude from duties                            |
+| Flag                                               | Purpose                                                              |
+| -------------------------------------------------- | -------------------------------------------------------------------- |
+| `fishermanMode`                                    | Validate proposals but don't broadcast attestations (monitoring only) |
+| `alwaysReexecuteBlockProposals`                    | Force re-execution even when not in committee                         |
+| `slashBroadcastedInvalidBlockPenalty`              | Penalty amount for invalid proposals (0 = disabled)                   |
+| `slashBroadcastedInvalidCheckpointProposalPenalty` | Penalty amount for invalid checkpoint proposals (0 = disabled)        |
+| `slashDuplicateProposalPenalty`                    | Penalty amount for duplicate proposals (0 = disabled)                 |
+| `slashDuplicateAttestationPenalty`                 | Penalty amount for duplicate attestations (0 = disabled)              |
+| `attestationPollingIntervalMs`                     | How often to poll for attestations when collecting                    |
+| `disabledValidators`                               | Validator addresses to exclude from duties                            |
 
 ### High Availability (HA) Keystore
 
@@ -220,6 +222,49 @@ This is useful for monitoring network health without participating in consensus.
 - `createCheckpointProposal(...)` → `CheckpointProposal`: Signs checkpoint proposal
 - `attestToCheckpointProposal(proposal, attestors)` → `CheckpointAttestation[]`: Creates attestations for given addresses
 
+## Block Building Limits
+
+L1 enforces gas and blob capacity per checkpoint. The node enforces these during block building to avoid L1 rejection. Three dimensions are metered: L2 gas (mana), DA gas, and blob fields. DA gas maps to blob fields today (`daGas = blobFields * 32`) but both are tracked independently.
+
+The full per-tx → per-block → per-checkpoint limits hierarchy, including how the per-block budgets relate to the network admission limits, is documented in [`stdlib/src/gas/README.md`](../stdlib/src/gas/README.md) under "Gas and Data Limits".
+
+### Checkpoint limits
+
+| Dimension | Source | Budget |
+| --- | --- | --- |
+| L2 gas (mana) | `rollup.getManaLimit()` | Fetched from L1 at startup |
+| DA gas | `MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT` | 786,432 (6 blobs × 4096 fields × 32 gas/field) |
+| Blob fields | `BLOBS_PER_CHECKPOINT × FIELDS_PER_BLOB` | 24,576 minus checkpoint/block-end overhead |
+
+### Per-block budgets
+
+Per-block budgets prevent one block from consuming the entire checkpoint budget. The checkpoint builder dynamically computes per-block limits before each block based on the remaining checkpoint budget and the number of remaining blocks.
+
+**Proposer**: When building a proposal (`isBuildingProposal: true`), the `CheckpointProposalJob` passes `maxBlocksPerCheckpoint` (from the timetable) and `perBlockAllocationMultiplier` (default 1.2) via opts to `CheckpointBuilder.buildBlock`. The builder computes a fair share as `min(perBlockLimit, ceil(remainingBudget / remainingBlocks * multiplier), remainingBudget)`. The multiplier greater than 1 allows early blocks to use more than their even share, since different blocks hit different limit dimensions (L2 gas, DA gas, blob fields) — a strict even split would waste capacity. As prior blocks consume budget, later blocks see tightened limits. This applies to all four dimensions (L2 gas, DA gas, blob fields, transaction count). Operators can set hard per-block caps via `SEQ_MAX_L2_BLOCK_GAS` / `SEQ_MAX_DA_BLOCK_GAS` / `SEQ_MAX_TX_PER_BLOCK` (capped at checkpoint limits at startup); these act as additional upper bounds alongside the redistribution.
+
+**Validator**: When re-executing a proposal (`isBuildingProposal` unset), `capLimitsByCheckpointBudgets` only caps by the per-block limit and the total remaining checkpoint budget — no redistribution or multiplier is applied. This avoids false rejections due to differences between proposer and validator fair-share calculations. Validators can optionally set hard per-block limits via `VALIDATOR_MAX_L2_BLOCK_GAS`, `VALIDATOR_MAX_DA_BLOCK_GAS`, and `VALIDATOR_MAX_TX_PER_BLOCK`. When unset, no per-block limit is enforced (checkpoint-level protocol limits still apply). These are independent of the `SEQ_` vars so operators can tune proposer and validation limits separately.
+
+### Per-transaction enforcement
+
+**Mempool entry** (`GasLimitsValidator`): L2 gas must be ≤ `MAX_PROCESSABLE_L2_GAS` (6,540,000) and ≥ fixed minimums.
+
+**Block building** (`PublicProcessor.process`): Before processing, txs are skipped if their estimated blob fields or gas limits would exceed the block budget. After processing, actual values are checked and the tx is reverted if limits are exceeded.
+
+### Gas limit configuration
+
+| Variable | Default | Description |
+| --- | --- | --- |
+| `SEQ_MAX_L2_BLOCK_GAS` | *none* | Hard per-block L2 gas cap. Capped at `rollupManaLimit` at startup. When unset, redistribution dynamically computes per-block limits. |
+| `SEQ_MAX_DA_BLOCK_GAS` | *none* | Hard per-block DA gas cap. Capped at `MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT` at startup. When unset, redistribution handles it. |
+| `SEQ_MAX_TX_PER_BLOCK` | *none* | Hard per-block tx count cap. Capped at `SEQ_MAX_TX_PER_CHECKPOINT` at startup (if set). |
+| `SEQ_MAX_TX_PER_CHECKPOINT` | *none* | Total txs across all blocks in a checkpoint. When set, checkpoint-level capping and redistribution are enforced for tx count. |
+| `SEQ_PER_BLOCK_ALLOCATION_MULTIPLIER` | 1.2 | Multiplier for per-block budget redistribution. Passed via opts to the checkpoint builder during proposal building. |
+| `SEQ_REDISTRIBUTE_CHECKPOINT_BUDGET` | true | Legacy flag; redistribution is now always active during proposal building and inactive during validation. |
+| `VALIDATOR_MAX_L2_BLOCK_GAS` | *none* | Per-block L2 gas limit for validation. Proposals exceeding this are rejected. |
+| `VALIDATOR_MAX_DA_BLOCK_GAS` | *none* | Per-block DA gas limit for validation. Proposals exceeding this are rejected. |
+| `VALIDATOR_MAX_TX_PER_BLOCK` | *none* | Per-block tx count limit for validation. Proposals exceeding this are rejected. |
+| `VALIDATOR_MAX_TX_PER_CHECKPOINT` | *none* | Per-checkpoint tx count limit for validation. Proposals exceeding this are rejected. |
+
 ## Testing Patterns
 
 ### Common Mocks
@@ -268,7 +313,7 @@ For tests that exercise re-execution:
 ```typescript
 // Mock parent block lookup
 blockSource.getBlockHeaderByArchive.mockResolvedValue(parentBlockHeader);
-blockSource.getL2BlockNew.mockResolvedValue({
+blockSource.getL2Block.mockResolvedValue({
   checkpointNumber: CheckpointNumber(1),
   indexWithinCheckpoint: 0,
   header: { globalVariables: parentGlobalVariables },

package/dest/checkpoint_builder.d.ts

@@ -1,20 +1,18 @@
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { DateProvider, Timer } from '@aztec/foundation/timer';
+import { type LoggerBindings } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 import { LightweightCheckpointBuilder } from '@aztec/prover-client/light';
-import { PublicProcessor } from '@aztec/simulator/server';
-import { L2BlockNew } from '@aztec/stdlib/block';
+import { PublicContractsDB, PublicProcessor } from '@aztec/simulator/server';
+import { L2Block } from '@aztec/stdlib/block';
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
-import { type BuildBlockInCheckpointResult, type FullNodeBlockBuilderConfig, type ICheckpointBlockBuilder, type ICheckpointsBuilder, type MerkleTreeWriteOperations, type PublicProcessorLimits, type WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { type BlockBuilderOptions, type BuildBlockInCheckpointResult, type FullNodeBlockBuilderConfig, type ICheckpointBlockBuilder, type ICheckpointsBuilder, type MerkleTreeWriteOperations, type PublicProcessorLimits, type WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { type DebugLogStore } from '@aztec/stdlib/logs';
 import { type CheckpointGlobalVariables, GlobalVariables, StateReference, Tx } from '@aztec/stdlib/tx';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 export type { BuildBlockInCheckpointResult } from '@aztec/stdlib/interfaces/server';
-/** Result of building a block within a checkpoint. Extends the base interface with timer. */
-export interface BuildBlockInCheckpointResultWithTimer extends BuildBlockInCheckpointResult {
-    blockBuildingTimer: Timer;
-}
 /**
  * Builder for a single checkpoint. Handles building blocks within the checkpoint
  * and completing it.
@@ -26,18 +24,30 @@ export declare class CheckpointBuilder implements ICheckpointBlockBuilder {
     private contractDataSource;
     private dateProvider;
     private telemetryClient;
-    constructor(checkpointBuilder: LightweightCheckpointBuilder, fork: MerkleTreeWriteOperations, config: FullNodeBlockBuilderConfig, contractDataSource: ContractDataSource, dateProvider: DateProvider, telemetryClient: TelemetryClient);
+    private debugLogStore;
+    private log;
+    /** Persistent contracts DB shared across all blocks in this checkpoint. */
+    protected contractsDB: PublicContractsDB;
+    constructor(checkpointBuilder: LightweightCheckpointBuilder, fork: MerkleTreeWriteOperations, config: FullNodeBlockBuilderConfig, contractDataSource: ContractDataSource, dateProvider: DateProvider, telemetryClient: TelemetryClient, bindings?: LoggerBindings, debugLogStore?: DebugLogStore);
     getConstantData(): CheckpointGlobalVariables;
     /**
      * Builds a single block within this checkpoint.
+     * Automatically caps gas and blob field limits based on checkpoint-level budgets and prior blocks.
      */
-    buildBlock(pendingTxs: Iterable<Tx> | AsyncIterable<Tx>, blockNumber: BlockNumber, timestamp: bigint, opts: PublicProcessorLimits & {
+    buildBlock(pendingTxs: Iterable<Tx> | AsyncIterable<Tx>, blockNumber: BlockNumber, timestamp: bigint, opts: BlockBuilderOptions & {
         expectedEndState?: StateReference;
-    }): Promise<BuildBlockInCheckpointResultWithTimer>;
+    }): Promise<BuildBlockInCheckpointResult>;
     /** Completes the checkpoint and returns it. */
     completeCheckpoint(): Promise<Checkpoint>;
     /** Gets the checkpoint currently in progress. */
     getCheckpoint(): Promise<Checkpoint>;
+    /**
+     * Caps per-block gas and blob field limits by remaining checkpoint-level budgets.
+     * When building a proposal (isBuildingProposal=true), computes a fair share of remaining budget
+     * across remaining blocks scaled by the multiplier. When validating, only caps by per-block limit
+     * and remaining checkpoint budget (no redistribution or multiplier).
+     */
+    protected capLimitsByCheckpointBudgets(opts: BlockBuilderOptions): Pick<PublicProcessorLimits, 'maxBlockGas' | 'maxBlobFields' | 'maxTransactions'>;
     protected makeBlockBuilderDeps(globalVariables: GlobalVariables, fork: MerkleTreeWriteOperations): Promise<{
         processor: PublicProcessor;
         validator: import("@aztec/stdlib/interfaces/server").PublicProcessorValidator;
@@ -50,18 +60,20 @@ export declare class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
     private contractDataSource;
     private dateProvider;
     private telemetryClient;
-    constructor(config: FullNodeBlockBuilderConfig & Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>, worldState: WorldStateSynchronizer, contractDataSource: ContractDataSource, dateProvider: DateProvider, telemetryClient?: TelemetryClient);
+    private debugLogStore;
+    private log;
+    constructor(config: FullNodeBlockBuilderConfig & Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>, worldState: WorldStateSynchronizer, contractDataSource: ContractDataSource, dateProvider: DateProvider, telemetryClient?: TelemetryClient, debugLogStore?: DebugLogStore);
     getConfig(): FullNodeBlockBuilderConfig;
     updateConfig(config: Partial<FullNodeBlockBuilderConfig>): void;
     /**
      * Starts a new checkpoint and returns a CheckpointBuilder to build blocks within it.
      */
-    startCheckpoint(checkpointNumber: CheckpointNumber, constants: CheckpointGlobalVariables, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], fork: MerkleTreeWriteOperations): Promise<CheckpointBuilder>;
+    startCheckpoint(checkpointNumber: CheckpointNumber, constants: CheckpointGlobalVariables, feeAssetPriceModifier: bigint, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], fork: MerkleTreeWriteOperations, bindings?: LoggerBindings): Promise<CheckpointBuilder>;
     /**
      * Opens a checkpoint, either starting fresh or resuming from existing blocks.
      */
-    openCheckpoint(checkpointNumber: CheckpointNumber, constants: CheckpointGlobalVariables, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], fork: MerkleTreeWriteOperations, existingBlocks?: L2BlockNew[]): Promise<CheckpointBuilder>;
+    openCheckpoint(checkpointNumber: CheckpointNumber, constants: CheckpointGlobalVariables, feeAssetPriceModifier: bigint, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], fork: MerkleTreeWriteOperations, existingBlocks?: L2Block[], bindings?: LoggerBindings): Promise<CheckpointBuilder>;
     /** Returns a fork of the world state at the given block number. */
     getFork(blockNumber: BlockNumber): Promise<MerkleTreeWriteOperations>;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/checkpoint_builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkpoint_builder.d.ts","sourceRoot":"","sources":["../src/checkpoint_builder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"checkpoint_builder.d.ts","sourceRoot":"","sources":["../src/checkpoint_builder.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,EAAE,YAAY,EAAW,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC;AAC1E,OAAO,EAEL,iBAAiB,EACjB,eAAe,EAEhB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAErE,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,4BAA4B,EACjC,KAAK,0BAA0B,EAE/B,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EAExB,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC5B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,KAAK,aAAa,EAAqB,MAAM,oBAAoB,CAAC;AAE3E,OAAO,EAAE,KAAK,yBAAyB,EAAE,eAAe,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACvG,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAInF,YAAY,EAAE,4BAA4B,EAAE,MAAM,iCAAiC,CAAC;AAEpF;;;GAGG;AACH,qBAAa,iBAAkB,YAAW,uBAAuB;IAO7D,OAAO,CAAC,iBAAiB;IACzB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,eAAe;IAEvB,OAAO,CAAC,aAAa;IAbvB,OAAO,CAAC,GAAG,CAAS;IAEpB,2EAA2E;IAC3E,SAAS,CAAC,WAAW,EAAE,iBAAiB,CAAC;IAEzC,YACU,iBAAiB,EAAE,4BAA4B,EAC/C,IAAI,EAAE,yBAAyB,EAC/B,MAAM,EAAE,0BAA0B,EAClC,kBAAkB,EAAE,kBAAkB,EACtC,YAAY,EAAE,YAAY,EAC1B,eAAe,EAAE,eAAe,EACxC,QAAQ,CAAC,EAAE,cAAc,EACjB,aAAa,GAAE,aAAuC,EAO/D;IAED,eAAe,IAAI,yBAAyB,CAE3C;IAED;;;OAGG;IACG,UAAU,CACd,UAAU,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC,EAC5C,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,mBAAmB,GAAG;QAAE,gBAAgB,CAAC,EAAE,cAAc,CAAA;KAAE,GAChE,OAAO,CAAC,4BAA4B,CAAC,CA6EvC;IAED,+CAA+C;IACzC,kBAAkB,IAAI,OAAO,CAAC,UAAU,CAAC,CAU9C;IAED,iDAAiD;IACjD,aAAa,IAAI,OAAO,CAAC,UAAU,CAAC,CAEnC;IAED;;;;;OAKG;IACH,SAAS,CAAC,4BAA4B,CACpC,IAAI,EAAE,mBAAmB,GACxB,IAAI,CAAC,qBAAqB,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,CAAC,CAgDlF;IAED,UAAgB,oBAAoB,CAAC,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,yBAAyB;;;OA4CrG;CACF;AAED,gDAAgD;AAChD,qBAAa,0BAA2B,YAAW,mBAAmB;IAIlE,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,aAAa;IARvB,OAAO,CAAC,GAAG,CAAS;IAEpB,YACU,MAAM,EAAE,0BAA0B,GAAG,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,cAAc,CAAC,EAC9F,UAAU,EAAE,sBAAsB,EAClC,kBAAkB,EAAE,kBAAkB,EACtC,YAAY,EAAE,YAAY,EAC1B,eAAe,GAAE,eAAsC,EACvD,aAAa,GAAE,aAAuC,EAG/D;IAEM,SAAS,IAAI,0BAA0B,CAE7C;IAEM,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,0BAA0B,CAAC,QAE9D;IAED;;OAEG;IACG,eAAe,CACnB,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,yBAAyB,EACpC,qBAAqB,EAAE,MAAM,EAC7B,cAAc,EAAE,EAAE,EAAE,EACpB,2BAA2B,EAAE,EAAE,EAAE,EACjC,IAAI,EAAE,yBAAyB,EAC/B,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,iBAAiB,CAAC,CAiC5B;IAED;;OAEG;IACG,cAAc,CAClB,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,yBAAyB,EACpC,qBAAqB,EAAE,MAAM,EAC7B,cAAc,EAAE,EAAE,EAAE,EACpB,2BAA2B,EAAE,EAAE,EAAE,EACjC,IAAI,EAAE,yBAAyB,EAC/B,cAAc,GAAE,OAAO,EAAO,EAC9B,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,iBAAiB,CAAC,CA+C5B;IAED,mEAAmE;IACnE,OAAO,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAEpE;CACF"}

package/dest/checkpoint_builder.js

@@ -1,17 +1,19 @@
-import { merge, pick } from '@aztec/foundation/collection';
+import { NUM_CHECKPOINT_END_MARKER_FIELDS, getNumBlockEndBlobFields } from '@aztec/blob-lib/encoding';
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT } from '@aztec/constants';
+import { merge, pick, sum } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
-import { Timer, elapsed } from '@aztec/foundation/timer';
-import { getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
+import { elapsed } from '@aztec/foundation/timer';
+import { createTxValidatorForBlockBuilding, getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
 import { LightweightCheckpointBuilder } from '@aztec/prover-client/light';
 import { GuardedMerkleTreeOperations, PublicContractsDB, PublicProcessor, createPublicTxSimulatorForBlockBuilding } from '@aztec/simulator/server';
 import { Gas } from '@aztec/stdlib/gas';
-import { FullNodeBlockBuilderConfigKeys } from '@aztec/stdlib/interfaces/server';
+import { FullNodeBlockBuilderConfigKeys, InsufficientValidTxsError } from '@aztec/stdlib/interfaces/server';
+import { NullDebugLogStore } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { GlobalVariables } from '@aztec/stdlib/tx';
 import { getTelemetryClient } from '@aztec/telemetry-client';
-import { createValidatorForBlockBuilding } from './tx_validator/tx_validator_factory.js';
-const log = createLogger('checkpoint-builder');
+import { ForkCheckpoint } from '@aztec/world-state';
 /**
  * Builder for a single checkpoint. Handles building blocks within the checkpoint
  * and completing it.
@@ -22,23 +24,32 @@ const log = createLogger('checkpoint-builder');
     contractDataSource;
     dateProvider;
     telemetryClient;
-    constructor(checkpointBuilder, fork, config, contractDataSource, dateProvider, telemetryClient){
+    debugLogStore;
+    log;
+    /** Persistent contracts DB shared across all blocks in this checkpoint. */ contractsDB;
+    constructor(checkpointBuilder, fork, config, contractDataSource, dateProvider, telemetryClient, bindings, debugLogStore = new NullDebugLogStore()){
         this.checkpointBuilder = checkpointBuilder;
         this.fork = fork;
         this.config = config;
         this.contractDataSource = contractDataSource;
         this.dateProvider = dateProvider;
         this.telemetryClient = telemetryClient;
+        this.debugLogStore = debugLogStore;
+        this.log = createLogger('checkpoint-builder', {
+            ...bindings,
+            instanceId: `checkpoint-${checkpointBuilder.checkpointNumber}`
+        });
+        this.contractsDB = new PublicContractsDB(this.contractDataSource, this.log.getBindings());
     }
     getConstantData() {
         return this.checkpointBuilder.constants;
     }
     /**
    * Builds a single block within this checkpoint.
+   * Automatically caps gas and blob field limits based on checkpoint-level budgets and prior blocks.
    */ async buildBlock(pendingTxs, blockNumber, timestamp, opts) {
-        const blockBuildingTimer = new Timer();
         const slot = this.checkpointBuilder.constants.slotNumber;
-        log.verbose(`Building block ${blockNumber} for slot ${slot} within checkpoint`, {
+        this.log.verbose(`Building block ${blockNumber} for slot ${slot} within checkpoint`, {
             slot,
             blockNumber,
             ...opts,
@@ -56,29 +67,54 @@ const log = createLogger('checkpoint-builder');
             gasFees: constants.gasFees
         });
         const { processor, validator } = await this.makeBlockBuilderDeps(globalVariables, this.fork);
-        const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs, _, usedTxBlobFields]] = await elapsed(()=>processor.process(pendingTxs, opts, validator));
-        // Add block to checkpoint
-        const block = await this.checkpointBuilder.addBlock(globalVariables, processedTxs, {
-            expectedEndState: opts.expectedEndState
-        });
-        // How much public gas was processed
-        const publicGas = processedTxs.reduce((acc, tx)=>acc.add(tx.gasUsed.publicGas), Gas.empty());
-        const res = {
-            block,
-            publicGas,
-            publicProcessorDuration,
-            numTxs: processedTxs.length,
-            failedTxs,
-            blockBuildingTimer,
-            usedTxs,
-            usedTxBlobFields
+        // Cap gas limits amd available blob fields by remaining checkpoint-level budgets
+        const cappedOpts = {
+            ...opts,
+            ...this.capLimitsByCheckpointBudgets(opts)
         };
-        log.debug('Built block within checkpoint', res.block.header);
-        return res;
+        // Create a block-level checkpoint on the contracts DB so we can roll back on failure
+        this.contractsDB.createCheckpoint();
+        // We execute all merkle tree operations on a world state fork checkpoint
+        // This enables us to discard all modifications in the event that we fail to successfully process sufficient transactions
+        const forkCheckpoint = await ForkCheckpoint.new(this.fork);
+        try {
+            const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs]] = await elapsed(()=>processor.process(pendingTxs, cappedOpts, validator));
+            // Throw before updating state if we don't have enough valid txs
+            const minValidTxs = opts.minValidTxs ?? 0;
+            if (processedTxs.length < minValidTxs) {
+                throw new InsufficientValidTxsError(processedTxs.length, minValidTxs, failedTxs);
+            }
+            // Commit the fork checkpoint
+            await forkCheckpoint.commit();
+            // Add block to checkpoint
+            const { block } = await this.checkpointBuilder.addBlock(globalVariables, processedTxs, {
+                expectedEndState: opts.expectedEndState
+            });
+            this.contractsDB.commitCheckpoint();
+            this.log.debug('Built block within checkpoint', {
+                header: block.header.toInspect(),
+                processedTxs: processedTxs.map((tx)=>tx.hash.toString()),
+                failedTxs: failedTxs.map((tx)=>tx.tx.txHash.toString())
+            });
+            return {
+                block,
+                publicProcessorDuration,
+                numTxs: processedTxs.length,
+                failedTxs,
+                usedTxs
+            };
+        } catch (err) {
+            // Revert all changes to contracts db
+            this.contractsDB.revertCheckpoint();
+            // If we reached the point of committing the checkpoint, this does nothing
+            // Otherwise it reverts any changes made to the fork for this failed block
+            await forkCheckpoint.revert();
+            throw err;
+        }
     }
     /** Completes the checkpoint and returns it. */ async completeCheckpoint() {
         const checkpoint = await this.checkpointBuilder.completeCheckpoint();
-        log.verbose(`Completed checkpoint ${checkpoint.number}`, {
+        this.log.verbose(`Completed checkpoint ${checkpoint.number}`, {
             checkpointNumber: checkpoint.number,
             numBlocks: checkpoint.blocks.length,
             archiveRoot: checkpoint.archive.root.toString()
@@ -88,13 +124,64 @@ const log = createLogger('checkpoint-builder');
     /** Gets the checkpoint currently in progress. */ getCheckpoint() {
         return this.checkpointBuilder.clone().completeCheckpoint();
     }
+    /**
+   * Caps per-block gas and blob field limits by remaining checkpoint-level budgets.
+   * When building a proposal (isBuildingProposal=true), computes a fair share of remaining budget
+   * across remaining blocks scaled by the multiplier. When validating, only caps by per-block limit
+   * and remaining checkpoint budget (no redistribution or multiplier).
+   */ capLimitsByCheckpointBudgets(opts) {
+        const existingBlocks = this.checkpointBuilder.getBlocks();
+        // Remaining L2 gas (mana)
+        // IMPORTANT: This assumes mana is computed solely based on L2 gas used in transactions.
+        // This may change in the future.
+        const usedMana = sum(existingBlocks.map((b)=>b.header.totalManaUsed.toNumber()));
+        const remainingMana = this.config.rollupManaLimit - usedMana;
+        // Remaining DA gas
+        const usedDAGas = sum(existingBlocks.map((b)=>b.computeDAGasUsed())) ?? 0;
+        const remainingDAGas = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT - usedDAGas;
+        // Remaining blob fields (block blob fields include both tx data and block-end overhead)
+        const usedBlobFields = sum(existingBlocks.map((b)=>b.toBlobFields().length));
+        const totalBlobCapacity = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS;
+        const isFirstBlock = existingBlocks.length === 0;
+        const blockEndOverhead = getNumBlockEndBlobFields(isFirstBlock);
+        const maxBlobFieldsForTxs = totalBlobCapacity - usedBlobFields - blockEndOverhead;
+        // Remaining txs
+        const usedTxs = sum(existingBlocks.map((b)=>b.body.txEffects.length));
+        const remainingTxs = Math.max(0, (this.config.maxTxsPerCheckpoint ?? Infinity) - usedTxs);
+        // Cap by per-block limit + remaining checkpoint budget
+        let cappedL2Gas = Math.min(opts.maxBlockGas?.l2Gas ?? Infinity, remainingMana);
+        let cappedDAGas = Math.min(opts.maxBlockGas?.daGas ?? Infinity, remainingDAGas);
+        let cappedBlobFields = Math.min(opts.maxBlobFields ?? Infinity, maxBlobFieldsForTxs);
+        let cappedMaxTransactions = Math.min(opts.maxTransactions ?? Infinity, remainingTxs);
+        // Proposer mode: further cap by fair share of remaining budget across remaining blocks
+        if (opts.isBuildingProposal) {
+            const remainingBlocks = Math.max(1, opts.maxBlocksPerCheckpoint - existingBlocks.length);
+            const multiplier = opts.perBlockAllocationMultiplier;
+            // DA gas and blob fields use a higher multiplier so the largest contract class deploy fits a block.
+            const daMultiplier = opts.perBlockDAAllocationMultiplier ?? multiplier;
+            cappedL2Gas = Math.min(cappedL2Gas, Math.ceil(remainingMana / remainingBlocks * multiplier));
+            cappedDAGas = Math.min(cappedDAGas, Math.ceil(remainingDAGas / remainingBlocks * daMultiplier));
+            cappedBlobFields = Math.min(cappedBlobFields, Math.ceil(maxBlobFieldsForTxs / remainingBlocks * daMultiplier));
+            cappedMaxTransactions = Math.min(cappedMaxTransactions, Math.ceil(remainingTxs / remainingBlocks * multiplier));
+        }
+        return {
+            maxBlockGas: new Gas(cappedDAGas, cappedL2Gas),
+            maxBlobFields: cappedBlobFields,
+            maxTransactions: Number.isFinite(cappedMaxTransactions) ? cappedMaxTransactions : undefined
+        };
+    }
     async makeBlockBuilderDeps(globalVariables, fork) {
-        const txPublicSetupAllowList = this.config.txPublicSetupAllowList ?? await getDefaultAllowedSetupFunctions();
-        const contractsDB = new PublicContractsDB(this.contractDataSource);
+        const txPublicSetupAllowList = [
+            ...await getDefaultAllowedSetupFunctions(),
+            ...this.config.txPublicSetupAllowListExtend ?? []
+        ];
+        const contractsDB = this.contractsDB;
         const guardedFork = new GuardedMerkleTreeOperations(fork);
-        const publicTxSimulator = createPublicTxSimulatorForBlockBuilding(guardedFork, contractsDB, globalVariables, this.telemetryClient);
-        const processor = new PublicProcessor(globalVariables, guardedFork, contractsDB, publicTxSimulator, this.dateProvider, this.telemetryClient, undefined, this.config);
-        const validator = createValidatorForBlockBuilding(fork, this.contractDataSource, globalVariables, txPublicSetupAllowList);
+        const collectDebugLogs = this.debugLogStore.isEnabled;
+        const bindings = this.log.getBindings();
+        const publicTxSimulator = createPublicTxSimulatorForBlockBuilding(guardedFork, contractsDB, globalVariables, this.telemetryClient, bindings, collectDebugLogs);
+        const processor = new PublicProcessor(globalVariables, guardedFork, contractsDB, publicTxSimulator, this.dateProvider, this.telemetryClient, createLogger('simulator:public-processor', bindings), this.config, this.debugLogStore);
+        const validator = createTxValidatorForBlockBuilding(fork, this.contractDataSource, globalVariables, txPublicSetupAllowList, this.log.getBindings());
         return {
             processor,
             validator
@@ -107,12 +194,16 @@ const log = createLogger('checkpoint-builder');
     contractDataSource;
     dateProvider;
     telemetryClient;
-    constructor(config, worldState, contractDataSource, dateProvider, telemetryClient = getTelemetryClient()){
+    debugLogStore;
+    log;
+    constructor(config, worldState, contractDataSource, dateProvider, telemetryClient = getTelemetryClient(), debugLogStore = new NullDebugLogStore()){
         this.config = config;
         this.worldState = worldState;
         this.contractDataSource = contractDataSource;
         this.dateProvider = dateProvider;
         this.telemetryClient = telemetryClient;
+        this.debugLogStore = debugLogStore;
+        this.log = createLogger('checkpoint-builder');
     }
     getConfig() {
         return this.config;
@@ -122,37 +213,39 @@ const log = createLogger('checkpoint-builder');
     }
     /**
    * Starts a new checkpoint and returns a CheckpointBuilder to build blocks within it.
-   */ async startCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, fork) {
+   */ async startCheckpoint(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, bindings) {
         const stateReference = await fork.getStateReference();
         const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
-        log.verbose(`Building new checkpoint ${checkpointNumber}`, {
+        this.log.verbose(`Building new checkpoint ${checkpointNumber}`, {
             checkpointNumber,
             msgCount: l1ToL2Messages.length,
             initialStateReference: stateReference.toInspect(),
             initialArchiveRoot: bufferToHex(archiveTree.root),
-            constants
+            constants,
+            feeAssetPriceModifier
         });
-        const lightweightBuilder = await LightweightCheckpointBuilder.startNewCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, fork);
-        return new CheckpointBuilder(lightweightBuilder, fork, this.config, this.contractDataSource, this.dateProvider, this.telemetryClient);
+        const lightweightBuilder = await LightweightCheckpointBuilder.startNewCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, fork, bindings, feeAssetPriceModifier);
+        return new CheckpointBuilder(lightweightBuilder, fork, this.config, this.contractDataSource, this.dateProvider, this.telemetryClient, bindings, this.debugLogStore);
     }
     /**
    * Opens a checkpoint, either starting fresh or resuming from existing blocks.
-   */ async openCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, fork, existingBlocks = []) {
+   */ async openCheckpoint(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, existingBlocks = [], bindings) {
         const stateReference = await fork.getStateReference();
         const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
         if (existingBlocks.length === 0) {
-            return this.startCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, fork);
+            return this.startCheckpoint(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, bindings);
         }
-        log.verbose(`Resuming checkpoint ${checkpointNumber} with ${existingBlocks.length} existing blocks`, {
+        this.log.verbose(`Resuming checkpoint ${checkpointNumber} with ${existingBlocks.length} existing blocks`, {
             checkpointNumber,
             msgCount: l1ToL2Messages.length,
             existingBlockCount: existingBlocks.length,
             initialStateReference: stateReference.toInspect(),
             initialArchiveRoot: bufferToHex(archiveTree.root),
-            constants
+            constants,
+            feeAssetPriceModifier
         });
-        const lightweightBuilder = await LightweightCheckpointBuilder.resumeCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, fork, existingBlocks);
-        return new CheckpointBuilder(lightweightBuilder, fork, this.config, this.contractDataSource, this.dateProvider, this.telemetryClient);
+        const lightweightBuilder = await LightweightCheckpointBuilder.resumeCheckpoint(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, existingBlocks, bindings);
+        return new CheckpointBuilder(lightweightBuilder, fork, this.config, this.contractDataSource, this.dateProvider, this.telemetryClient, bindings, this.debugLogStore);
     }
     /** Returns a fork of the world state at the given block number. */ getFork(blockNumber) {
         return this.worldState.fork(blockNumber);

package/dest/config.d.ts

@@ -1,11 +1,17 @@
 import { type ConfigMappingsType } from '@aztec/foundation/config';
+import { type SequencerConfig } from '@aztec/stdlib/config';
 import type { ValidatorClientConfig } from '@aztec/stdlib/interfaces/server';
 export type { ValidatorClientConfig };
-export declare const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientConfig>;
+/**
+ * Default clock-disparity tolerance (ms) for proposal/attestation receive windows, mirroring the p2p config
+ * default. Used by the validator-client validators when the merged node config does not carry the value.
+ */
+export declare const DEFAULT_MAX_GOSSIP_CLOCK_DISPARITY_MS = 500;
+export declare const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientConfig & Pick<SequencerConfig, 'blockDurationMs'>>;
 /**
  * Returns the prover configuration from the environment variables.
  * Note: If an environment variable is not set, the default value is used.
  * @returns The validator configuration.
  */
-export declare function getProverEnvVars(): ValidatorClientConfig;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxLQUFLLGtCQUFrQixFQUt4QixNQUFNLDBCQUEwQixDQUFDO0FBRWxDLE9BQU8sS0FBSyxFQUFFLHFCQUFxQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFHN0UsWUFBWSxFQUFFLHFCQUFxQixFQUFFLENBQUM7QUFFdEMsZUFBTyxNQUFNLDZCQUE2QixFQUFFLGtCQUFrQixDQUFDLHFCQUFxQixDQWlFbkYsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCx3QkFBZ0IsZ0JBQWdCLElBQUkscUJBQXFCLENBRXhEIn0=
+export declare function getProverEnvVars(): ValidatorClientConfig & Pick<SequencerConfig, 'blockDurationMs'>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxLQUFLLGtCQUFrQixFQU94QixNQUFNLDBCQUEwQixDQUFDO0FBRWxDLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBaUMsTUFBTSxzQkFBc0IsQ0FBQztBQUUzRixPQUFPLEtBQUssRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRTdFLFlBQVksRUFBRSxxQkFBcUIsRUFBRSxDQUFDO0FBRXRDOzs7R0FHRztBQUNILGVBQU8sTUFBTSxxQ0FBcUMsTUFBTSxDQUFDO0FBRXpELGVBQU8sTUFBTSw2QkFBNkIsRUFBRSxrQkFBa0IsQ0FDNUQscUJBQXFCLEdBQUcsSUFBSSxDQUFDLGVBQWUsRUFBRSxpQkFBaUIsQ0FBQyxDQStGakUsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCx3QkFBZ0IsZ0JBQWdCLElBQUkscUJBQXFCLEdBQUcsSUFBSSxDQUFDLGVBQWUsRUFBRSxpQkFBaUIsQ0FBQyxDQUluRyJ9

package/dest/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAG7E,YAAY,EAAE,qBAAqB,EAAE,CAAC;AAEtC,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAAC,qBAAqB,CAiEnF,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAOxB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,KAAK,eAAe,EAAiC,MAAM,sBAAsB,CAAC;AAE3F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E,YAAY,EAAE,qBAAqB,EAAE,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,qCAAqC,MAAM,CAAC;AAEzD,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAC5D,qBAAqB,GAAG,IAAI,CAAC,eAAe,EAAE,iBAAiB,CAAC,CA+FjE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,GAAG,IAAI,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAInG"}