feat(frontend): block propagation from Xatu

cache/large_payload_test.go

@@ -0,0 +1,70 @@
+package cache
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/ethpandaops/dora/types"
+	"github.com/ethpandaops/dora/types/models"
+	"github.com/ethpandaops/dora/utils"
+	"github.com/sirupsen/logrus"
+)
+
+// A mainnet-scale slot arrival payload runs to hundreds of kilobytes, well past
+// the 100KB MaxEntrySize. That setting only sizes the initial allocation; the
+// real ceiling is HardMaxCacheSize/Shards, so these must still round trip. If
+// they ever stop, every request rebuilds and the page cache silently stops
+// absorbing load.
+func TestLargeArrivalPayloadRoundTrips(t *testing.T) {
+	utils.Config = &types.Config{}
+
+	tc, err := NewTieredCache(100, "", "test", logrus.New())
+	if err != nil {
+		t.Fatalf("cache init: %v", err)
+	}
+
+	for _, nodes := range []int{500, 1000, 2000} {
+		resp := &models.SlotArrivalResponse{Slot: 15060285, Settled: true}
+		for i := 0; i < nodes; i++ {
+			resp.Nodes = append(resp.Nodes, &models.SlotArrivalNode{
+				Name:           fmt.Sprintf("pub-contributoor/operator-%04d/hashed-abcdef01", i),
+				FullName:       fmt.Sprintf("pub-contributoor/operator-%04d/hashed-abcdef0123456789", i),
+				Group:          "community",
+				Implementation: "lighthouse",
+				Continent:      "EU",
+				Country:        "Germany",
+				CountryCode:    "de",
+				MinMs:          uint32(700 + i%800),
+			})
+		}
+
+		raw, err := json.Marshal(resp)
+		if err != nil {
+			t.Fatalf("marshal: %v", err)
+		}
+
+		key := fmt.Sprintf("slotarrival:15060285:%d", nodes)
+		if err := tc.Set(key, resp, time.Hour); err != nil {
+			t.Errorf("%d nodes (%d KB payload): Set failed: %v", nodes, len(raw)/1024, err)
+
+			continue
+		}
+
+		out := &models.SlotArrivalResponse{}
+		if _, err := tc.Get(key, out); err != nil {
+			t.Errorf("%d nodes (%d KB): Get failed: %v", nodes, len(raw)/1024, err)
+
+			continue
+		}
+
+		if len(out.Nodes) != nodes {
+			t.Errorf("%d nodes: round-tripped %d", nodes, len(out.Nodes))
+
+			continue
+		}
+
+		t.Logf("%4d nodes, %4d KB payload: cached and retrieved OK", nodes, len(raw)/1024)
+	}
+}

cache/nil_fidelity_epoch_test.go

@@ -0,0 +1,51 @@
+package cache
+
+import (
+	"testing"
+	"time"
+
+	"github.com/ethpandaops/dora/types"
+	"github.com/ethpandaops/dora/types/models"
+	"github.com/ethpandaops/dora/utils"
+	"github.com/sirupsen/logrus"
+)
+
+func TestEpochPageNilArrivalThroughCache(t *testing.T) {
+	utils.Config = &types.Config{}
+
+	tc, err := NewTieredCache(100, "", "test", logrus.New())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// no arrival data for this slot: ArrivalNodes is the presence signal
+	in := &models.EpochPageData{
+		Epoch: 7,
+		Slots: []*models.EpochPageDataSlot{
+			{Slot: 224},
+			{Slot: 225, ArrivalNodes: 12, ArrivalMinMs: 742, ArrivalP90Ms: 1180},
+		},
+	}
+
+	if err := tc.Set("epoch:7", in, time.Hour); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+
+	out := &models.EpochPageData{}
+	if _, err := tc.Get("epoch:7", out); err != nil {
+		t.Fatalf("get: %v", err)
+	}
+
+	absent, present := out.Slots[0], out.Slots[1]
+	t.Logf("absent slot: nodes=%d min=%d p90=%d", absent.ArrivalNodes, absent.ArrivalMinMs, absent.ArrivalP90Ms)
+	t.Logf("present slot: nodes=%d min=%d p90=%d", present.ArrivalNodes, present.ArrivalMinMs, present.ArrivalP90Ms)
+
+	if absent.ArrivalNodes != 0 {
+		t.Errorf("slot with no data came back with %d nodes", absent.ArrivalNodes)
+	}
+
+	if present.ArrivalNodes != 12 || present.ArrivalMinMs != 742 || present.ArrivalP90Ms != 1180 {
+		t.Errorf("real arrival data did not survive: nodes=%d min=%d p90=%d",
+			present.ArrivalNodes, present.ArrivalMinMs, present.ArrivalP90Ms)
+	}
+}

cache/nil_fidelity_test.go

