Fix envelopes-by-range to only serve canonical payloads via backward walk

Author: terencechain

beacon-chain/blockchain/gloas_test.go

@@ -782,11 +782,17 @@ func TestSaveHead_GloasForkBoundary_PreforkBidForcesEmptyHead(t *testing.T) {
 		LatestBlockHeader:          &ethpb.BeaconBlockHeader{ParentRoot: make([]byte, 32), StateRoot: make([]byte, 32), BodyRoot: make([]byte, 32)},
 		Eth1Data:                   &ethpb.Eth1Data{DepositRoot: make([]byte, 32), BlockHash: make([]byte, 32)},
 		LatestExecutionPayloadBid:  &ethpb.ExecutionPayloadBid{BlockHash: make([]byte, 32), ParentBlockHash: make([]byte, 32), ParentBlockRoot: make([]byte, 32), PrevRandao: make([]byte, 32), FeeRecipient: make([]byte, 20), BlobKzgCommitments: [][]byte{make([]byte, 48)}},
-		BuilderPendingPayments:     func() []*ethpb.BuilderPendingPayment { pp := make([]*ethpb.BuilderPendingPayment, 64); for i := range pp { pp[i] = &ethpb.BuilderPendingPayment{Withdrawal: &ethpb.BuilderPendingWithdrawal{FeeRecipient: make([]byte, 20)}} }; return pp }(),
+		BuilderPendingPayments: func() []*ethpb.BuilderPendingPayment {
+			pp := make([]*ethpb.BuilderPendingPayment, 64)
+			for i := range pp {
+				pp[i] = &ethpb.BuilderPendingPayment{Withdrawal: &ethpb.BuilderPendingWithdrawal{FeeRecipient: make([]byte, 20)}}
+			}
+			return pp
+		}(),
 		ExecutionPayloadAvailability: make([]byte, 1024),
-		LatestBlockHash:            make([]byte, 32),
-		PayloadExpectedWithdrawals: make([]*enginev1.Withdrawal, 0),
-		ProposerLookahead:          make([]uint64, 64),
+		LatestBlockHash:              make([]byte, 32),
+		PayloadExpectedWithdrawals:   make([]*enginev1.Withdrawal, 0),
+		ProposerLookahead:            make([]uint64, 64),
 	})
 	require.NoError(t, err2)
 	oldRoot := bytesutil.ToBytes32([]byte("oldroot1"))
@@ -853,11 +859,17 @@ func TestSaveHead_GloasForkBoundary_PostforkBidSetsFullHead(t *testing.T) {
 		LatestBlockHeader:          &ethpb.BeaconBlockHeader{ParentRoot: make([]byte, 32), StateRoot: make([]byte, 32), BodyRoot: make([]byte, 32)},
 		Eth1Data:                   &ethpb.Eth1Data{DepositRoot: make([]byte, 32), BlockHash: make([]byte, 32)},
 		LatestExecutionPayloadBid:  &ethpb.ExecutionPayloadBid{BlockHash: make([]byte, 32), ParentBlockHash: make([]byte, 32), ParentBlockRoot: make([]byte, 32), PrevRandao: make([]byte, 32), FeeRecipient: make([]byte, 20), BlobKzgCommitments: [][]byte{make([]byte, 48)}},
-		BuilderPendingPayments:     func() []*ethpb.BuilderPendingPayment { pp := make([]*ethpb.BuilderPendingPayment, 64); for i := range pp { pp[i] = &ethpb.BuilderPendingPayment{Withdrawal: &ethpb.BuilderPendingWithdrawal{FeeRecipient: make([]byte, 20)}} }; return pp }(),
+		BuilderPendingPayments: func() []*ethpb.BuilderPendingPayment {
+			pp := make([]*ethpb.BuilderPendingPayment, 64)
+			for i := range pp {
+				pp[i] = &ethpb.BuilderPendingPayment{Withdrawal: &ethpb.BuilderPendingWithdrawal{FeeRecipient: make([]byte, 20)}}
+			}
+			return pp
+		}(),
 		ExecutionPayloadAvailability: make([]byte, 1024),
-		LatestBlockHash:            make([]byte, 32),
-		PayloadExpectedWithdrawals: make([]*enginev1.Withdrawal, 0),
-		ProposerLookahead:          make([]uint64, 64),
+		LatestBlockHash:              make([]byte, 32),
+		PayloadExpectedWithdrawals:   make([]*enginev1.Withdrawal, 0),
+		ProposerLookahead:            make([]uint64, 64),
 	})
 	require.NoError(t, err2)
 	oldRoot2 := bytesutil.ToBytes32([]byte("oldroot2"))

