refactor: remove deprecated L2Block and L2BlockHeader

Author: spalladino

.claude/settings.local.json

@@ -0,0 +1,17 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git show:*)",
+      "Skill(ci-log-reader)",
+      "Bash(./ci.sh:*)",
+      "Bash(sort:*)",
+      "Bash(ls:*)",
+      "Bash(find:*)",
+      "Bash(./scripts/tsc.sh:*)",
+      "Bash(test:*)",
+      "Bash(./bootstrap.sh:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)"
+    ]
+  }
+}

yarn-project/archiver/L2BLOCK_MIGRATION_PLAN.md

@@ -0,0 +1,184 @@
+# L2Block to L2BlockNew Migration Plan
+
+## Overview
+
+The `L2Block` class is deprecated in favor of `L2BlockNew`. The key differences:
+
+- **L2Block**: Uses `L2BlockHeader` which combines block header + checkpoint-specific fields (blobsHash, inHash, epochOutHash, blockHeadersHash)
+- **L2BlockNew**: Uses pure `BlockHeader` without checkpoint-specific fields, plus `checkpointNumber` and `indexWithinCheckpoint` as separate fields
+
+The migration is needed because `L2Block` requires checkpoint data to be constructed, but with the new feature to push proposed blocks to the archiver before checkpoints exist, we need a block type that doesn't depend on checkpoint data.
+
+## Files to Migrate
+
+### Phase 1: Core Interfaces (stdlib)
+
+| File | Changes Needed |
+|------|----------------|
+| `stdlib/src/block/l2_block_source.ts` | Replace `getBlock()` return type with `L2BlockNew`, remove deprecated methods |
+| `stdlib/src/interfaces/aztec-node.ts` | Update `getBlock()` to return `L2BlockNew` |
+| `stdlib/src/interfaces/archiver.ts` | Update interfaces |
+| `stdlib/src/interfaces/block-builder.ts` | Update interfaces if needed |
+| `stdlib/src/p2p/block_proposal.ts` | Check if uses L2Block |
+| `stdlib/src/p2p/consensus_payload.ts` | Check if uses L2Block |
+
+### Phase 2: Archiver Package
+
+| File | Changes Needed |
+|------|----------------|
+| `archiver/src/modules/data_source_base.ts` | Change `getBlock()` to use `getL2BlockNew()`, remove L2Block conversion logic |
+| `archiver/src/store/block_store.ts` | Update any L2Block references |
+| `archiver/src/store/kv_archiver_store.ts` | Update store interfaces |
+| `archiver/src/archiver.ts` | Update main archiver class |
+| `archiver/src/test/mock_archiver.ts` | Update mock |
+| `archiver/src/test/mock_l2_block_source.ts` | Update mock |
+
+### Phase 3: Node and Sequencer
+
+| File | Changes Needed |
+|------|----------------|
+| `aztec-node/src/aztec-node/server.ts` | Update `getBlock()` implementation |
+| `sequencer-client/src/sequencer/sequencer.ts` | Check and update |
+| `prover-client/src/block-factory/light.ts` | Check and update |
+
+### Phase 4: P2P Package
+
+| File | Changes Needed |
+|------|----------------|
+| `p2p/src/client/interface.ts` | Update interfaces |
+| `p2p/src/client/p2p_client.ts` | Update implementation |
+| `p2p/src/services/libp2p/libp2p_service.ts` | Update |
+| `p2p/src/services/reqresp/interface.ts` | Update |
+| `p2p/src/services/tx_collection/*.ts` | Update |
+
+### Phase 5: Other Packages
+
+| File | Changes Needed |
+|------|----------------|
+| `txe/src/**/*.ts` | Update all TXE files |
+| `world-state/src/synchronizer/server_world_state_synchronizer.ts` | Update |
+| `aztec.js/src/api/block.ts` | Update client API |
+
+### Phase 6: End-to-End Tests
+
+| File | Changes Needed |
+|------|----------------|
+| `end-to-end/src/e2e_l1_publisher/write_json.ts` | Update test utilities |
+| `end-to-end/src/shared/gas_portal_test_harness.ts` | Update |
+| `end-to-end/src/spartan/*.ts` | Update |
+
+## Migration Strategy
+
+### Step 1: Update L2BlockSource Interface
+- Change `getBlock(number: BlockNumber): Promise<L2Block | undefined>` to return `L2BlockNew`
+- Keep `getL2BlockNew()` as is or deprecate it once `getBlock()` is migrated
+
+### Step 2: Update Archiver Implementation
+- Modify `getBlock()` in `data_source_base.ts` to call `this.store.getBlock()` directly (like `getL2BlockNew()` does)
+- Remove `getPublishedBlocks()` dependency for `getBlock()`
+
+### Step 3: Update AztecNode
+- Update `getBlock()` in server.ts to return `L2BlockNew`
+
+### Step 4: Update Consumers
+- Update all code that calls `getBlock()` to work with `L2BlockNew`
+- Replace `block.header.*` accesses with appropriate `L2BlockNew` accessors
+
+### Step 5: Update Tests
+- Update e2e tests to use `L2BlockNew` methods instead of `L2Block` methods
+
+## Key Method Migrations
+
+### L2Block methods to L2BlockNew equivalents
+
+| L2Block | L2BlockNew |
+|---------|------------|
+| `block.header.globalVariables` | `block.header.globalVariables` (same) |
+| `block.header.state` | `block.header.state` (same) |
+| `block.number` | `block.number` (same) |
+| `block.slot` | `block.slot` (same) |
+| `block.body` | `block.body` (same) |
+| `block.archive` | `block.archive` (same) |
+| `block.getCheckpointBlobFields()` | Use `encodeCheckpointBlobDataFromBlocks([block.toBlockBlobData()])` |
+| `block.toBlobFields()` | `block.toBlobFields()` (same) |
+| `block.getCheckpointHeader()` | No direct equivalent - checkpoint header is separate |
+| `block.header.blobsHash` | Not available on L2BlockNew - it's checkpoint-specific |
+
+## Current Progress
+
+- [x] Phase 1: Core Interfaces (stdlib) - COMPLETED
+- [x] Phase 2: Archiver Package - COMPLETED
+- [x] Phase 3: Node and Sequencer - COMPLETED
+- [x] Phase 4: P2P Package - COMPLETED
+- [x] Phase 5: Other Packages (pxe, txe, world-state) - COMPLETED
+- [x] Phase 6: End-to-End Tests - COMPLETED
+
+**BUILD PASSES** ✓
+
+## Phase 7: Delete deprecated L2Block class
+
+### Remaining L2Block usages to remove:
+
+| File | Usage | Fix |
+|------|-------|-----|
+| `archiver/src/modules/data_source_base.ts` | `L2Block.fromCheckpoint()` | Pass checkpoint blocks directly as L2BlockNew |
+| `archiver/src/test/mock_l2_block_source.ts` | `L2Block[]`, `L2Block.random()` | Use `L2BlockNew.random()` |
+| `archiver/src/test/mock_archiver.ts` | `L2Block.fromCheckpoint()` | Use checkpoint blocks directly |
+| `sequencer-client/src/publisher/sequencer-publisher.test.ts` | `L2Block.random()` | Use `L2BlockNew.random()` |
+| `prover-client/src/block-factory/light.ts` | Creates `L2Block` | Create `L2BlockNew` instead |
+| `p2p/src/client/p2p_client.test.ts` | `L2Block.random()` | Use `L2BlockNew.random()` |
+| `p2p/src/services/libp2p/libp2p_service.test.ts` | `L2Block.random()` | Use `L2BlockNew.random()` |
+
+### Files to delete after migration:
+- `stdlib/src/block/l2_block.ts`
+- `stdlib/src/block/l2_block_header.ts`
+
+## Phase 7 Status: COMPLETED ✓
+
+- `L2Block` class deleted from `stdlib/src/block/l2_block.ts`
+- All usages migrated to `L2BlockNew`
+- Build passes
+
+## Phase 8: Delete deprecated L2BlockHeader class
+
+### Files to update (replace `L2BlockHeader` with `BlockHeader` or `CheckpointHeader`):
+
+| File | Usage | Fix |
+|------|-------|-----|
+| `stdlib/src/tests/mocks.ts` | `makeL2BlockHeader().toBlockHeader()` | Use `BlockHeader.random()` directly |
+| `stdlib/src/tests/mocks.ts` | `makeL2BlockHeader().toCheckpointHeader()` | Use `CheckpointHeader.random()` directly |
+| `stdlib/src/tests/factories.ts` | Re-exports `makeL2BlockHeader` | Remove export |
+| `p2p/src/mem_pools/attestation_pool/mocks.ts` | `makeL2BlockHeader().toCheckpointHeader()` | Use `CheckpointHeader.random()` |
+| `p2p/src/client/test/p2p_client.integration_*.test.ts` | Uses `L2BlockHeader` | Replace with `BlockHeader` |
+| `p2p/src/msg_validators/**/*.test.ts` | Uses `L2BlockHeader` | Replace with `BlockHeader`/`CheckpointHeader` |
+| `validator-client/src/*.test.ts` | Uses `L2BlockHeader` | Replace with appropriate type |
+| `txe/src/utils/block_creation.ts` | Creates `L2BlockHeader` directly | Use `BlockHeader` directly |
+
+### Files to delete:
+- `stdlib/src/block/l2_block_header.ts`
+- `stdlib/src/block/l2_block_code_to_purge.ts`
+
+### Key replacements:
+- `makeL2BlockHeader(seed).toBlockHeader()` → `BlockHeader.random()`
+- `makeL2BlockHeader(seed).toCheckpointHeader()` → `CheckpointHeader.random()`
+- `L2BlockHeader` type → `BlockHeader` or `CheckpointHeader` depending on context
+
+## Phase 8 Status: COMPLETED ✓
+
+- `L2BlockHeader` class deleted from `stdlib/src/block/l2_block_header.ts`
+- `l2_block_code_to_purge.ts` deleted
+- All usages migrated to `BlockHeader` or `CheckpointHeader`
+- Build passes
+
+## Migration Complete ✓
+
+All deprecated classes have been removed:
+- [x] `L2Block` class - DELETED
+- [x] `L2BlockHeader` class - DELETED
+- [x] `l2_block_code_to_purge.ts` - DELETED
+
+## Notes
+
+- The original issue was that `getBlock()` required checkpoint data, but provisional blocks don't have checkpoint data yet
+- Migration resolved this by using `L2BlockNew` which doesn't depend on checkpoint-specific fields
+- `L2BlockNew` can now be stored and retrieved before checkpoints are created