@@ -0,0 +1,68 @@
+package cache
+
+import (
+	"testing"
+	"time"
+
+	"github.com/ethpandaops/dora/types"
+	"github.com/ethpandaops/dora/types/models"
+	"github.com/ethpandaops/dora/utils"
+	"github.com/sirupsen/logrus"
+)
+
+func TestNilPointerFidelityThroughCache(t *testing.T) {
+	utils.Config = &types.Config{}
+
+	tc, err := NewTieredCache(100, "", "test", logrus.New())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// a node that only reported gossip: every other series must stay nil
+	p2p := uint32(742)
+	in := &models.SlotArrivalResponse{
+		Slot: 1, Settled: true,
+		Nodes: []*models.SlotArrivalNode{{Name: "n", P2PMs: &p2p}},
+	}
+
+	if err := tc.Set("slotarrival:1:x", in, time.Hour); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+
+	out := &models.SlotArrivalResponse{}
+	if _, err := tc.Get("slotarrival:1:x", out); err != nil {
+		t.Fatalf("get: %v", err)
+	}
+
+	n := out.Nodes[0]
+	t.Logf("after round trip: P2PMs=%v APIMs=%v HeadMs=%v NPMs=%v",
+		deref(n.P2PMs), deref(n.APIMs), deref(n.HeadMs), deref(n.NPMs))
+
+	for name, ptr := range map[string]*uint32{"APIMs": n.APIMs, "HeadMs": n.HeadMs, "NPMs": n.NPMs} {
+		if ptr != nil {
+			t.Errorf("%s should be nil after round trip, got pointer to %d", name, *ptr)
+		}
+	}
+}
+
+func deref(p *uint32) string {
+	if p == nil {
+		return "nil"
+	}
+
+	return "&" + itoa(*p)
+}
+
+func itoa(v uint32) string {
+	if v == 0 {
+		return "0"
+	}
+
+	var b []byte
+	for v > 0 {
+		b = append([]byte{byte('0' + v%10)}, b...)
+		v /= 10
+	}
+
+	return string(b)
+}

cache/nil_fidelity_waves_test.go

@@ -0,0 +1,78 @@
+package cache
+
+import (
+	"testing"
+	"time"
+
+	"github.com/ethpandaops/dora/types"
+	"github.com/ethpandaops/dora/types/models"
+	"github.com/ethpandaops/dora/utils"
+	"github.com/sirupsen/logrus"
+)
+
+// The waves response leans on nil to mean "no data": a nil section hides its
+// panel, a nil FirstSeenMs renders "not seen". Like the arrival response, it
+// must stay on the cache's JSON path, where nil survives a round trip.
+func TestWavesNilFidelityThroughCache(t *testing.T) {
+	utils.Config = &types.Config{}
+
+	tc, err := NewTieredCache(100, "", "test", logrus.New())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	pct := 87.5
+	in := &models.SlotWavesResponse{
+		Slot: 9, Settled: true,
+		// Attestations deliberately nil: a network without the cbt attestation
+		// model must not come back as an empty wave.
+		Columns: &models.SlotColumnWave{
+			BlobCount: 3,
+			Columns: []*models.SlotColumn{
+				// probed but never seen
+				{Index: 0, AvailabilityPct: &pct, Probes: 4},
+				// seen but never probed
+				{Index: 1, FirstSeenMs: ptr(uint32(1300))},
+			},
+		},
+	}
+
+	if err := tc.Set("slotwaves:9:x", in, time.Hour); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+
+	out := &models.SlotWavesResponse{}
+	if _, err := tc.Get("slotwaves:9:x", out); err != nil {
+		t.Fatalf("get: %v", err)
+	}
+
+	if out.Attestations != nil {
+		t.Errorf("Attestations should stay nil, got %+v", out.Attestations)
+	}
+
+	if out.Columns == nil {
+		t.Fatal("Columns section lost")
+	}
+
+	unseen, unprobed := out.Columns.Columns[0], out.Columns.Columns[1]
+
+	if unseen.FirstSeenMs != nil {
+		t.Errorf("unseen column got FirstSeenMs %d", *unseen.FirstSeenMs)
+	}
+
+	if unseen.AvailabilityPct == nil || *unseen.AvailabilityPct != pct {
+		t.Errorf("availability lost: %v", unseen.AvailabilityPct)
+	}
+
+	if unprobed.AvailabilityPct != nil {
+		t.Errorf("unprobed column got AvailabilityPct %v", *unprobed.AvailabilityPct)
+	}
+
+	if unprobed.FirstSeenMs == nil || *unprobed.FirstSeenMs != 1300 {
+		t.Errorf("first seen lost: %v", unprobed.FirstSeenMs)
+	}
+}
+
+func ptr[T any](v T) *T {
+	return &v
+}

clients/consensus/chainspec.go

@@ -136,6 +136,8 @@ type ChainSpecConfig struct {
 	ContributionDueBpsGloas              uint64 `yaml:"CONTRIBUTION_DUE_BPS_GLOAS"                 check-if-fork:"GloasForkEpoch"`
 	SyncMessageDueBpsGloas               uint64 `yaml:"SYNC_MESSAGE_DUE_BPS_GLOAS"                 check-if-fork:"GloasForkEpoch"`
 	PayloadAttestationDueBps             uint64 `yaml:"PAYLOAD_ATTESTATION_DUE_BPS"                check-if-fork:"GloasForkEpoch"`
+	BuilderPaymentThresholdNumerator     uint64 `yaml:"BUILDER_PAYMENT_THRESHOLD_NUMERATOR"        check-if-fork:"GloasForkEpoch"`
+	BuilderPaymentThresholdDenominator   uint64 `yaml:"BUILDER_PAYMENT_THRESHOLD_DENOMINATOR"      check-if-fork:"GloasForkEpoch"`
 	PayloadDueBps                        uint64 `yaml:"PAYLOAD_DUE_BPS"                            check-if-fork:"GloasForkEpoch"`
 	MaxRequestPayloads                   uint64 `yaml:"MAX_REQUEST_PAYLOADS"                       check-if-fork:"GloasForkEpoch"`