beacon-chain/db/iface/interface.go

@@ -34,6 +34,7 @@ type ReadOnlyDatabase interface {
 	IsFinalizedBlock(ctx context.Context, blockRoot [32]byte) bool
 	FinalizedChildBlock(ctx context.Context, blockRoot [32]byte) (interfaces.ReadOnlySignedBeaconBlock, error)
 	HighestRootsBelowSlot(ctx context.Context, slot primitives.Slot) (primitives.Slot, [][32]byte, error)
+	LowestRootsAboveSlot(ctx context.Context, slot primitives.Slot) (primitives.Slot, [][32]byte, error)
 	EarliestSlot(ctx context.Context) (primitives.Slot, error)
 	// State related methods.
 	State(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
@@ -68,6 +69,7 @@ type ReadOnlyDatabase interface {
 
 	// Execution payload envelope operations (Gloas+).
 	ExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]byte) (*ethpb.SignedBlindedExecutionPayloadEnvelope, error)
+	ExecutionPayloadEnvelopeByBlockHash(ctx context.Context, blockHash [32]byte) (*ethpb.SignedBlindedExecutionPayloadEnvelope, error)
 	HasExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]byte) bool
 
 	// P2P Metadata operations.

beacon-chain/db/kv/blocks.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"math"
 	"slices"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db/filters"
@@ -808,6 +809,43 @@ func (s *Store) HighestRootsBelowSlot(ctx context.Context, slot primitives.Slot)
 	return fs, roots, nil
 }
 
+// LowestRootsAboveSlot returns roots from the database slot index from the lowest slot above the input slot.
+// The returned slot is the slot where the roots were found. This is the mirror of HighestRootsBelowSlot.
+// If no block exists above the given slot, an empty root slice is returned.
+func (s *Store) LowestRootsAboveSlot(ctx context.Context, slot primitives.Slot) (fs primitives.Slot, roots [][32]byte, err error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.LowestRootsAboveSlot")
+	defer span.End()
+
+	// Guard against overflow: if slot is already max, nothing can be above it.
+	if slot == math.MaxUint64 {
+		return 0, nil, nil
+	}
+	// Seek to slot+1 so we find the first key strictly above slot.
+	sk := bytesutil.Uint64ToBytesBigEndian(uint64(slot + 1))
+	err = s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(blockSlotIndicesBucket)
+		c := bkt.Cursor()
+		// Seek positions the cursor at the smallest key >= sk.
+		// If no key >= sk exists, sl is nil and we return empty.
+		for sl, r := c.Seek(sk); sl != nil; sl, r = c.Next() {
+			if ctx.Err() != nil {
+				return ctx.Err()
+			}
+			if r == nil {
+				continue
+			}
+			fs = bytesutil.BytesToSlotBigEndian(sl)
+			roots, err = splitRoots(r)
+			if err != nil {
+				return errors.Wrapf(err, "error parsing packed roots %#x", r)
+			}
+			return nil
+		}
+		return nil
+	})
+	return fs, roots, err
+}
+
 // FeeRecipientByValidatorID returns the fee recipient for a validator id.
 // `ErrNotFoundFeeRecipient` is returned if the validator id is not found.
 func (s *Store) FeeRecipientByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (common.Address, error) {

beacon-chain/db/kv/blocks_test.go

@@ -3,6 +3,7 @@ package kv
 import (
 	"context"
 	"fmt"
+	"math"
 	"testing"
 	"time"
 
@@ -1460,3 +1461,51 @@ func TestStore_EarliestSlot(t *testing.T) {
 		assert.Equal(t, nextEpochSlot, slot)
 	})
 }