yarn-project/archiver/src/archiver-sync.test.ts

@@ -212,7 +212,7 @@ describe('Archiver Sync', () => {
           const expectedTotalNumLogs = (name: 'private' | 'public' | 'contractClass') =>
             sum(block.body.txEffects.map(txEffect => txEffect[`${name}Logs`].length));
 
-          const privateLogs = (await archiver.getBlock(blockNumber))!.toL2Block().getPrivateLogs();
+          const privateLogs = (await archiver.getBlock(blockNumber))!.getPrivateLogs();
           expect(privateLogs.length).toBe(expectedTotalNumLogs('private'));
 
           const publicLogs = (await archiver.getPublicLogs({ fromBlock: blockNumber, toBlock: blockNumber + 1 })).logs;

yarn-project/archiver/src/modules/data_source_base.ts

@@ -7,8 +7,7 @@ import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
   type CheckpointedL2Block,
   CommitteeAttestation,
-  L2Block,
-  type L2BlockNew,
+  L2BlockNew,
   type L2Tips,
   PublishedL2Block,
 } from '@aztec/stdlib/block';
@@ -273,13 +272,13 @@ export abstract class ArchiverDataSourceBase
     return this.store.getBlocksForSlot(slotNumber);
   }
 
-  public async getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]> {
+  public async getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2BlockNew[]> {
     if (!this.l1Constants) {
       throw new Error('L1 constants not set');
     }
 
     const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
-    const blocks: L2Block[] = [];
+    const blocks: L2BlockNew[] = [];
 
     // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
     // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
@@ -361,49 +360,43 @@ export abstract class ArchiverDataSourceBase
       await Promise.all(checkpoints.map(ch => this.store.getBlocksForCheckpoint(ch.checkpointNumber)))
     ).filter(isDefined);
 
-    const olbBlocks: PublishedL2Block[] = [];
+    const publishedBlocks: PublishedL2Block[] = [];
     for (let i = 0; i < checkpoints.length; i++) {
       const blockForCheckpoint = blocks[i][0];
       const checkpoint = checkpoints[i];
       if (checkpoint.checkpointNumber > provenCheckpointNumber && proven === true) {
-        // this checkpointisn't proven and we only want proven
+        // this checkpoint isn't proven and we only want proven
         continue;
       }
-      const oldCheckpoint = new Checkpoint(
-        blockForCheckpoint.archive,
-        checkpoint.header,
-        [blockForCheckpoint],
-        checkpoint.checkpointNumber,
-      );
-      const oldBlock = L2Block.fromCheckpoint(oldCheckpoint);
       const publishedBlock = new PublishedL2Block(
-        oldBlock,
+        blockForCheckpoint,
         checkpoint.l1,
         checkpoint.attestations.map(x => CommitteeAttestation.fromBuffer(x)),
       );
-      olbBlocks.push(publishedBlock);
+      publishedBlocks.push(publishedBlock);
     }
-    return olbBlocks;
+    return publishedBlocks;
   }
 
