feat: new engine API handler

[mattsse]

this will eventually replace the beacon-consensus and changes how it interacts with the tree.

The chain requires some component that advances the chain Chainhandler, the beacon-consensus (engine-API) is such a type.
internally this make use the treeservice to maintain the blockchain tree.

This would also it possible to run the node without the engine API and use something else.

TBD if pruning+pipeline should be part of chainhandler or whether this should be separate.

all naming TBD

[gakonst]

following progress

[Rjected]

would these be for example. any skipped FCU? assuming incoming_requests would correspond to requests that have never been processed before

[mattsse]

ah, these are internal events that will be popped from the vecdeque on poll

[rkrasiuk]

looking gud

[rkrasiuk]

imo by tree handler, no need to introduce extra complexity here

[rkrasiuk]

we also need a separate method for finalizing at block height

[gakonst]

and per discussion in discord we should also allow buffering & committing transactions separate from the state/tree/historical indices?

[rkrasiuk]

these are tree implementation details that have nothing to do with the interfaces. the tree should be able to decide on its own when to buffer / commit

[gakonst]

Suggested change

	WriteAccess,
	WriteAccessStarted,

[gakonst]

Suggested change

	Pipeline(PipelineAction),
	PipelineTriggered(PipelineAction),

[gakonst]

I really like how this captures the pipeline into live sync transition along with the hooks, and the live sync logic is a general handler where you don't need to know anything about its internals except where it drove the chain

[gakonst]

Will ExEx hook on these chain notifications?

[gakonst]

should the types here be CoW?

[gakonst]

good start, very excited for the event driven design

[gakonst]

and per discussion in discord we should also allow buffering & committing transactions separate from the state/tree/historical indices?

[gakonst]

I wonder if Pruning has been all along the wrong way to think about it, and instead we should have an Archiver hook, and we implement Archiver for a Static Files Hook and for a State Diffs hook?

[gakonst]

This is really good because it completely generalizes between a handler that's for Engine API For L1 usage, an optimized Engine API Handler for OP Sequencer usage which does FCU->GP->NP in a loop instead of allowing forking, or a handler for usage with ABCI or other consensus interfaces.

[gakonst]

These receivers should be polled in a spawned task in the background right? or will the Engine Handler itself be the thing that's spawned in the background?

[gakonst]

When do we need to do this? Is it on long reorgs? Something like snap sync?

[gakonst]

Could on forkchoice updated buffer up the data instead and have a way to configure when the write to the db is done?

[emhane]

buffering should be done wrt to time out #8251 (comment). we should use a data structure that checks if existing entries are expired on insert

fn buffer_fcu(&mut self, msg: ForkChoiceUpdate) {
    let mut iter = self.iter_mut().rev();
    let mut entry = iter.next();
    let mut expired_count = 0;
    while entry.is_some() && entry.unwrap().insert_time.elapsed() >= Duration::from_secs(8) {
        expired_count += 1;
    }
    self.split_off(self.len() - expired_count)
    
    self.push(msg)
}

[emhane]

ref #8579

[gakonst]

does this cover also op engine types?

[emhane]

Suggested change

	pub trait EngineRequestHandler: Send + Sync {
	pub trait EngineRequestHandler: Send + Sync + Stream<Item = RequestHandlerEvent<Self::Event>> {

what is the actual problem here with doing this instead?

[mattsse]

it's not a stream

[emhane]

probably it should be though

The Stream trait is similar to Future but can yield multiple values before completing

https://rust-lang.github.io/async-book/05_streams/01_chapter.html

[emhane]

buffering should be done wrt to time out #8251 (comment). we should use a data structure that checks if existing entries are expired on insert

fn buffer_fcu(&mut self, msg: ForkChoiceUpdate) {
    let mut iter = self.iter_mut().rev();
    let mut entry = iter.next();
    let mut expired_count = 0;
    while entry.is_some() && entry.unwrap().insert_time.elapsed() >= Duration::from_secs(8) {
        expired_count += 1;
    }
    self.split_off(self.len() - expired_count)
    
    self.push(msg)
}

[emhane]

this impl should close #6217 right?

out of scope for now