+
+func TestStore_LowestRootsAboveSlot(t *testing.T) {
+	for _, tt := range blockTests {
+		t.Run(tt.name, func(t *testing.T) {
+			db := setupDB(t)
+			ctx := t.Context()
+
+			block1, err := tt.newBlock(primitives.Slot(10), nil)
+			require.NoError(t, err)
+			block2, err := tt.newBlock(primitives.Slot(50), nil)
+			require.NoError(t, err)
+			block3, err := tt.newBlock(primitives.Slot(100), nil)
+			require.NoError(t, err)
+
+			require.NoError(t, db.SaveBlock(ctx, block1))
+			require.NoError(t, db.SaveBlock(ctx, block2))
+			require.NoError(t, db.SaveBlock(ctx, block3))
+
+			// Exact next-slot hit: slot 9 → block at slot 10.
+			foundSlot, roots, err := db.LowestRootsAboveSlot(ctx, 9)
+			require.NoError(t, err)
+			require.Equal(t, 1, len(roots))
+			assert.Equal(t, primitives.Slot(10), foundSlot)
+
+			// Gap across missed slots: slot 10 → block at slot 50 (slots 11-49 missing).
+			foundSlot, roots, err = db.LowestRootsAboveSlot(ctx, 10)
+			require.NoError(t, err)
+			require.Equal(t, 1, len(roots))
+			assert.Equal(t, primitives.Slot(50), foundSlot)
+
+			// Another gap: slot 50 → block at slot 100.
+			foundSlot, roots, err = db.LowestRootsAboveSlot(ctx, 50)
+			require.NoError(t, err)
+			require.Equal(t, 1, len(roots))
+			assert.Equal(t, primitives.Slot(100), foundSlot)
+
+			// No slot above: slot 100 is the last block.
+			_, roots, err = db.LowestRootsAboveSlot(ctx, 100)
+			require.NoError(t, err)
+			assert.Equal(t, 0, len(roots))
+
+			// Max-slot overflow: should return empty, not wrap to 0.
+			_, roots, err = db.LowestRootsAboveSlot(ctx, math.MaxUint64)
+			require.NoError(t, err)
+			assert.Equal(t, 0, len(roots))
+		})
+	}
+}

beacon-chain/db/kv/execution_payload_envelope.go

@@ -15,6 +15,8 @@ import (
 // beacon block root. The envelope is stored in blinded form: the full execution payload is replaced
 // with its block hash. The full payload can later be retrieved from the EL via
 // engine_getPayloadBodiesByHash.
+// A secondary index from BlockHash → BeaconBlockRoot is maintained so that
+// envelopes can be looked up by execution block hash.
 func (s *Store) SaveExecutionPayloadEnvelope(ctx context.Context, env *ethpb.SignedExecutionPayloadEnvelope) error {
 	_, span := trace.StartSpan(ctx, "BeaconDB.SaveExecutionPayloadEnvelope")
 	defer span.End()
@@ -24,6 +26,7 @@ func (s *Store) SaveExecutionPayloadEnvelope(ctx context.Context, env *ethpb.Sig
 	}
 
 	blockRoot := bytesutil.ToBytes32(env.Message.BeaconBlockRoot)
+	blockHash := bytesutil.ToBytes32(env.Message.Payload.BlockHash)
 	blinded := blindEnvelope(env)
 
 	enc, err := encodeBlindedEnvelope(blinded)
@@ -32,8 +35,10 @@ func (s *Store) SaveExecutionPayloadEnvelope(ctx context.Context, env *ethpb.Sig
 	}
 
 	return s.db.Update(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(executionPayloadEnvelopesBucket)
-		return bkt.Put(blockRoot[:], enc)
+		if err := tx.Bucket(executionPayloadEnvelopesBucket).Put(blockRoot[:], enc); err != nil {
+			return err
+		}
+		return tx.Bucket(executionPayloadEnvelopeBlockHashBucket).Put(blockHash[:], blockRoot[:])
 	})
 }
 
@@ -56,6 +61,30 @@ func (s *Store) ExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]byte
 	return decodeBlindedEnvelope(enc)
 }
 
