From b5c0cfb6f541d8c97875a717b4a7044628bdaf44 Mon Sep 17 00:00:00 2001 From: yperbasis Date: Wed, 11 Nov 2026 16:16:40 +0100 Subject: [PATCH] clients/consensus: track canonical heads from head events --- pkg/clients/consensus/clientlogic.go | 55 ++-- pkg/clients/consensus/clientlogic_test.go | 243 ++++++++++++++++++ .../consensus/rpc/eventstream/eventstream.go | 3 +- 3 files changed, 282 insertions(+), 19 deletions(-) create mode 100644 pkg/clients/consensus/clientlogic_test.go diff --git a/pkg/clients/consensus/clientlogic.go b/pkg/clients/consensus/clientlogic.go index e17354f3..f335ea3e 100644 --- a/pkg/clients/consensus/clientlogic.go +++ b/pkg/clients/consensus/clientlogic.go @@ -137,7 +137,7 @@ func (client *Client) runClientLogic() error { } // start event stream - blockStream := client.rpcClient.NewBlockStream(client.clientCtx, rpc.StreamBlockEvent|rpc.StreamFinalizedEvent|rpc.StreamExecutionPayloadEvent) + blockStream := client.rpcClient.NewBlockStream(client.clientCtx, rpc.StreamBlockEvent|rpc.StreamHeadEvent|rpc.StreamFinalizedEvent|rpc.StreamExecutionPayloadEvent) defer blockStream.Close() // process events @@ -166,6 +166,14 @@ func (client *Client) runClientLogic() error { } } + case rpc.StreamHeadEvent: + if headEvent, ok := evt.Data.(*v1.HeadEvent); ok { + err := client.processHeadEvent(headEvent) + if err != nil { + client.logger.Warnf("failed processing head event: %v", err) + } + } + case rpc.StreamFinalizedEvent: if finalizedEvent, ok := evt.Data.(*v1.FinalizedCheckpointEvent); ok { err := client.processFinalizedEvent(finalizedEvent) @@ -209,20 +217,27 @@ func (client *Client) runClientLogic() error { } func (client *Client) processBlockEvent(evt *v1.BlockEvent) error { - err := client.processBlock(evt.Block, evt.Slot, nil, "streamed") + _, err := client.processBlock(evt.Block, evt.Slot, nil, "streamed") if err != nil { return fmt.Errorf("could not process block: %v", err) } - client.headMutex.Lock() - client.headSlot = evt.Slot - client.headRoot = evt.Block - client.headMutex.Unlock() client.pool.resetHeadForkCache() return nil } +func (client *Client) processHeadEvent(evt *v1.HeadEvent) error { + block, err := client.processBlock(evt.Block, evt.Slot, nil, "head") + if err != nil { + return fmt.Errorf("could not process head block: %v", err) + } + + client.setHead(block) + + return nil +} + func (client *Client) processFinalizedEvent(evt *v1.FinalizedCheckpointEvent) error { client.logger.Debugf("received finalization_checkpoint event: finalized %v [0x%x]", evt.Epoch, evt.Block) return client.setFinalizedHead(evt.Epoch, evt.Block) @@ -271,11 +286,13 @@ func (client *Client) pollClientHead() error { return fmt.Errorf("could not find latest header") } - err = client.processBlock(latestHeader.Root, latestHeader.Header.Message.Slot, latestHeader.Header, "polled") + block, err := client.processBlock(latestHeader.Root, latestHeader.Header.Message.Slot, latestHeader.Header, "polled") if err != nil { return fmt.Errorf("could not get process block: %v", err) } + client.setHead(block) + finalityCheckpoint, err := client.rpcClient.GetFinalityCheckpoints(ctx) if err != nil { return fmt.Errorf("could not get finality checkpoint: %v", err) @@ -284,10 +301,10 @@ func (client *Client) pollClientHead() error { return client.setFinalizedHead(finalityCheckpoint.Finalized.Epoch, finalityCheckpoint.Finalized.Root) } -func (client *Client) processBlock(root phase0.Root, slot phase0.Slot, header *phase0.SignedBeaconBlockHeader, source string) error { +func (client *Client) processBlock(root phase0.Root, slot phase0.Slot, header *phase0.SignedBeaconBlockHeader, source string) (*Block, error) { cachedBlock, isNewBlock := client.pool.blockCache.AddBlock(root, slot) if cachedBlock == nil { - return fmt.Errorf("could not add block to cache %v [0x%x]", slot, root) + return nil, fmt.Errorf("could not add block to cache %v [0x%x]", slot, root) } cachedBlock.SetSeenBy(client) @@ -314,7 +331,7 @@ func (client *Client) processBlock(root phase0.Root, slot phase0.Slot, header *p return header.Header, nil }) if err != nil { - return err + return nil, err } loaded, err := cachedBlock.EnsureBlock(func() (*spec.VersionedSignedBeaconBlock, error) { @@ -329,7 +346,7 @@ func (client *Client) processBlock(root phase0.Root, slot phase0.Slot, header *p return block, nil }) if err != nil { - return err + return nil, err } if loaded { @@ -342,21 +359,23 @@ func (client *Client) processBlock(root phase0.Root, slot phase0.Slot, header *p } } + return cachedBlock, nil +} + +func (client *Client) setHead(block *Block) { client.headMutex.Lock() - if bytes.Equal(client.headRoot[:], root[:]) { + if bytes.Equal(client.headRoot[:], block.Root[:]) { client.headMutex.Unlock() - return nil + return } - client.headSlot = slot - client.headRoot = root + client.headSlot = block.Slot + client.headRoot = block.Root client.headMutex.Unlock() client.pool.resetHeadForkCache() - client.blockDispatcher.Fire(cachedBlock) - - return nil + client.blockDispatcher.Fire(block) } func (client *Client) loadBlockPayload(cachedBlock *Block) { diff --git a/pkg/clients/consensus/clientlogic_test.go b/pkg/clients/consensus/clientlogic_test.go new file mode 100644 index 00000000..1aad6a76 --- /dev/null +++ b/pkg/clients/consensus/clientlogic_test.go @@ -0,0 +1,243 @@ +package consensus + +import ( + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "net/http/httptest" + "slices" + "strings" + "testing" + "time" + + "github.com/ethpandaops/assertoor/pkg/clients/consensus/rpc" + v1 "github.com/ethpandaops/go-eth2-client/api/v1" + "github.com/ethpandaops/go-eth2-client/spec" + "github.com/ethpandaops/go-eth2-client/spec/phase0" + "github.com/sirupsen/logrus" +) + +func TestClientTracksHeadEvents(t *testing.T) { + pool := newTestPool(t) + pool.blockCache.specs = &ChainSpec{SlotsPerEpoch: 8} + parent := cacheTestBlock(t, pool, 12, phase0.Root{1}, phase0.Root{}) + oldHead := cacheTestBlock(t, pool, 13, phase0.Root{2}, parent.Root) + newHead := cacheTestBlock(t, pool, 13, phase0.Root{3}, parent.Root) + events := make(chan *v1.HeadEvent) + topics := make(chan []string, 1) + payloadReady := make(chan struct{}) + ctx, cancel := context.WithCancel(t.Context()) + + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + var data any + + switch r.URL.Path { + case "/eth/v1/node/syncing": + data = &v1.SyncState{HeadSlot: oldHead.Slot} + case "/eth/v1/node/version": + data = map[string]string{"version": "Lighthouse/test"} + case "/eth/v1/beacon/headers/head": + data = &v1.BeaconBlockHeader{Root: oldHead.Root, Canonical: true, Header: oldHead.GetHeader()} + case "/eth/v1/beacon/states/head/finality_checkpoints": + data = &v1.Finality{ + PreviousJustified: &phase0.Checkpoint{}, + Justified: &phase0.Checkpoint{}, + Finalized: &phase0.Checkpoint{}, + } + case "/eth/v1/events": + requested := strings.Split(r.URL.Query().Get("topics"), ",") + + w.Header().Set("Content-Type", "text/event-stream") + w.WriteHeader(http.StatusOK) + + controller := http.NewResponseController(w) + if err := controller.Flush(); err != nil { + t.Error(err) + return + } + + if slices.Contains(requested, "execution_payload_available") { + close(payloadReady) + <-r.Context().Done() + + return + } + + topics <- requested + + for { + select { + case event := <-events: + encoded, err := json.Marshal(event) + if err != nil { + t.Error(err) + return + } + + if _, err := fmt.Fprintf(w, "event: head\ndata: %s\n\n", encoded); err != nil { + t.Error(err) + return + } + + if err := controller.Flush(); err != nil { + t.Error(err) + return + } + case <-r.Context().Done(): + return + } + } + default: + t.Errorf("unexpected request: %s", r.URL.Path) + http.NotFound(w, r) + + return + } + + w.Header().Set("Content-Type", "application/json") + + if err := json.NewEncoder(w).Encode(map[string]any{"data": data}); err != nil { + t.Error(err) + } + })) + t.Cleanup(server.Close) + t.Cleanup(cancel) + + rpcClient, err := rpc.NewBeaconClient("test", server.URL, nil) + if err != nil { + t.Fatal(err) + } + + if err := rpcClient.Initialize(ctx); err != nil { + t.Fatal(err) + } + + client := &Client{pool: pool, clientCtx: ctx, rpcClient: rpcClient, logger: pool.logger.WithField("client", "test")} + subscription := client.SubscribeBlockEvent(4) + done := make(chan error, 1) + + go func() { done <- client.runClientLogic() }() + + t.Cleanup(func() { + cancel() + + select { + case err := <-done: + if err != nil { + t.Error(err) + } + case <-time.After(5 * time.Second): + t.Error("client loop did not stop") + } + }) + + select { + case requested := <-topics: + if !slices.Contains(requested, "head") { + t.Fatalf("client subscribes to %v, want head events", requested) + } + case <-time.After(5 * time.Second): + t.Fatal("client did not subscribe to events") + } + + awaitHead(t, subscription, oldHead) + + select { + case <-payloadReady: + case <-time.After(5 * time.Second): + t.Fatal("client did not subscribe to payload events") + } + + select { + case events <- &v1.HeadEvent{Slot: newHead.Slot, Block: newHead.Root}: + case <-time.After(5 * time.Second): + t.Fatal("could not send head event") + } + + awaitHead(t, subscription, newHead) + + if slot, root := client.GetLastHead(); slot != newHead.Slot || root != newHead.Root { + t.Fatalf("head is %d [%s], want %d [%s]", slot, root, newHead.Slot, newHead.Root) + } +} + +func TestBlockEventDoesNotReplaceHead(t *testing.T) { + pool := newTestPool(t) + parent := cacheTestBlock(t, pool, 12, phase0.Root{1}, phase0.Root{}) + head := cacheTestBlock(t, pool, 13, phase0.Root{2}, parent.Root) + side := cacheTestBlock(t, pool, 13, phase0.Root{3}, parent.Root) + client := &Client{ + pool: pool, + logger: pool.logger.WithField("client", "test"), + headSlot: head.Slot, + headRoot: head.Root, + isOnline: true, + clientCtx: t.Context(), + } + peer := &Client{pool: pool, clientIdx: 1, headSlot: head.Slot, headRoot: head.Root, isOnline: true} + pool.clients = []*Client{client, peer} + + if err := client.processBlockEvent(&v1.BlockEvent{Slot: side.Slot, Block: side.Root}); err != nil { + t.Fatal(err) + } + + if slot, root := client.GetLastHead(); slot != head.Slot || root != head.Root { + t.Fatalf("block import changed head to %d [%s], want %d [%s]", slot, root, head.Slot, head.Root) + } + + if seen := side.GetSeenBy(); len(seen) != 1 || seen[0] != client { + t.Fatal("side block was not recorded as seen by the client") + } + + if forks := pool.GetHeadForks(1); len(forks) != 1 { + t.Fatalf("got %d forks after a side block import, want 1", len(forks)) + } +} + +func awaitHead(t *testing.T, subscription *Subscription[*Block], want *Block) { + t.Helper() + + select { + case block := <-subscription.Channel(): + if block.Root != want.Root || block.Slot != want.Slot { + t.Fatalf("published head is %d [%s], want %d [%s]", block.Slot, block.Root, want.Slot, want.Root) + } + case <-time.After(5 * time.Second): + t.Fatalf("head %d [%s] was not published", want.Slot, want.Root) + } +} + +func newTestPool(t *testing.T) *Pool { + t.Helper() + + logger := logrus.New() + logger.SetOutput(io.Discard) + + pool, err := NewPool(t.Context(), &PoolConfig{FollowDistance: 64}, logger) + if err != nil { + t.Fatal(err) + } + + return pool +} + +func cacheTestBlock(t *testing.T, pool *Pool, slot phase0.Slot, root, parent phase0.Root) *Block { + t.Helper() + + block, _ := pool.blockCache.AddBlock(root, slot) + if err := block.EnsureHeader(func() (*phase0.SignedBeaconBlockHeader, error) { + return &phase0.SignedBeaconBlockHeader{Message: &phase0.BeaconBlockHeader{Slot: slot, ParentRoot: parent}}, nil + }); err != nil { + t.Fatal(err) + } + + if _, err := block.EnsureBlock(func() (*spec.VersionedSignedBeaconBlock, error) { + return &spec.VersionedSignedBeaconBlock{Version: spec.DataVersionPhase0}, nil + }); err != nil { + t.Fatal(err) + } + + return block +} diff --git a/pkg/clients/consensus/rpc/eventstream/eventstream.go b/pkg/clients/consensus/rpc/eventstream/eventstream.go index ca3268e7..20763644 100644 --- a/pkg/clients/consensus/rpc/eventstream/eventstream.go +++ b/pkg/clients/consensus/rpc/eventstream/eventstream.go @@ -77,8 +77,9 @@ func SubscribeWithRequest(lastEventID string, request *http.Request) (*Stream, e // SubscribeWith takes a http client and request providing customization over both headers and // control over the http client settings (timeouts, tls, etc) func SubscribeWith(lastEventID string, client *http.Client, request *http.Request) (*Stream, error) { + streamClient := *client stream := &Stream{ - c: client, + c: &streamClient, req: request, lastEventID: lastEventID, retry: time.Millisecond * 3000,