feat(sequencer): redistribute checkpoint budget evenly across remaining blocks (#21378)

Update the per-block budgets so that, on every block, the limits are
further adjusted to `remainingCheckpointBudget / remainingBlocks *
multiplier`. This prevents the last blocks from starvation. Also adjusts
the multiplier from 2x to 1.2x.

## Visualization

Using the
https://github.com/AztecProtocol/explorations/tree/main/block-distribution-simulator

### Before this PR

No redistribution, 2x multiplier

<img width="1544" height="737" alt="Screenshot From 2026-03-11 15-50-38"
src="https://github.com/user-attachments/assets/fda36d04-5d9e-456a-9ced-4649fa58d724"
/>

### After this PR

Redistribution enabled, 1.2x multiplier

<img width="1544" height="737" alt="Screenshot From 2026-03-11 15-50-49"
src="https://github.com/user-attachments/assets/2bc196f3-77fa-47bf-9294-4eb4199f8f93"
/>

### With no multiplier

For comparison purposes only, note the lower gas utilization

<img width="1544" height="737" alt="Screenshot From 2026-03-11 15-50-59"
src="https://github.com/user-attachments/assets/0facbc36-65e3-446e-abaf-eb7f637b87c9"
/>

## Summary

- Adds `SEQ_REDISTRIBUTE_CHECKPOINT_BUDGET` (default: true) to
distribute remaining checkpoint budget evenly across remaining blocks
instead of letting one block consume it all. Fair share per block is
`ceil(remainingBudget / remainingBlocks * multiplier)`, applied to all
four dimensions (L2 gas, DA gas, blob fields, tx count).
- Changes default `perBlockAllocationMultiplier` from 2 to 1.2 for
smoother distribution.
- Wires `maxBlocksPerCheckpoint` from the timetable through to the
checkpoint builder config.

## Test plan

- Existing `capLimitsByCheckpointBudgets` tests pass with
`redistributeCheckpointBudget: false` (old behavior)
- New tests cover: even split with multiplier=1, fair share with
multiplier=1.2, last block gets all remaining, disabled flag falls back
to old behavior, DA gas and tx count redistribution
- `computeBlockLimits` tests updated for new default multiplier and
`maxBlocksPerCheckpoint` return value

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: spalladino

yarn-project/foundation/src/config/env_var.ts

@@ -211,6 +211,7 @@ export type EnvVar =
   | 'SEQ_MAX_DA_BLOCK_GAS'
   | 'SEQ_MAX_L2_BLOCK_GAS'
   | 'SEQ_PER_BLOCK_ALLOCATION_MULTIPLIER'
+  | 'SEQ_REDISTRIBUTE_CHECKPOINT_BUDGET'
   | 'SEQ_PUBLISHER_PRIVATE_KEY'
   | 'SEQ_PUBLISHER_PRIVATE_KEYS'
   | 'SEQ_PUBLISHER_ADDRESSES'

yarn-project/sequencer-client/src/client/sequencer-client.test.ts

@@ -22,8 +22,8 @@ describe('computeBlockLimits', () => {
   describe('L2 gas', () => {
     it('derives maxL2BlockGas from rollupManaLimit when not explicitly set', () => {
       const rollupManaLimit = 1_000_000;
-      // Single block mode (maxNumberOfBlocks=1), default multiplier=2:
-      // min(1_000_000, ceil(1_000_000 / 1 * 2)) = min(1_000_000, 2_000_000) = 1_000_000
+      // Single block mode (maxNumberOfBlocks=1), default multiplier=1.2:
+      // min(1_000_000, ceil(1_000_000 / 1 * 1.2)) = min(1_000_000, 1_200_000) = 1_000_000
       const result = computeBlockLimits(makeConfig(), rollupManaLimit, 12, log);
       expect(result.maxL2BlockGas).toBe(rollupManaLimit);
     });
@@ -43,8 +43,8 @@ describe('computeBlockLimits', () => {
     const daLimit = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
 
     it('derives maxDABlockGas from DA checkpoint limit when not explicitly set', () => {
-      // Single block mode (maxNumberOfBlocks=1), default multiplier=2:
-      // min(daLimit, ceil(daLimit / 1 * 2)) = min(daLimit, daLimit * 2) = daLimit
+      // Single block mode (maxNumberOfBlocks=1), default multiplier=1.2:
+      // min(daLimit, ceil(daLimit / 1 * 1.2)) = min(daLimit, daLimit * 1.2) = daLimit
       const result = computeBlockLimits(makeConfig(), 1_000_000, 12, log);
       expect(result.maxDABlockGas).toBe(daLimit);
     });
@@ -78,14 +78,14 @@ describe('computeBlockLimits', () => {
     });
 
     it('derives maxTxsPerBlock from maxTxsPerCheckpoint when per-block not set', () => {
-      // Multi-block mode with maxNumberOfBlocks=5, multiplier=2:
-      // min(100, ceil(100 / 5 * 2)) = min(100, 40) = 40
+      // Multi-block mode with maxNumberOfBlocks=5, multiplier=1.2:
+      // min(100, ceil(100 / 5 * 1.2)) = min(100, 24) = 24
       const config = makeConfig({
         maxTxsPerCheckpoint: 100,
         blockDurationMs: 8000,
       });
       const result = computeBlockLimits(config, 1_000_000, 12, log);
-      expect(result.maxTxsPerBlock).toBe(40);
+      expect(result.maxTxsPerBlock).toBe(24);
     });
   });
 
@@ -97,14 +97,20 @@ describe('computeBlockLimits', () => {
       //   timeReservedAtEnd = 8 + 19 = 27
       //   timeAvailableForBlocks = 72 - 1 - 27 = 44
       //   maxNumberOfBlocks = floor(44 / 8) = 5
-      // With multiplier=2 and rollupManaLimit=1_000_000:
-      //   maxL2BlockGas = min(1_000_000, ceil(1_000_000 / 5 * 2)) = min(1_000_000, 400_000) = 400_000
+      // With multiplier=1.2 and rollupManaLimit=1_000_000:
+      //   maxL2BlockGas = min(1_000_000, ceil(1_000_000 / 5 * 1.2)) = min(1_000_000, 240_000) = 240_000
       const config = makeConfig({ blockDurationMs: 8000 });
       const result = computeBlockLimits(config, 1_000_000, 12, log);
-      expect(result.maxL2BlockGas).toBe(400_000);
+      expect(result.maxL2BlockGas).toBe(240_000);
 
       const daLimit = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
-      expect(result.maxDABlockGas).toBe(Math.min(daLimit, Math.ceil((daLimit / 5) * 2)));
+      expect(result.maxDABlockGas).toBe(Math.min(daLimit, Math.ceil((daLimit / 5) * 1.2)));
+    });
+
+    it('returns maxBlocksPerCheckpoint from timetable', () => {
+      const config = makeConfig({ blockDurationMs: 8000 });
+      const result = computeBlockLimits(config, 1_000_000, 12, log);
+      expect(result.maxBlocksPerCheckpoint).toBe(5);
     });
   });
 });

yarn-project/sequencer-client/src/client/sequencer-client.ts

@@ -160,7 +160,7 @@ export class SequencerClient {
     const l1PublishingTimeBasedOnChain = isAnvilTestChain(config.l1ChainId) ? 1 : ethereumSlotDuration;
     const l1PublishingTime = config.l1PublishingTime ?? l1PublishingTimeBasedOnChain;
 
-    const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock } = computeBlockLimits(
+    const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock, maxBlocksPerCheckpoint } = computeBlockLimits(
       config,
       rollupManaLimit,
       l1PublishingTime,
@@ -183,7 +183,7 @@ export class SequencerClient {
       deps.dateProvider,
       epochCache,
       rollupContract,
-      { ...config, l1PublishingTime, maxL2BlockGas, maxDABlockGas, maxTxsPerBlock },
+      { ...config, l1PublishingTime, maxL2BlockGas, maxDABlockGas, maxTxsPerBlock, maxBlocksPerCheckpoint },
       telemetryClient,
       log,
     );
@@ -257,7 +257,7 @@ export function computeBlockLimits(
   rollupManaLimit: number,
   l1PublishingTime: number,
   log: ReturnType<typeof createLogger>,
-): { maxL2BlockGas: number; maxDABlockGas: number; maxTxsPerBlock: number } {
+): { maxL2BlockGas: number; maxDABlockGas: number; maxTxsPerBlock: number; maxBlocksPerCheckpoint: number } {
   const maxNumberOfBlocks = new SequencerTimetable({
     ethereumSlotDuration: config.ethereumSlotDuration,
     aztecSlotDuration: config.aztecSlotDuration,
@@ -331,5 +331,5 @@ export function computeBlockLimits(
     multiplier,
   });
 
-  return { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock };
+  return { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock, maxBlocksPerCheckpoint: maxNumberOfBlocks };
 }

yarn-project/sequencer-client/src/config.ts

@@ -40,7 +40,8 @@ export const DefaultSequencerConfig = {
   minTxsPerBlock: 1,
   buildCheckpointIfEmpty: false,
   publishTxsWithProposals: false,
-  perBlockAllocationMultiplier: 2,
+  perBlockAllocationMultiplier: 1.2,
+  redistributeCheckpointBudget: true,
   enforceTimeTable: true,
   attestationPropagationTime: DEFAULT_P2P_PROPAGATION_TIME,
   secondsBeforeInvalidatingBlockAsCommitteeMember: 144, // 12 L1 blocks
@@ -112,6 +113,15 @@ export const sequencerConfigMappings: ConfigMappingsType<SequencerConfig> = {
       ' Values greater than one allow early blocks to use more than their even share, relying on checkpoint-level capping for later blocks.',
     ...numberConfigHelper(DefaultSequencerConfig.perBlockAllocationMultiplier),
   },
+  redistributeCheckpointBudget: {
+    env: 'SEQ_REDISTRIBUTE_CHECKPOINT_BUDGET',
+    description:
+      'Redistribute remaining checkpoint budget evenly across remaining blocks instead of allowing a single block to consume the entire remaining budget.',
+    ...booleanConfigHelper(DefaultSequencerConfig.redistributeCheckpointBudget),
+  },
+  maxBlocksPerCheckpoint: {
+    description: 'Computed max number of blocks per checkpoint from timetable.',
+  },
   coinbase: {
     env: 'COINBASE',
     parseEnv: (val: string) => (val ? EthAddress.fromString(val) : undefined),

yarn-project/stdlib/src/interfaces/block-builder.ts

@@ -64,6 +64,9 @@ export type FullNodeBlockBuilderConfig = Pick<L1RollupConstants, 'l1GenesisTime'
     | 'maxTxsPerCheckpoint'
     | 'maxL2BlockGas'
     | 'maxDABlockGas'
+    | 'redistributeCheckpointBudget'
+    | 'perBlockAllocationMultiplier'
+    | 'maxBlocksPerCheckpoint'
   >;
 
 export const FullNodeBlockBuilderConfigKeys: (keyof FullNodeBlockBuilderConfig)[] = [
@@ -79,6 +82,9 @@ export const FullNodeBlockBuilderConfigKeys: (keyof FullNodeBlockBuilderConfig)[
   'maxL2BlockGas',
   'maxDABlockGas',
   'rollupManaLimit',
+  'redistributeCheckpointBudget',
+  'perBlockAllocationMultiplier',
+  'maxBlocksPerCheckpoint',
 ] as const;
 
 /** Thrown when no valid transactions are available to include in a block after processing, and this is not the first block in a checkpoint. */

yarn-project/stdlib/src/interfaces/configs.ts

@@ -27,6 +27,10 @@ export interface SequencerConfig {
   maxDABlockGas?: number;
   /** Per-block gas budget multiplier for both L2 and DA gas. Budget = (checkpointLimit / maxBlocks) * multiplier. */
   perBlockAllocationMultiplier?: number;
+  /** Redistribute remaining checkpoint budget evenly across remaining blocks instead of allowing a single block to consume the entire remaining budget. */
+  redistributeCheckpointBudget?: boolean;
+  /** Computed max number of blocks per checkpoint from timetable. */
+  maxBlocksPerCheckpoint?: number;
   /** Recipient of block reward. */
   coinbase?: EthAddress;
   /** Address to receive fees. */
@@ -94,6 +98,8 @@ export const SequencerConfigSchema = zodFor<SequencerConfig>()(
     publishTxsWithProposals: z.boolean().optional(),
     maxDABlockGas: z.number().optional(),
     perBlockAllocationMultiplier: z.number().optional(),
+    redistributeCheckpointBudget: z.boolean().optional(),
+    maxBlocksPerCheckpoint: z.number().optional(),
     coinbase: schemas.EthAddress.optional(),
     feeRecipient: schemas.AztecAddress.optional(),
     acvmWorkingDirectory: z.string().optional(),
@@ -142,7 +148,9 @@ type SequencerConfigOptionalKeys =
   | 'maxTxsPerCheckpoint'
   | 'maxL2BlockGas'
   | 'maxDABlockGas'
-  | 'perBlockAllocationMultiplier';
+  | 'perBlockAllocationMultiplier'
+  | 'redistributeCheckpointBudget'
+  | 'maxBlocksPerCheckpoint';
 
 export type ResolvedSequencerConfig = Prettify<
   Required<Omit<SequencerConfig, SequencerConfigOptionalKeys>> & Pick<SequencerConfig, SequencerConfigOptionalKeys>

yarn-project/validator-client/README.md

@@ -239,11 +239,11 @@ L1 enforces gas and blob capacity per checkpoint. The node enforces these during
 
 Per-block budgets prevent one block from consuming the entire checkpoint budget.
 
-**Proposer**: `computeBlockLimits()` derives budgets at startup as `min(checkpointLimit, ceil(checkpointLimit / maxBlocks * multiplier))`, where `maxBlocks` comes from the timetable and `multiplier` defaults to 2. The multiplier greater than 1 allows early blocks to use more than their even share of the checkpoint budget, since different blocks hit different limit dimensions (L2 gas, DA gas, blob fields) — a strict even split would waste capacity. Operators can override via `SEQ_MAX_L2_BLOCK_GAS` / `SEQ_MAX_DA_BLOCK_GAS` / `SEQ_MAX_TX_PER_BLOCK` (capped at checkpoint limits). Per-block TX limits follow the same derivation pattern when `SEQ_MAX_TX_PER_CHECKPOINT` is set.
+**Proposer**: `computeBlockLimits()` derives budgets at startup as `min(checkpointLimit, ceil(checkpointLimit / maxBlocks * multiplier))`, where `maxBlocks` comes from the timetable and `multiplier` defaults to 1.2. The multiplier greater than 1 allows early blocks to use more than their even share of the checkpoint budget, since different blocks hit different limit dimensions (L2 gas, DA gas, blob fields) — a strict even split would waste capacity. Operators can override via `SEQ_MAX_L2_BLOCK_GAS` / `SEQ_MAX_DA_BLOCK_GAS` / `SEQ_MAX_TX_PER_BLOCK` (capped at checkpoint limits). Per-block TX limits follow the same derivation pattern when `SEQ_MAX_TX_PER_CHECKPOINT` is set.
 
 **Validator**: Optionally enforces per-block limits via `VALIDATOR_MAX_L2_BLOCK_GAS`, `VALIDATOR_MAX_DA_BLOCK_GAS`, and `VALIDATOR_MAX_TX_PER_BLOCK`. When set, these are passed to `buildBlock` during re-execution and to `validateCheckpoint` for final validation. When unset, no per-block limit is enforced for that dimension (checkpoint-level protocol limits still apply). These are independent of the `SEQ_` vars so operators can tune proposer and validation limits separately.
 
-**Checkpoint-level capping**: `CheckpointBuilder.capLimitsByCheckpointBudgets()` always runs before tx processing, capping per-block limits by `checkpointBudget - sum(used by prior blocks)` for all three gas dimensions and for transaction count (when `SEQ_MAX_TX_PER_CHECKPOINT` is set). This applies to both proposer and validator paths.
+**Checkpoint-level capping**: `CheckpointBuilder.capLimitsByCheckpointBudgets()` always runs before tx processing, capping per-block limits by the remaining checkpoint budget. When `SEQ_REDISTRIBUTE_CHECKPOINT_BUDGET` is enabled (default: true), the remaining budget is distributed evenly across remaining blocks with the multiplier applied: `min(perBlockLimit, ceil(remainingBudget / remainingBlocks * multiplier), remainingBudget)`. This prevents early blocks from consuming the entire checkpoint budget, producing smoother distribution. When disabled, each block can consume up to the full remaining budget, ie caps by `checkpointBudget - sum(used by prior blocks)`. This applies to all four dimensions (L2 gas, DA gas, blob fields, transaction count). Validators always cap by the total remaining.
 
 ### Per-transaction enforcement
 
@@ -259,7 +259,8 @@ Per-block budgets prevent one block from consuming the entire checkpoint budget.
 | `SEQ_MAX_DA_BLOCK_GAS` | *auto* | Per-block DA gas. Auto-derived from checkpoint DA limit / maxBlocks * multiplier. |
 | `SEQ_MAX_TX_PER_BLOCK` | *none* | Per-block tx count. If `SEQ_MAX_TX_PER_CHECKPOINT` is set and per-block is not, derived as `ceil(checkpointLimit / maxBlocks * multiplier)`. |
 | `SEQ_MAX_TX_PER_CHECKPOINT` | *none* | Total txs across all blocks in a checkpoint. When set, per-block tx limit is derived from it (unless explicitly overridden) and checkpoint-level capping is enforced. |
-| `SEQ_PER_BLOCK_ALLOCATION_MULTIPLIER` | 2 | Multiplier for per-block budget computation. |
+| `SEQ_PER_BLOCK_ALLOCATION_MULTIPLIER` | 1.2 | Multiplier for per-block budget computation. |
+| `SEQ_REDISTRIBUTE_CHECKPOINT_BUDGET` | true | Redistribute remaining checkpoint budget evenly across remaining blocks instead of allowing one block to consume it all. |
 | `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. |

yarn-project/validator-client/src/checkpoint_builder.test.ts

@@ -85,6 +85,7 @@ describe('CheckpointBuilder', () => {
       l1ChainId: 1,
       rollupVersion: 1,
       rollupManaLimit: 200_000_000,
+      redistributeCheckpointBudget: false,
       ...overrideConfig,
     };
 
@@ -416,4 +417,127 @@ describe('CheckpointBuilder', () => {
       expect(capped.maxTransactions).toBeUndefined();
     });
   });
+
+  describe('redistributeCheckpointBudget', () => {
+    it('evenly splits budget with multiplier=1', () => {
+      const rollupManaLimit = 1_000_000;
+      setupBuilder({
+        redistributeCheckpointBudget: true,
+        perBlockAllocationMultiplier: 1,
+        maxBlocksPerCheckpoint: 5,
+        rollupManaLimit,
+      });
+
+      lightweightCheckpointBuilder.getBlocks.mockReturnValue([]);
+
+      const opts: PublicProcessorLimits = {};
+      const capped = (checkpointBuilder as TestCheckpointBuilder).testCapLimits(opts);
+
+      // Fair share = ceil(1_000_000 / 5 * 1) = 200_000
+      expect(capped.maxBlockGas!.l2Gas).toBe(200_000);
+    });
+
+    it('computes fair share with multiplier=1.2, 5 max blocks, 2 existing', () => {
+      const rollupManaLimit = 1_000_000;
+      setupBuilder({
+        redistributeCheckpointBudget: true,
+        perBlockAllocationMultiplier: 1.2,
+        maxBlocksPerCheckpoint: 5,
+        rollupManaLimit,
+      });
+
+      // 2 existing blocks used 400_000 mana total
+      lightweightCheckpointBuilder.getBlocks.mockReturnValue([
+        createMockBlock({ manaUsed: 200_000, txBlobFields: [10], blockBlobFieldCount: 20 }),
+        createMockBlock({ manaUsed: 200_000, txBlobFields: [10], blockBlobFieldCount: 20 }),
+      ]);
+
+      const opts: PublicProcessorLimits = {};
+      const capped = (checkpointBuilder as TestCheckpointBuilder).testCapLimits(opts);
+
+      // remainingMana = 600_000, remainingBlocks = 3, multiplier = 1.2
+      // fairShare = ceil(600_000 / 3 * 1.2) = ceil(240_000) = 240_000
+      expect(capped.maxBlockGas!.l2Gas).toBe(240_000);
+    });
+
+    it('gives all remaining budget to last block (remainingBlocks=1)', () => {
+      const rollupManaLimit = 1_000_000;
+      setupBuilder({
+        redistributeCheckpointBudget: true,
+        perBlockAllocationMultiplier: 1.2,
+        maxBlocksPerCheckpoint: 3,
+        rollupManaLimit,
+      });
+
+      // 2 existing blocks used 800_000 total
+      lightweightCheckpointBuilder.getBlocks.mockReturnValue([
+        createMockBlock({ manaUsed: 400_000, txBlobFields: [10], blockBlobFieldCount: 20 }),
+        createMockBlock({ manaUsed: 400_000, txBlobFields: [10], blockBlobFieldCount: 20 }),
+      ]);
+
+      const opts: PublicProcessorLimits = {};
+      const capped = (checkpointBuilder as TestCheckpointBuilder).testCapLimits(opts);
+
+      // remainingMana = 200_000, remainingBlocks = 1, multiplier = 1.2
+      // fairShare = ceil(200_000 / 1 * 1.2) = 240_000. min(200_000, 240_000, 200_000) = 200_000
+      expect(capped.maxBlockGas!.l2Gas).toBe(200_000);
+    });
+
+    it('uses old behavior when redistributeCheckpointBudget is false', () => {
+      const rollupManaLimit = 1_000_000;
+      setupBuilder({
+        redistributeCheckpointBudget: false,
+        maxBlocksPerCheckpoint: 5,
+        rollupManaLimit,
+      });
+
+      lightweightCheckpointBuilder.getBlocks.mockReturnValue([
+        createMockBlock({ manaUsed: 200_000, txBlobFields: [10], blockBlobFieldCount: 20 }),
+      ]);
+
+      const opts: PublicProcessorLimits = {};
+      const capped = (checkpointBuilder as TestCheckpointBuilder).testCapLimits(opts);
+
+      // Old behavior: no fair share, just remaining budget = 800_000
+      expect(capped.maxBlockGas!.l2Gas).toBe(800_000);
+    });
+
+    it('redistributes DA gas across remaining blocks', () => {
+      setupBuilder({
+        redistributeCheckpointBudget: true,
+        perBlockAllocationMultiplier: 1,
+        maxBlocksPerCheckpoint: 4,
+      });
+
+      lightweightCheckpointBuilder.getBlocks.mockReturnValue([]);
+
+      const opts: PublicProcessorLimits = {};
+      const capped = (checkpointBuilder as TestCheckpointBuilder).testCapLimits(opts);
+
+      // fairShareDA = ceil(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT / 4 * 1)
+      const expectedDA = Math.ceil(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT / 4);
+      expect(capped.maxBlockGas!.daGas).toBe(expectedDA);
+    });
+
+    it('redistributes tx count across remaining blocks', () => {
+      setupBuilder({
+        redistributeCheckpointBudget: true,
+        perBlockAllocationMultiplier: 1,
+        maxBlocksPerCheckpoint: 4,
+        maxTxsPerCheckpoint: 100,
+      });
+
+      // 1 existing block with 10 txs
+      lightweightCheckpointBuilder.getBlocks.mockReturnValue([
+        createMockBlock({ manaUsed: 0, txBlobFields: new Array(10).fill(1), blockBlobFieldCount: 20 }),
+      ]);
+
+      const opts: PublicProcessorLimits = {};
+      const capped = (checkpointBuilder as TestCheckpointBuilder).testCapLimits(opts);
+
+      // remainingTxs = 90, remainingBlocks = 3, multiplier = 1
+      // fairShareTxs = ceil(90 / 3 * 1) = 30
+      expect(capped.maxTransactions).toBe(30);
+    });
+  });
 });