+// ExecutionPayloadEnvelopeByBlockHash retrieves the blinded signed execution payload envelope
+// by execution block hash. It uses the secondary BlockHash → BeaconBlockRoot index and then
+// fetches the envelope from the primary bucket.
+func (s *Store) ExecutionPayloadEnvelopeByBlockHash(ctx context.Context, blockHash [32]byte) (*ethpb.SignedBlindedExecutionPayloadEnvelope, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.ExecutionPayloadEnvelopeByBlockHash")
+	defer span.End()
+
+	var enc []byte
+	if err := s.db.View(func(tx *bolt.Tx) error {
+		blockRoot := tx.Bucket(executionPayloadEnvelopeBlockHashBucket).Get(blockHash[:])
+		if blockRoot == nil {
+			return nil
+		}
+		enc = tx.Bucket(executionPayloadEnvelopesBucket).Get(blockRoot)
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+	if enc == nil {
+		return nil, errors.Wrap(ErrNotFound, "execution payload envelope not found for block hash")
+	}
+	return decodeBlindedEnvelope(enc)
+}
+
 // HasExecutionPayloadEnvelope checks whether an execution payload envelope exists for the given beacon block root.
 func (s *Store) HasExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]byte) bool {
 	_, span := trace.StartSpan(ctx, "BeaconDB.HasExecutionPayloadEnvelope")
@@ -72,13 +101,25 @@ func (s *Store) HasExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]b
 	return exists
 }
 
-// DeleteExecutionPayloadEnvelope removes a signed execution payload envelope by beacon block root.
+// DeleteExecutionPayloadEnvelope removes a signed execution payload envelope by beacon block root
+// and cleans up the BlockHash index entry.
 func (s *Store) DeleteExecutionPayloadEnvelope(ctx context.Context, blockRoot [32]byte) error {
 	_, span := trace.StartSpan(ctx, "BeaconDB.DeleteExecutionPayloadEnvelope")
 	defer span.End()
 
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(executionPayloadEnvelopesBucket)
+		// Read the existing entry to find the BlockHash for index cleanup.
+		enc := bkt.Get(blockRoot[:])
+		if enc != nil {
+			blinded, err := decodeBlindedEnvelope(enc)
+			if err == nil && blinded.Message != nil {
+				blockHash := bytesutil.ToBytes32(blinded.Message.BlockHash)
+				if err := tx.Bucket(executionPayloadEnvelopeBlockHashBucket).Delete(blockHash[:]); err != nil {
+					return err
+				}
+			}
+		}
 		return bkt.Delete(blockRoot[:])
 	})
 }
@@ -95,6 +136,7 @@ func blindEnvelope(env *ethpb.SignedExecutionPayloadEnvelope) *ethpb.SignedBlind
 			BeaconBlockRoot:   env.Message.BeaconBlockRoot,
 			Slot:              env.Message.Slot,
 			StateRoot:         env.Message.StateRoot,
+			ParentBlockHash:   env.Message.Payload.ParentHash,
 		},
 		Signature: env.Signature,
 	}

beacon-chain/db/kv/execution_payload_envelope_test.go

