split builder & validator pubkey and check builder indexes for index reuse in UI

Author: pk910

handlers/builder.go

@@ -69,11 +69,12 @@ func BuilderDetail(w http.ResponseWriter, r *http.Request) {
 		// search by pubkey - check cache first (more accurate), then fall back to DB
 		var pubkey phase0.BLSPubKey
 		copy(pubkey[:], builderPubKey)
-		if validatorIdx, found := services.GlobalBeaconService.GetValidatorIndexByPubkey(pubkey); found {
-			idx := uint64(validatorIdx)
-			if idx&services.BuilderIndexFlag != 0 {
-				builderIndex = idx &^ services.BuilderIndexFlag
-				builder = services.GlobalBeaconService.GetBuilderByIndex(gloas.BuilderIndex(builderIndex))
+		if builderIdx, found := services.GlobalBeaconService.GetBuilderIndexByPubkey(pubkey); found {
+			// builder indexes can be reused (EIP-8282): only accept the cache hit if this pubkey
+			// still owns the index, otherwise fall through to the DB lookup by pubkey below.
+			if b := services.GlobalBeaconService.GetBuilderByIndex(builderIdx); b != nil && b.PublicKey == pubkey {
+				builderIndex = uint64(builderIdx)
+				builder = b
 			}
 		}
 
@@ -462,33 +463,32 @@ func buildBuilderRecentBids(ctx context.Context, builderIndex uint64, chainState
 func buildBuilderRecentDeposits(ctx context.Context, pubkey []byte, chainState *consensus.ChainState) []*models.BuilderPageDataDeposit {
 	result := make([]*models.BuilderPageDataDeposit, 0)
 
-	// Query deposit requests by builder pubkey
-	depositFilter := &services.CombinedDepositRequestFilter{
-		Filter: &dbtypes.DepositTxFilter{
-			PublicKey:    pubkey,
-			WithOrphaned: 1,
-		},
+	// Query the dedicated builder deposit requests (EIP-8282) by builder pubkey.
+	filter := &dbtypes.BuilderDepositFilter{
+		PublicKey:    pubkey,
+		WithOrphaned: 1,
 	}
-	deposits, _ := services.GlobalBeaconService.GetDepositRequestsByFilter(ctx, depositFilter, 0, 20)
+	deposits, _, _ := services.GlobalBeaconService.GetBuilderDepositsByFilter(ctx, filter, 0, 20)
 	for _, deposit := range deposits {
 		entry := &models.BuilderPageDataDeposit{
-			Type:             "deposit",
-			Amount:           deposit.Amount(),
-			DepositorAddress: deposit.SourceAddress(),
+			Type: "deposit",
 		}
 		if deposit.Request != nil {
 			entry.SlotNumber = deposit.Request.SlotNumber
 			entry.SlotRoot = deposit.Request.SlotRoot
 			entry.Time = chainState.SlotToTime(phase0.Slot(deposit.Request.SlotNumber))
 			entry.Orphaned = deposit.RequestOrphaned
+			entry.Amount = deposit.Request.Amount
 		} else if deposit.Transaction != nil {
-			entry.Time = chainState.SlotToTime(phase0.Slot(deposit.Transaction.BlockTime))
+			entry.Amount = deposit.Transaction.Amount
+			entry.Time = time.Unix(int64(deposit.Transaction.BlockTime), 0)
 		}
 
 		// Add transaction details if available
 		if deposit.Transaction != nil {
 			entry.HasTransaction = true
 			entry.TransactionHash = deposit.Transaction.TxHash
+			entry.DepositorAddress = deposit.Transaction.TxSender
 			entry.TransactionDetails = &models.BuilderPageDataDepositTxDetails{
 				BlockNumber: deposit.Transaction.BlockNumber,
 				BlockHash:   fmt.Sprintf("%#x", deposit.Transaction.BlockRoot),

handlers/builder_deposits.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"net/http"
@@ -12,6 +13,7 @@ import (
 	"github.com/ethpandaops/dora/services"
 	"github.com/ethpandaops/dora/templates"
 	"github.com/ethpandaops/dora/types/models"
+	"github.com/ethpandaops/go-eth2-client/spec/gloas"
 	"github.com/ethpandaops/go-eth2-client/spec/phase0"
 	"github.com/sirupsen/logrus"
 )
@@ -165,6 +167,28 @@ func buildBuilderDepositsPageData(ctx context.Context, pageIdx uint64, pageSize
 
 	chainState := services.GlobalBeaconService.GetChainState()
 
+	// builderIdxOf returns the builder index recorded for a deposit (CL request preferred, else
+	// the pending EL tx), if any.
+	builderIdxOf := func(deposit *services.CombinedBuilderDeposit) *uint64 {
+		if deposit.Request != nil && deposit.Request.BuilderIndex != nil {
+			return deposit.Request.BuilderIndex
+		}
+		if deposit.Transaction != nil && deposit.Transaction.BuilderIndex != nil {
+			return deposit.Transaction.BuilderIndex
+		}
+		return nil
+	}
+
+	// collect the builder indexes to resolve so we can batch-load the builders and tell whether
+	// each pubkey still owns its (reusable) index or was superseded.
+	indexes := make([]gloas.BuilderIndex, 0, len(combined))
+	for _, deposit := range combined {
+		if idx := builderIdxOf(deposit); idx != nil {
+			indexes = append(indexes, gloas.BuilderIndex(*idx))
+		}
+	}
+	builders := services.GlobalBeaconService.GetActiveBuildersByIndexes(ctx, indexes)
+
 	for _, deposit := range combined {
 		depositData := &models.BuilderDepositsPageDataDeposit{}
 
@@ -179,18 +203,19 @@ func buildBuilderDepositsPageData(ctx context.Context, pageIdx uint64, pageSize
 			depositData.Amount = deposit.Request.Amount
 			depositData.Result = deposit.Request.Result
 			depositData.BlockNumber = deposit.Request.BlockNumber
-			if deposit.Request.BuilderIndex != nil {
-				depositData.HasBuilderIndex = true
-				depositData.BuilderIndex = *deposit.Request.BuilderIndex
-			}
 		} else if deposit.Transaction != nil {
 			depositData.PublicKey = deposit.Transaction.PublicKey
 			depositData.WithdrawalCredentials = deposit.Transaction.WithdrawalCredentials
 			depositData.Amount = deposit.Transaction.Amount
 			depositData.BlockNumber = deposit.Transaction.BlockNumber
-			if deposit.Transaction.BuilderIndex != nil {
+		}
+
+		if idx := builderIdxOf(deposit); idx != nil {
+			if b := builders[gloas.BuilderIndex(*idx)]; b != nil && bytes.Equal(b.PublicKey[:], depositData.PublicKey) {
 				depositData.HasBuilderIndex = true
-				depositData.BuilderIndex = *deposit.Transaction.BuilderIndex
+				depositData.BuilderIndex = *idx
+			} else {
+				depositData.IsInactiveBuilder = true
 			}
 		}
 

handlers/builder_exits.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"net/http"
@@ -12,6 +13,7 @@ import (
 	"github.com/ethpandaops/dora/services"
 	"github.com/ethpandaops/dora/templates"
 	"github.com/ethpandaops/dora/types/models"
+	"github.com/ethpandaops/go-eth2-client/spec/gloas"
 	"github.com/ethpandaops/go-eth2-client/spec/phase0"
 	"github.com/sirupsen/logrus"
 )
@@ -153,6 +155,28 @@ func buildBuilderExitsPageData(ctx context.Context, pageIdx uint64, pageSize uin
 
 	chainState := services.GlobalBeaconService.GetChainState()
 
+	// builderIdxOf returns the builder index recorded for an exit (CL request preferred, else the
+	// pending EL tx), if any.
+	builderIdxOf := func(exit *services.CombinedBuilderExit) *uint64 {
+		if exit.Request != nil && exit.Request.BuilderIndex != nil {
+			return exit.Request.BuilderIndex
+		}
+		if exit.Transaction != nil && exit.Transaction.BuilderIndex != nil {
+			return exit.Transaction.BuilderIndex
+		}
+		return nil
+	}
+
+	// collect the builder indexes to resolve so we can batch-load the builders and tell whether
+	// each pubkey still owns its (reusable) index or was superseded.
+	indexes := make([]gloas.BuilderIndex, 0, len(combined))
+	for _, exit := range combined {
+		if idx := builderIdxOf(exit); idx != nil {
+			indexes = append(indexes, gloas.BuilderIndex(*idx))
+		}
+	}
+	builders := services.GlobalBeaconService.GetActiveBuildersByIndexes(ctx, indexes)
+
 	for _, exit := range combined {
 		exitData := &models.BuilderExitsPageDataExit{}
 
@@ -166,17 +190,18 @@ func buildBuilderExitsPageData(ctx context.Context, pageIdx uint64, pageSize uin
 			exitData.PublicKey = exit.Request.PublicKey
 			exitData.Result = exit.Request.Result
 			exitData.BlockNumber = exit.Request.BlockNumber
-			if exit.Request.BuilderIndex != nil {
-				exitData.HasBuilderIndex = true
-				exitData.BuilderIndex = *exit.Request.BuilderIndex
-			}
 		} else if exit.Transaction != nil {
 			exitData.SourceAddress = exit.Transaction.SourceAddress
 			exitData.PublicKey = exit.Transaction.PublicKey
 			exitData.BlockNumber = exit.Transaction.BlockNumber
-			if exit.Transaction.BuilderIndex != nil {
+		}
+
+		if idx := builderIdxOf(exit); idx != nil {
+			if b := builders[gloas.BuilderIndex(*idx)]; b != nil && bytes.Equal(b.PublicKey[:], exitData.PublicKey) {
 				exitData.HasBuilderIndex = true
-				exitData.BuilderIndex = *exit.Transaction.BuilderIndex
+				exitData.BuilderIndex = *idx
+			} else {
+				exitData.IsInactiveBuilder = true
 			}
 		}
 

handlers/slot.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"bytes"
 	"context"
 	"encoding/hex"
 	"encoding/json"
@@ -981,8 +982,8 @@ func getSlotPageBlockData(ctx context.Context, blockData *services.CombinedBlock
 			getSlotPageDepositRequests(pageData, requests.Deposits)
 			getSlotPageWithdrawalRequests(pageData, requests.Withdrawals)
 			getSlotPageConsolidationRequests(pageData, requests.Consolidations)
-			getSlotPageBuilderDeposits(pageData, requests.BuilderDeposits)
-			getSlotPageBuilderExits(pageData, requests.BuilderExits)
+			getSlotPageBuilderDeposits(ctx, pageData, requests.BuilderDeposits)
+			getSlotPageBuilderExits(ctx, pageData, requests.BuilderExits)
 		}
 	}
 
@@ -1322,22 +1323,37 @@ func getSlotPageConsolidationRequests(pageData *models.SlotPageBlockData, consol
 	pageData.ConsolidationRequestsCount = uint64(len(pageData.ConsolidationRequests))
 }
 
-func getSlotPageBuilderDeposits(pageData *models.SlotPageBlockData, builderDeposits []*gloas.BuilderDepositRequest) {
+func getSlotPageBuilderDeposits(ctx context.Context, pageData *models.SlotPageBlockData, builderDeposits []*gloas.BuilderDepositRequest) {
 	pageData.BuilderDepositRequests = make([]*models.SlotPageBuilderDepositRequest, 0, len(builderDeposits))
 
-	for _, builderDeposit := range builderDeposits {
+	// resolve pubkeys -> builder indexes first, then batch-load the builders for those indexes to
+	// tell whether each pubkey still owns its (reusable) index or was superseded.
+	resolvedIdx := make([]gloas.BuilderIndex, len(builderDeposits))
+	resolvedOk := make([]bool, len(builderDeposits))
+	indexes := make([]gloas.BuilderIndex, 0, len(builderDeposits))
+	for i, builderDeposit := range builderDeposits {
+		if builderIdx, found := services.GlobalBeaconService.GetBuilderIndexByPubkey(builderDeposit.Pubkey); found {
+			resolvedIdx[i] = builderIdx
+			resolvedOk[i] = true
+			indexes = append(indexes, builderIdx)
+		}
+	}
+	builders := services.GlobalBeaconService.GetActiveBuildersByIndexes(ctx, indexes)
+
+	for i, builderDeposit := range builderDeposits {
 		requestData := &models.SlotPageBuilderDepositRequest{
 			PublicKey:       builderDeposit.Pubkey[:],
 			WithdrawalCreds: builderDeposit.WithdrawalCredentials,
 			Amount:          uint64(builderDeposit.Amount),
 			Signature:       builderDeposit.Signature[:],
 		}
 
-		if rawIdx, found := services.GlobalBeaconService.GetValidatorIndexByPubkey(builderDeposit.Pubkey); found {
-			fullIndex := uint64(rawIdx)
-			if fullIndex&services.BuilderIndexFlag != 0 {
+		if resolvedOk[i] {
+			if b := builders[resolvedIdx[i]]; b != nil && bytes.Equal(b.PublicKey[:], builderDeposit.Pubkey[:]) {
 				requestData.HasBuilderIndex = true
-				requestData.BuilderIndex = fullIndex &^ services.BuilderIndexFlag
+				requestData.BuilderIndex = uint64(resolvedIdx[i])
+			} else {
+				requestData.IsInactiveBuilder = true
 			}
 		}
 
@@ -1347,20 +1363,33 @@ func getSlotPageBuilderDeposits(pageData *models.SlotPageBlockData, builderDepos
 	pageData.BuilderDepositRequestsCount = uint64(len(pageData.BuilderDepositRequests))
 }
 
-func getSlotPageBuilderExits(pageData *models.SlotPageBlockData, builderExits []*gloas.BuilderExitRequest) {
+func getSlotPageBuilderExits(ctx context.Context, pageData *models.SlotPageBlockData, builderExits []*gloas.BuilderExitRequest) {
 	pageData.BuilderExitRequests = make([]*models.SlotPageBuilderExitRequest, 0, len(builderExits))
 
-	for _, builderExit := range builderExits {
+	resolvedIdx := make([]gloas.BuilderIndex, len(builderExits))
+	resolvedOk := make([]bool, len(builderExits))
+	indexes := make([]gloas.BuilderIndex, 0, len(builderExits))
+	for i, builderExit := range builderExits {
+		if builderIdx, found := services.GlobalBeaconService.GetBuilderIndexByPubkey(builderExit.Pubkey); found {
+			resolvedIdx[i] = builderIdx
+			resolvedOk[i] = true
+			indexes = append(indexes, builderIdx)
+		}
+	}
+	builders := services.GlobalBeaconService.GetActiveBuildersByIndexes(ctx, indexes)
+
+	for i, builderExit := range builderExits {
 		requestData := &models.SlotPageBuilderExitRequest{
 			SourceAddress: builderExit.SourceAddress[:],
 			PublicKey:     builderExit.Pubkey[:],
 		}
 
-		if rawIdx, found := services.GlobalBeaconService.GetValidatorIndexByPubkey(builderExit.Pubkey); found {
-			fullIndex := uint64(rawIdx)
-			if fullIndex&services.BuilderIndexFlag != 0 {
+		if resolvedOk[i] {
+			if b := builders[resolvedIdx[i]]; b != nil && bytes.Equal(b.PublicKey[:], builderExit.Pubkey[:]) {
 				requestData.HasBuilderIndex = true
-				requestData.BuilderIndex = fullIndex &^ services.BuilderIndexFlag
+				requestData.BuilderIndex = uint64(resolvedIdx[i])
+			} else {
+				requestData.IsInactiveBuilder = true
 			}
 		}
 

indexer/beacon/buildercache.go

@@ -133,7 +133,7 @@ func (cache *builderCache) updateBuilderSet(slot phase0.Slot, dependentRoot phas
 			cachedBuilder = &builderEntry{}
 			cache.builderSetCache[i] = cachedBuilder
 
-			cache.indexer.pubkeyCache.Add(builders[i].PublicKey, phase0.ValidatorIndex(uint64(i)|BuilderIndexFlag))
+			_ = cache.indexer.builderPubkeyCache.Add(builders[i].PublicKey, phase0.ValidatorIndex(uint64(i)))
 		} else {
 			parentBuilder = cachedBuilder.finalBuilder
 			parentChecksum = cachedBuilder.finalChecksum
@@ -557,7 +557,7 @@ func (cache *builderCache) prepopulateFromDB() (uint64, error) {
 
 			cache.builderSetCache[dbBuilder.BuilderIndex] = builderEntry
 
-			cache.indexer.pubkeyCache.Add(builder.PublicKey, phase0.ValidatorIndex(dbBuilder.BuilderIndex|BuilderIndexFlag))
+			_ = cache.indexer.builderPubkeyCache.Add(builder.PublicKey, phase0.ValidatorIndex(dbBuilder.BuilderIndex))
 
 			restoreCount++
 		}

indexer/beacon/indexer.go

@@ -47,6 +47,7 @@ type Indexer struct {
 	epochCache         *epochCache
 	forkCache          *forkCache
 	pubkeyCache        *pubkeyCache
+	builderPubkeyCache *pubkeyCache
 	validatorCache     *validatorCache
 	pendingValidators  *pendingValidatorProjector
 	validatorActivity  *validatorActivityCache
@@ -123,6 +124,10 @@ func NewIndexer(ctx context.Context, logger logrus.FieldLogger, consensusPool *c
 	indexer.epochCache = newEpochCache(indexer)
 	indexer.forkCache = newForkCache(indexer)
 	indexer.pubkeyCache = newPubkeyCache(indexer, utils.Config.Indexer.PubkeyCachePath)
+	// builders (EIP-8282) live in a separate index space and may share pubkeys with validators,
+	// so they get their own pubkey cache. It reuses the validator cache's backing store (same
+	// file) but namespaces builder keys with a prefix to avoid collisions.
+	indexer.builderPubkeyCache = indexer.pubkeyCache.newPrefixedCache([]byte(pubkeyCacheBuilderPrefix))
 	indexer.validatorCache = newValidatorCache(indexer)
 	indexer.pendingValidators = newPendingValidatorProjector(indexer)
 	indexer.validatorActivity = newValidatorActivityCache(indexer)
@@ -486,6 +491,7 @@ func (indexer *Indexer) StopIndexer() {
 	}
 
 	indexer.pubkeyCache.Close()
+	// builderPubkeyCache shares pubkeyCache's store, so it is closed by the line above.
 	indexer.stateCache.Close()
 }