feat: archiver to follow "fork-choice" of contract

[LHerskind]

[!success] Goal
The archiver should:

• only look for blocks if any blocks were proposed;
• download non-pruned history only;
• identify a prune that its view is effected by;
• store a list of prunes that effected it.

Currently the archiver continuously look for block proposal events emitted by the Rollup contract.
This have historically caused some pain for initial synching, since it started at block 0, and looked for events before any even had the possibility of being emitted.
Furthermore, it means that we might start searching for events for a period where no blocks have been proposed.

First, we suggest using the Rollup::GENESIS_TIME as a proxy for when to start, potentially adding Rollup::GENESIS_TIME_IN_L1_BLOCK_NUMBER such that the point of start can simple be read directly from the contract. This will allow us for a simpler setup, and avoid searching for something in the void.
Second, if we look at the values Rollup::provenBlockCount and Rollup::pendingBlockCount and keep track of these locally, we will know when blocks have been proposed. This allows us to easily skip the event search when we know that nothing will be found.

In relation to pruned blocks, the archiver need to handle those differently depending on how it is encountering them. We will go through some cases now.

The fresh sync:
The archiver have no local state. Does it gain anything from downloading blocks that were pruned? No, these would never be applied to the world state, so we might as well discard them. Better than discarding them, we should not download them at all.
Consider the event Rollup::L2BlockProposed, it currently have just the block number, giving us very little to figure out if it is pruned or not. Lets say that we alter it:

// Old
event L2BlockProposed(uint256 indexed blockNumber);

// New
event L2BlockProposed(uint256 indexed blockNumber, uint256 archive);

By including the archive value, we have more information that we can use to validate that the proposal was not pruned, without needing to download it in full first.

For each event we find, we check archive == Rollup::archiveAt(blockNumber). If the check passes, the block is currently part of the chain and we can download it, otherwise it have been pruned and we just ignore it.

Synching after shutdown:
Say that we have an archiver that have previously been running at the head of the chain but we shut it down over the weekend, and now we want to start it again and catch up.

At the start of every loop, call Rollup::archiveAt() for the blockNumber of your current chain tip. If the returned value does not match the archive of your chain tip, a prune have executed while you were gone.
We need to figure out where the prune happened. We at this point know that it have happened sometime between our proven and pending blocks, so we can simply perform a binary search in there to find the last block where the Rollup::archiveAt() will match. For any blocks we have stored that have a higher block number than the found value, we delete the blocks.

At this point, the archive includes only non-pruned blocks. However, the world-state might include changes made by these blocks, and we need those undone. We therefore want to tell the world state that a prune that have impacted our state have happened. To ensure that it can correctly unwind state, we should tell it at what block it should unwind until, and what we expect that state root to be, e.g., {blockNumber, archive}. The world state unwinds until these values are hit.

We should insert these into a store before we delete the blocks, such that a node failure in the moment where blocks have been deleted but the world-state have not been unwind is not a problem. I think the check should happen as part of collectAndProcessBlocks to ensure that we don't start applying a bunch of blocks before unwinding them.

When the unwind have occurred, we should be able to simple progress as usual.

To optimise the number of calls needed, we can add the status() function to the Rollup, that way, we fetch multiple of the values we are interested in, with just a single call.

function status(uint256 myHeaderBlockNumber) 
	external 
	view 
	returns(uint256, bytes32, uint256, bytes32, bytes32) 
{
	bytes32 archiveOfMyBlock = myHeaderBlockNumber < pendingBlockCount 
	? archiveAt(myHeaderBlockNumber)
	: bytes32(0);

	return (
		provenBlockCount,
                blocks[provenBlock - 1].archive,
		pendingBlockCount,
		blocks[pendingBlock - 1].archive,
		archiveOfMyBlock
	);
}

Tasks

Preview Give feedback

1. test: Add more test for measuring speed of synching #8536
   +0
   
2. refactor: Use contract values as lower bound for search start, remove the env var #8552
   +0
   
3. refactor: Download only non-pruned blocks #8562
   +0
   
4. refactor: Only look for events if blocks are known to have been added #8565
   +0
   
5. feat: Add status to contract and use it to catch prune #8620
   +0
   

[LHerskind]

The archiver can now follow the L2 forkchoice - the state is yet to come.