@@ -1,6 +1,7 @@
 package kv
 
 import (
+	"bytes"
 	"context"
 	"testing"
 
@@ -75,6 +76,7 @@ func TestStore_SaveAndRetrieveExecutionPayloadEnvelope(t *testing.T) {
 
 	// BlockHash should be the payload's block hash (not a hash tree root).
 	assert.DeepEqual(t, env.Message.Payload.BlockHash, loaded.Message.BlockHash)
+	assert.Equal(t, true, bytes.Equal(env.Message.Payload.ParentHash, loaded.Message.ParentBlockHash))
 }
 
 func TestStore_DeleteExecutionPayloadEnvelope(t *testing.T) {
@@ -107,13 +109,60 @@ func TestStore_SaveExecutionPayloadEnvelope_NilRejected(t *testing.T) {
 	require.ErrorContains(t, "nil", err)
 }
 
+func TestStore_ExecutionPayloadEnvelopeByBlockHash(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	env := testEnvelope(t)
+	blockHash := bytesutil.ToBytes32(env.Message.Payload.BlockHash)
+
+	// Save envelope — should populate both primary and BlockHash index.
+	require.NoError(t, db.SaveExecutionPayloadEnvelope(ctx, env))
+
+	// Look up by block hash.
+	loaded, err := db.ExecutionPayloadEnvelopeByBlockHash(ctx, blockHash)
+	require.NoError(t, err)
+	assert.Equal(t, env.Message.Slot, loaded.Message.Slot)
+	assert.DeepEqual(t, env.Message.Payload.BlockHash, loaded.Message.BlockHash)
+	assert.Equal(t, true, bytes.Equal(env.Message.Payload.ParentHash, loaded.Message.ParentBlockHash))
+}
+
+func TestStore_ExecutionPayloadEnvelopeByBlockHash_NotFound(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	nonExistent := bytesutil.ToBytes32([]byte("nonexistent"))
+
+	_, err := db.ExecutionPayloadEnvelopeByBlockHash(ctx, nonExistent)
+	require.ErrorContains(t, "not found", err)
+}
+
+func TestStore_DeleteExecutionPayloadEnvelope_CleansBlockHashIndex(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	env := testEnvelope(t)
+	blockRoot := bytesutil.ToBytes32(env.Message.BeaconBlockRoot)
+	blockHash := bytesutil.ToBytes32(env.Message.Payload.BlockHash)
+
+	require.NoError(t, db.SaveExecutionPayloadEnvelope(ctx, env))
+
+	// Verify BlockHash lookup works before delete.
+	_, err := db.ExecutionPayloadEnvelopeByBlockHash(ctx, blockHash)
+	require.NoError(t, err)
+
+	// Delete should clean up both buckets.
+	require.NoError(t, db.DeleteExecutionPayloadEnvelope(ctx, blockRoot))
+
+	_, err = db.ExecutionPayloadEnvelopeByBlockHash(ctx, blockHash)
+	require.ErrorContains(t, "not found", err)
+}
+
 func TestBlindEnvelope_PreservesBlockHash(t *testing.T) {
 	env := testEnvelope(t)
 
 	blinded := blindEnvelope(env)
 
 	// Should contain the block hash from the payload, not a hash tree root.
 	assert.DeepEqual(t, env.Message.Payload.BlockHash, blinded.Message.BlockHash)
+	assert.Equal(t, true, bytes.Equal(env.Message.Payload.ParentHash, blinded.Message.ParentBlockHash))
 
 	// Metadata should be preserved.
 	assert.Equal(t, env.Message.BuilderIndex, blinded.Message.BuilderIndex)

beacon-chain/db/kv/kv.go

@@ -127,6 +127,7 @@ var Buckets = [][]byte{
 	registrationBucket,
 	custodyBucket,
 	executionPayloadEnvelopesBucket,
+	executionPayloadEnvelopeBlockHashBucket,
 }
 
 // KVStoreOption is a functional option that modifies a kv.Store.

beacon-chain/db/kv/schema.go

@@ -7,17 +7,18 @@ package kv
 // it easy to scan for keys that have a certain shard number as a prefix and return those
 // corresponding attestations.
 var (
-	blocksBucket                    = []byte("blocks")
-	stateBucket                     = []byte("state")
-	stateSummaryBucket              = []byte("state-summary")
-	chainMetadataBucket             = []byte("chain-metadata")
-	checkpointBucket                = []byte("check-point")
-	powchainBucket                  = []byte("powchain")
-	stateValidatorsBucket           = []byte("state-validators")
-	feeRecipientBucket              = []byte("fee-recipient")
-	registrationBucket              = []byte("registration")
-	stateDiffBucket                 = []byte("state-diff")
-	executionPayloadEnvelopesBucket = []byte("execution-payload-envelopes")
+	blocksBucket                            = []byte("blocks")
+	stateBucket                             = []byte("state")
+	stateSummaryBucket                      = []byte("state-summary")
+	chainMetadataBucket                     = []byte("chain-metadata")
+	checkpointBucket                        = []byte("check-point")
+	powchainBucket                          = []byte("powchain")
+	stateValidatorsBucket                   = []byte("state-validators")
+	feeRecipientBucket                      = []byte("fee-recipient")
+	registrationBucket                      = []byte("registration")
+	stateDiffBucket                         = []byte("state-diff")
+	executionPayloadEnvelopesBucket         = []byte("execution-payload-envelopes")
+	executionPayloadEnvelopeBlockHashBucket = []byte("execution-payload-envelope-block-hash-index")
 
 	// Light Client Updates Bucket
 	lightClientUpdatesBucket       = []byte("light-client-updates")