@aztec/stdlib 0.0.1-commit.96bb3f7 → 0.0.1-commit.96dac018d

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -4,9 +4,12 @@ import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 
 import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
-import { type L2BlockId, type L2BlockPruneReason, type L2BlockSource, makeL2BlockId } from '../l2_block_source.js';
+import { type L2BlockId, type L2BlockSource, makeL2BlockId } from '../l2_block_source.js';
 import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider } from './interfaces.js';
 
+/** Maximum number of checkpoints to prefetch at once during sync. Matches MAX_RPC_CHECKPOINTS_LEN. */
+export const CHECKPOINT_PREFETCH_LIMIT = 50;
+
 /** Creates a stream of events for new blocks, chain tips updates, and reorgs, out of polling an archiver or a node. */
 export class L2BlockStream {
   private readonly runningPromise: RunningPromise;
@@ -16,13 +19,12 @@ export class L2BlockStream {
   constructor(
     private l2BlockSource: Pick<
       L2BlockSource,
-      'getL2BlocksNew' | 'getBlockHeader' | 'getL2Tips' | 'getPublishedCheckpoints' | 'getCheckpointedBlocks'
+      'getBlocks' | 'getBlockHeader' | 'getL2Tips' | 'getCheckpoints' | 'getCheckpointedBlocks'
     >,
     private localData: L2BlockStreamLocalDataProvider,
     private handler: L2BlockStreamEventHandler,
     private readonly log = createLogger('types:block_stream'),
     private opts: {
-      proven?: boolean;
       pollIntervalMS?: number;
       batchSize?: number;
       startingBlock?: number;
@@ -30,6 +32,8 @@ export class L2BlockStream {
       skipFinalized?: boolean;
       /** When true, checkpoint events will not be emitted. Blocks are still fetched via checkpoints but only blocks-added events are emitted. */
       ignoreCheckpoints?: boolean;
+      /** Maximum number of checkpoints to prefetch at once during sync. Defaults to CHECKPOINT_PREFETCH_LIMIT (50). */
+      checkpointPrefetchLimit?: number;
     } = {},
   ) {
     // Note that RunningPromise is in stopped state by default. This promise won't run until someone invokes `start`,
@@ -85,18 +89,9 @@ export class L2BlockStream {
         this.log.verbose(
           `Reorg detected. Pruning blocks from ${latestBlockNumber + 1} to ${localTips.proposed.number}.`,
         );
-        // This check is not 100% accurate
-        // If the local tips are sufficiently behind the source tips, such that we are missing at least one checkpoint
-        // that has now been re-orged due to a proof failure then this will indicate a failure to checkpoint rather than a failure to prove
-        // TODO: (mbps/PhilWindle): Improve re-org detection accuracy when we come to do re-orgs
-        let reason: L2BlockPruneReason = 'unproven';
-        if (latestBlockNumber === localTips.checkpointed.block.number && !this.opts.ignoreCheckpoints) {
-          reason = 'uncheckpointed';
-        }
         await this.emitEvent({
           type: 'chain-pruned',
           block: makeL2BlockId(latestBlockNumber, hash),
-          reason,
           checkpoint: sourceTips.checkpointed.checkpoint,
         });
       }
@@ -133,7 +128,7 @@ export class L2BlockStream {
       if (!this.opts.ignoreCheckpoints) {
         let loop1Iterations = 0;
         while (nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number) {
-          const checkpoints = await this.l2BlockSource.getPublishedCheckpoints(nextCheckpointToEmit, 1);
+          const checkpoints = await this.l2BlockSource.getCheckpoints(nextCheckpointToEmit, 1);
           if (checkpoints.length === 0) {
             break;
           }
@@ -159,27 +154,36 @@ export class L2BlockStream {
         }
       }
 
-      // Loop 2: Fetch new checkpointed blocks. For each block, get its checkpoint, emit all blocks
+      // Loop 2: Fetch new checkpointed blocks. For each checkpoint, emit all blocks
       // from that checkpoint that we need, then emit the checkpoint event.
-      // We cache the current checkpoint to avoid redundant fetches when batchSize < checkpoint size.
-      let checkpoint: PublishedCheckpoint | undefined;
-      while (nextBlockNumber <= sourceTips.checkpointed.block.number) {
-        const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.checkpointed.block.number - nextBlockNumber + 1);
+      // We prefetch multiple checkpoints, then process them one by one.
+      let prefetchedCheckpoints: PublishedCheckpoint[] = [];
+      let prefetchIdx = 0;
+      let nextCheckpointNumber: CheckpointNumber | undefined;
 
-        // Check if we need to fetch a new checkpoint (nextBlockNumber is beyond the cached one)
-        if (!checkpoint || nextBlockNumber > checkpoint.checkpoint.blocks.at(-1)!.number) {
-          const blocks = await this.l2BlockSource.getCheckpointedBlocks(BlockNumber(nextBlockNumber), 1);
-          if (blocks.length === 0) {
-            break;
-          }
-          const checkpoints = await this.l2BlockSource.getPublishedCheckpoints(blocks[0].checkpointNumber, 1);
-          if (checkpoints.length === 0) {
+      // Find the starting checkpoint number
+      if (nextBlockNumber <= sourceTips.checkpointed.block.number) {
+        const blocks = await this.l2BlockSource.getCheckpointedBlocks(BlockNumber(nextBlockNumber), 1);
+        if (blocks.length > 0) {
+          nextCheckpointNumber = blocks[0].checkpointNumber;
+        }
+      }
+
+      while (nextBlockNumber <= sourceTips.checkpointed.block.number && nextCheckpointNumber !== undefined) {
+        // Refill the prefetch buffer when exhausted
+        if (prefetchIdx >= prefetchedCheckpoints.length) {
+          const prefetchLimit = this.opts.checkpointPrefetchLimit ?? CHECKPOINT_PREFETCH_LIMIT;
+          prefetchedCheckpoints = await this.l2BlockSource.getCheckpoints(nextCheckpointNumber, prefetchLimit);
+          prefetchIdx = 0;
+          if (prefetchedCheckpoints.length === 0) {
             break;
           }
-          checkpoint = checkpoints[0];
         }
 
+        const checkpoint = prefetchedCheckpoints[prefetchIdx]!;
+
         // Get all blocks from this checkpoint that we need, respecting batchSize
+        const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.checkpointed.block.number - nextBlockNumber + 1);
         const blocksForCheckpoint = checkpoint.checkpoint.blocks
           .filter(b => b.number >= nextBlockNumber)
           .slice(0, limit);
@@ -189,23 +193,27 @@ export class L2BlockStream {
         await this.emitEvent({ type: 'blocks-added', blocks: blocksForCheckpoint });
         nextBlockNumber = blocksForCheckpoint.at(-1)!.number + 1;
 
-        // If we've reached the end of this checkpoint, emit the checkpoint event
+        // If we've reached the end of this checkpoint, emit the checkpoint event and move to next
         const lastBlockInCheckpoint = checkpoint.checkpoint.blocks.at(-1)!;
-        if (!this.opts.ignoreCheckpoints && nextBlockNumber > lastBlockInCheckpoint.number) {
-          const lastBlockHash = await lastBlockInCheckpoint.hash();
-          await this.emitEvent({
-            type: 'chain-checkpointed',
-            checkpoint,
-            block: makeL2BlockId(lastBlockInCheckpoint.number, lastBlockHash.toString()),
-          });
+        if (nextBlockNumber > lastBlockInCheckpoint.number) {
+          if (!this.opts.ignoreCheckpoints) {
+            const lastBlockHash = await lastBlockInCheckpoint.hash();
+            await this.emitEvent({
+              type: 'chain-checkpointed',
+              checkpoint,
+              block: makeL2BlockId(lastBlockInCheckpoint.number, lastBlockHash.toString()),
+            });
+          }
+          prefetchIdx++;
+          nextCheckpointNumber = CheckpointNumber(nextCheckpointNumber + 1);
         }
       }
 
       // Loop 3: Fetch any remaining uncheckpointed (proposed) blocks.
       while (nextBlockNumber <= sourceTips.proposed.number) {
         const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.proposed.number - nextBlockNumber + 1);
-        this.log.trace(`Requesting blocks from ${nextBlockNumber} limit ${limit} proven=${this.opts.proven}`);
-        const blocks = await this.l2BlockSource.getL2BlocksNew(BlockNumber(nextBlockNumber), limit, this.opts.proven);
+        this.log.trace(`Requesting blocks from ${nextBlockNumber} limit ${limit}`);
+        const blocks = await this.l2BlockSource.getBlocks(BlockNumber(nextBlockNumber), BlockNumber(limit));
         if (blocks.length === 0) {
           break;
         }

package/src/block/l2_block_stream/l2_tips_store_base.ts

@@ -2,7 +2,7 @@ import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 
 import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
-import type { L2BlockNew } from '../l2_block_new.js';
+import type { L2Block } from '../l2_block.js';
 import {
   type CheckpointId,
   GENESIS_CHECKPOINT_HEADER_HASH,
@@ -109,7 +109,7 @@ export abstract class L2TipsStoreBase implements L2BlockStreamEventHandler, L2Bl
   }
 
   // Protected helper that subclasses can override for block hash computation
-  protected computeBlockHash(block: L2BlockNew): Promise<string> {
+  protected computeBlockHash(block: L2Block): Promise<string> {
     return block.hash().then(hash => hash.toString());
   }
 

package/src/block/test/l2_tips_store_test_suite.ts

@@ -5,8 +5,8 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import {
   type CheckpointId,
   GENESIS_CHECKPOINT_HEADER_HASH,
+  L2Block,
   type L2BlockId,
-  L2BlockNew,
   type L2TipId,
 } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
@@ -31,8 +31,8 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     blockToCheckpoint.clear();
   });
 
-  const makeBlock = async (number: number): Promise<L2BlockNew> => {
-    const block = await L2BlockNew.random(BlockNumber(number));
+  const makeBlock = async (number: number): Promise<L2Block> => {
+    const block = await L2Block.random(BlockNumber(number));
     blockHashes.set(number, (await block.hash()).toString());
     return block;
   };
@@ -74,7 +74,7 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     checkpointed: makeTipId(checkpointed),
   });
 
-  const makeCheckpoint = async (checkpointNumber: number, blocks: L2BlockNew[]): Promise<PublishedCheckpoint> => {
+  const makeCheckpoint = async (checkpointNumber: number, blocks: L2Block[]): Promise<PublishedCheckpoint> => {
     const checkpoint = await Checkpoint.random(CheckpointNumber(checkpointNumber), {
       numBlocks: blocks.length,
       startBlockNumber: blocks[0].number,
@@ -243,7 +243,6 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     await tipsStore.handleBlockStreamEvent({
       type: 'chain-pruned',
       block: makeBlockId(5),
-      reason: 'unproven',
       checkpoint: { number: CheckpointNumber.ZERO, hash: GENESIS_CHECKPOINT_HEADER_HASH.toString() },
     });
 
@@ -268,7 +267,6 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     await tipsStore.handleBlockStreamEvent({
       type: 'chain-pruned',
       block: makeTip(0),
-      reason: 'unproven',
       checkpoint: { number: CheckpointNumber.ZERO, hash: GENESIS_CHECKPOINT_HEADER_HASH.toString() },
     });
 
@@ -334,7 +332,6 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     await tipsStore.handleBlockStreamEvent({
       type: 'chain-pruned',
       block: makeBlockId(5),
-      reason: 'unproven',
       checkpoint: { number: CheckpointNumber.ZERO, hash: GENESIS_CHECKPOINT_HEADER_HASH.toString() },
     });
 
@@ -399,7 +396,6 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     await tipsStore.handleBlockStreamEvent({
       type: 'chain-pruned',
       block: makeBlockId(3),
-      reason: 'unproven',
       checkpoint: { number: CheckpointNumber.ZERO, hash: GENESIS_CHECKPOINT_HEADER_HASH.toString() },
     });
 
@@ -478,7 +474,6 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     await tipsStore.handleBlockStreamEvent({
       type: 'chain-pruned',
       block: makeBlockId(3),
-      reason: 'unproven',
       checkpoint: { number: CheckpointNumber.ZERO, hash: GENESIS_CHECKPOINT_HEADER_HASH.toString() },
     });
 

package/src/block/validate_block_result.ts

@@ -11,6 +11,7 @@ import {
   deserializeCheckpointInfo,
   serializeCheckpointInfo,
 } from '../checkpoint/checkpoint_info.js';
+import { MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 
 /** Subtype for invalid checkpoint validation results */
@@ -109,13 +110,13 @@ export function deserializeValidateCheckpointResult(bufferOrReader: Buffer | Buf
   if (valid) {
     return { valid };
   }
-  const reason = reader.readString() as 'insufficient-attestations' | 'invalid-attestation';
+  const reason = reader.readString(64) as 'insufficient-attestations' | 'invalid-attestation';
   const checkpoint = deserializeCheckpointInfo(reader.readBuffer());
-  const committee = reader.readVector(EthAddress);
+  const committee = reader.readVector(EthAddress, MAX_COMMITTEE_SIZE);
   const epoch = EpochNumber(reader.readNumber());
   const seed = reader.readBigInt();
-  const attestors = reader.readVector(EthAddress);
-  const attestations = reader.readVector(CommitteeAttestation);
+  const attestors = reader.readVector(EthAddress, MAX_COMMITTEE_SIZE);
+  const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
   const invalidIndex = reader.readNumber();
   if (reason === 'insufficient-attestations') {
     return { valid, reason, checkpoint, committee, epoch, seed, attestors, attestations };

package/src/checkpoint/checkpoint.ts

@@ -1,17 +1,28 @@
 import { encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
-import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import {
+  BlockNumber,
+  CheckpointNumber,
+  CheckpointNumberSchema,
+  IndexWithinCheckpoint,
+  SlotNumber,
+} from '@aztec/foundation/branded-types';
 import { sum } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeSignedBigInt, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { L2BlockNew } from '../block/l2_block_new.js';
+import { L2Block } from '../block/l2_block.js';
+import { MAX_BLOCKS_PER_CHECKPOINT } from '../deserialization/index.js';
+import { computeCheckpointOutHash } from '../messaging/out_hash.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { schemas } from '../schemas/schemas.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import type { CheckpointInfo } from './checkpoint_info.js';
 
+type FieldsOfCheckpoint = Omit<FieldsOf<Checkpoint>, 'slot'>;
+
 export class Checkpoint {
   constructor(
     /** Snapshot of archive tree after the checkpoint is added. */
@@ -19,42 +30,59 @@ export class Checkpoint {
     /** Header of the checkpoint. */
     public header: CheckpointHeader,
     /** L2 blocks in the checkpoint. */
-    public blocks: L2BlockNew[],
+    public blocks: L2Block[],
     /** Number of the checkpoint. */
     public number: CheckpointNumber,
+    /** Fee asset price modifier in basis points (from oracle). Defaults to 0 (no change). */
+    public feeAssetPriceModifier: bigint = 0n,
   ) {}
 
+  get slot(): SlotNumber {
+    return this.header.slotNumber;
+  }
+
   static get schema() {
     return z
       .object({
         archive: AppendOnlyTreeSnapshot.schema,
         header: CheckpointHeader.schema,
-        blocks: z.array(L2BlockNew.schema),
+        blocks: z.array(L2Block.schema),
         number: CheckpointNumberSchema,
+        feeAssetPriceModifier: schemas.BigInt,
       })
-      .transform(({ archive, header, blocks, number }) => new Checkpoint(archive, header, blocks, number));
+      .transform(
+        ({ archive, header, blocks, number, feeAssetPriceModifier }) =>
+          new Checkpoint(archive, header, blocks, number, feeAssetPriceModifier),
+      );
   }
 
-  static from(fields: FieldsOf<Checkpoint>) {
+  static from(fields: FieldsOfCheckpoint) {
     return new Checkpoint(...Checkpoint.getFields(fields));
   }
 
-  static getFields(fields: FieldsOf<Checkpoint>) {
-    return [fields.archive, fields.header, fields.blocks, fields.number] as const;
+  static getFields(fields: FieldsOfCheckpoint) {
+    return [fields.archive, fields.header, fields.blocks, fields.number, fields.feeAssetPriceModifier] as const;
   }
 
   static fromBuffer(buf: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buf);
-    return new Checkpoint(
-      reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readObject(CheckpointHeader),
-      reader.readVector(L2BlockNew),
-      CheckpointNumber(reader.readNumber()),
-    );
+    const archive = reader.readObject(AppendOnlyTreeSnapshot);
+    const header = reader.readObject(CheckpointHeader);
+    const blocks = reader.readVector(L2Block, MAX_BLOCKS_PER_CHECKPOINT);
+    const number = CheckpointNumber(reader.readNumber());
+    const feeAssetPriceModifier = reader.readInt256();
+    return new Checkpoint(archive, header, blocks, number, feeAssetPriceModifier);
   }
 
   public toBuffer() {
-    return serializeToBuffer(this.archive, this.header, this.blocks.length, this.blocks, this.number);
+    return serializeToBuffer(
+      this.archive,
+      this.header,
+      this.blocks.length,
+      this.blocks,
+      this.number,
+      serializeSignedBigInt(this.feeAssetPriceModifier),
+    );
   }
 
   public toBlobFields(): Fr[] {
@@ -66,6 +94,16 @@ export class Checkpoint {
     return this.header.hash();
   }
 
+  /**
+   * Returns the out hash computed from all l2-to-l1 messages in this checkpoint.
+   * Note: This value is different from the out hash in the header, which is the **accumulated** out hash over all
+   * checkpoints up to and including this one in the epoch.
+   */
+  public getCheckpointOutHash(): Fr {
+    const msgs = this.blocks.map(block => block.body.txEffects.map(txEffect => txEffect.l2ToL1Msgs));
+    return computeCheckpointOutHash(msgs);
+  }
+
   public getState() {
     return this.blocks.at(-1)!.header.state;
   }
@@ -107,23 +145,25 @@ export class Checkpoint {
       numBlocks = 1,
       startBlockNumber = 1,
       previousArchive,
+      feeAssetPriceModifier = 0n,
       ...options
     }: {
       numBlocks?: number;
       startBlockNumber?: number;
       previousArchive?: AppendOnlyTreeSnapshot;
+      feeAssetPriceModifier?: bigint;
     } & Partial<Parameters<typeof CheckpointHeader.random>[0]> &
-      Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
+      Partial<Parameters<typeof L2Block.random>[1]> = {},
   ) {
     const header = CheckpointHeader.random(options);
 
     // Create blocks sequentially to chain archive roots properly.
     // Each block's header.lastArchive must equal the previous block's archive.
-    const blocks: L2BlockNew[] = [];
+    const blocks: L2Block[] = [];
     let lastArchive = previousArchive;
     for (let i = 0; i < numBlocks; i++) {
-      const block = await L2BlockNew.random(BlockNumber(startBlockNumber + i), {
-        indexWithinCheckpoint: i,
+      const block = await L2Block.random(BlockNumber(startBlockNumber + i), {
+        indexWithinCheckpoint: IndexWithinCheckpoint(i),
         ...options,
         ...(lastArchive ? { lastArchive } : {}),
       });
@@ -131,6 +171,6 @@ export class Checkpoint {
       blocks.push(block);
     }
 
-    return new Checkpoint(AppendOnlyTreeSnapshot.random(), header, blocks, checkpointNumber);
+    return new Checkpoint(AppendOnlyTreeSnapshot.random(), header, blocks, checkpointNumber, feeAssetPriceModifier);
   }
 }

package/src/checkpoint/checkpoint_data.ts

@@ -0,0 +1,51 @@
+import {
+  BlockNumber,
+  BlockNumberSchema,
+  CheckpointNumber,
+  CheckpointNumberSchema,
+} from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { L1PublishedData } from './published_checkpoint.js';
+
+/** Lightweight checkpoint metadata without full block data. */
+export type CheckpointData = {
+  checkpointNumber: CheckpointNumber;
+  header: CheckpointHeader;
+  archive: AppendOnlyTreeSnapshot;
+  checkpointOutHash: Fr;
+  startBlock: BlockNumber;
+  blockCount: number;
+  attestations: CommitteeAttestation[];
+  l1: L1PublishedData;
+};
+
+export const CheckpointDataSchema = z
+  .object({
+    checkpointNumber: CheckpointNumberSchema,
+    header: CheckpointHeader.schema,
+    archive: AppendOnlyTreeSnapshot.schema,
+    checkpointOutHash: schemas.Fr,
+    startBlock: BlockNumberSchema,
+    blockCount: schemas.Integer,
+    attestations: z.array(CommitteeAttestation.schema),
+    l1: L1PublishedData.schema,
+  })
+  .transform(
+    (obj): CheckpointData => ({
+      checkpointNumber: obj.checkpointNumber,
+      header: obj.header,
+      archive: obj.archive,
+      checkpointOutHash: obj.checkpointOutHash,
+      startBlock: obj.startBlock,
+      blockCount: obj.blockCount,
+      attestations: obj.attestations,
+      l1: obj.l1,
+    }),
+  );

package/src/checkpoint/index.ts

@@ -1,3 +1,4 @@
 export * from './checkpoint.js';
+export * from './checkpoint_data.js';
 export * from './checkpoint_info.js';
 export * from './published_checkpoint.js';

package/src/checkpoint/published_checkpoint.ts

@@ -8,6 +8,7 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { z } from 'zod';
 
 import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
 import { Checkpoint } from './checkpoint.js';
 
 export class L1PublishedData {
@@ -42,7 +43,7 @@ export class L1PublishedData {
   static fromBuffer(bufferOrReader: Buffer | BufferReader): L1PublishedData {
     const reader = BufferReader.asReader(bufferOrReader);
     const l1BlockNumber = reader.readBigInt();
-    const l1BlockHash = reader.readString();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
     const l1Timestamp = reader.readBigInt();
     return new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash);
   }
@@ -54,9 +55,11 @@ export class L1PublishedData {
 
 export class PublishedCheckpoint {
   constructor(
+    /** The checkpoint itself. */
     public checkpoint: Checkpoint,
+    /** Info on when this checkpoint was published on L1. */
     public l1: L1PublishedData,
-    // The attestations for the last block in the checkpoint.
+    /** The attestations for the last block in the checkpoint. */
     public attestations: CommitteeAttestation[],
   ) {}
 
@@ -82,9 +85,9 @@ export class PublishedCheckpoint {
     const reader = BufferReader.asReader(bufferOrReader);
     const checkpoint = reader.readObject(Checkpoint);
     const l1BlockNumber = reader.readBigInt();
-    const l1BlockHash = reader.readString();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
     const l1Timestamp = reader.readBigInt();
-    const attestations = reader.readVector(CommitteeAttestation);
+    const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
     return new PublishedCheckpoint(
       checkpoint,
       new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),

package/src/config/index.ts

@@ -1,2 +1,3 @@
 export * from './chain-config.js';
 export * from './node-rpc-config.js';
+export * from './sequencer-config.js';

package/src/config/node-rpc-config.ts

@@ -21,7 +21,7 @@ export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
   rpcMaxBodySize: {
     env: 'RPC_MAX_BODY_SIZE',
     description: 'Maximum allowed batch size for JSON RPC batch requests.',
-    defaultValue: '50mb',
+    defaultValue: '1mb',
   },
 };
 

package/src/config/sequencer-config.ts

@@ -0,0 +1,29 @@
+import type { ConfigMappingsType } from '@aztec/foundation/config';
+
+import type { SequencerConfig } from '../interfaces/configs.js';
+
+/**
+ * Partial sequencer config mappings for fields that need to be shared across packages.
+ * The full sequencer config mappings remain in sequencer-client, but shared fields
+ * (like blockDurationMs needed by both p2p and sequencer-client) are defined here
+ * to avoid duplication.
+ */
+export const sharedSequencerConfigMappings: ConfigMappingsType<
+  Pick<SequencerConfig, 'blockDurationMs' | 'expectedBlockProposalsPerSlot'>
+> = {
+  blockDurationMs: {
+    env: 'SEQ_BLOCK_DURATION_MS',
+    description:
+      'Duration per block in milliseconds when building multiple blocks per slot. ' +
+      'If undefined (default), builds a single block per slot using the full slot duration.',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+  },
+  expectedBlockProposalsPerSlot: {
+    env: 'SEQ_EXPECTED_BLOCK_PROPOSALS_PER_SLOT',
+    description:
+      'Expected number of block proposals per slot for P2P peer scoring. ' +
+      '0 (default) disables block proposal scoring. Set to a positive value to enable.',
+    parseEnv: (val: string) => (val ? parseInt(val, 10) : 0),
+    defaultValue: 0,
+  },
+};

package/src/contract/contract_address.ts

@@ -1,4 +1,4 @@
-import { GeneratorIndex } from '@aztec/constants';
+import { DomainSeparator } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 
@@ -44,7 +44,7 @@ export async function computePartialAddress(
 
   return poseidon2HashWithSeparator(
     [instance.originalContractClassId, saltedInitializationHash],
-    GeneratorIndex.PARTIAL_ADDRESS,
+    DomainSeparator.PARTIAL_ADDRESS,
   );
 }
 
@@ -57,7 +57,7 @@ export function computeSaltedInitializationHash(
 ): Promise<Fr> {
   return poseidon2HashWithSeparator(
     [instance.salt, instance.initializationHash, instance.deployer],
-    GeneratorIndex.PARTIAL_ADDRESS,
+    DomainSeparator.PARTIAL_ADDRESS,
   );
 }
 
@@ -87,5 +87,5 @@ export async function computeInitializationHashFromEncodedArgs(
   encodedArgs: Fr[],
 ): Promise<Fr> {
   const argsHash = await computeVarArgsHash(encodedArgs);
-  return poseidon2HashWithSeparator([initFn, argsHash], GeneratorIndex.CONSTRUCTOR);
+  return poseidon2HashWithSeparator([initFn, argsHash], DomainSeparator.INITIALIZER);
 }

package/src/contract/contract_class.ts

@@ -8,7 +8,7 @@ import { type ContractClassIdPreimage, computeContractClassIdWithPreimage } from
 import type { ContractClass, ContractClassWithId } from './interfaces/index.js';
 
 /** Contract artifact including its artifact hash */
-type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
+export type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
 
 const cmpFunctionArtifacts = <T extends { selector: FunctionSelector }>(a: T, b: T) =>
   a.selector.toField().cmp(b.selector.toField());
@@ -35,8 +35,8 @@ export async function getContractClassFromArtifact(
 
   privateArtifactFunctions.sort(cmpFunctionArtifacts);
 
-  const contractClass: ContractClass = {
-    version: 1,
+  const contractClass = {
+    version: 1 as const,
     artifactHash,
     packedBytecode,
     privateFunctions: privateArtifactFunctions,