-  public async getBlock(number: BlockNumber): Promise<L2Block | undefined> {
+  public async getBlock(number: BlockNumber): Promise<L2BlockNew | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
       number = await this.store.getLatestBlockNumber();
     }
     if (number === 0) {
       return undefined;
     }
-    const publishedBlocks = await this.getPublishedBlocks(number, 1);
-    if (publishedBlocks.length === 0) {
-      return undefined;
-    }
-    return publishedBlocks[0].block;
+    return this.store.getBlock(number);
   }
 
-  public async getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2Block[]> {
-    const publishedBlocks = await this.getPublishedBlocks(from, limit, proven);
-    return publishedBlocks.map(x => x.block);
+  public async getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
+    const blocks = await this.store.getBlocks(from, limit);
+
+    if (proven === true) {
+      const provenBlockNumber = await this.store.getProvenBlockNumber();
+      return blocks.filter(b => b.number <= provenBlockNumber);
+    }
+    return blocks;
   }
 
   public async getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
@@ -416,6 +409,16 @@ export abstract class ArchiverDataSourceBase
     return this.buildOldBlockFromCheckpointedBlock(checkpointedBlock);
   }
 
+  public async getL2BlockNewByHash(blockHash: Fr): Promise<L2BlockNew | undefined> {
+    const checkpointedBlock = await this.store.getCheckpointedBlockByHash(blockHash);
+    return checkpointedBlock?.block;
+  }
+
+  public async getL2BlockNewByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
+    const checkpointedBlock = await this.store.getCheckpointedBlockByArchive(archive);
+    return checkpointedBlock?.block;
+  }
+
   private async buildOldBlockFromCheckpointedBlock(
     checkpointedBlock: CheckpointedL2Block | undefined,
   ): Promise<PublishedL2Block | undefined> {
@@ -426,15 +429,8 @@ export abstract class ArchiverDataSourceBase
     if (!checkpoint) {
       return checkpoint;
     }
-    const fullCheckpoint = new Checkpoint(
-      checkpointedBlock?.block.archive,
-      checkpoint?.header,
-      [checkpointedBlock.block],
-      checkpoint.checkpointNumber,
-    );
-    const oldBlock = L2Block.fromCheckpoint(fullCheckpoint);
     const published = new PublishedL2Block(
-      oldBlock,
+      checkpointedBlock.block,
       checkpoint.l1,
       checkpoint.attestations.map(x => CommitteeAttestation.fromBuffer(x)),
     );

yarn-project/archiver/src/test/mock_archiver.ts

@@ -1,6 +1,6 @@
 import type { CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
-import { L2Block, type L2BlockSource } from '@aztec/stdlib/block';
+import type { L2BlockSource } from '@aztec/stdlib/block';
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 
@@ -57,7 +57,7 @@ export class MockPrefilledArchiver extends MockArchiver {
 
     const fromBlock = this.l2Blocks.length;
     // TODO: Add L2 blocks and checkpoints separately once archiver has the apis for that.
-    this.addBlocks(this.prefilled.slice(fromBlock, fromBlock + numBlocks).map(c => L2Block.fromCheckpoint(c)));
+    this.addBlocks(this.prefilled.slice(fromBlock, fromBlock + numBlocks).flatMap(c => c.blocks));
     return Promise.resolve();
   }
 }