execution: treat empty BAL as valid access list (EIP-7928) (#20776)

This update aligns BAL handling with the requirements described in
[EIP-7928](https://eips.ethereum.org/EIPS/eip-7928), which requires that
even an empty BAL be recognized as a legitimate access list. According
to the specification, the header should include the `rlp.encode([])`
hash, while the payload should have the standard empty RLP list
(`0xc0`). Previously, even though the header hash was established
correctly, the BAL bytes themselves were not saved. This effectively
regarded an empty BAL as if it did not exist, contradicting the desired
behavior indicated in the EIP.

With this change, empty BALs are now handled consistently like any other
BAL. The RLP decoder now returns an initialized empty slice instead of
nil, so `0xc0` naturally round-trips through the standard encode/decode
path without special-case logic. The `len(block.BlockAccessList) > 0`
guard in the DB inserter correctly persists the `[]byte{0xc0}` sidecar
(length 1), and the engine API response encodes it back via standard RLP
rules. The payload response path also retains the `br.BlockAccessList !=
nil` guard so that a genuinely missing BAL is never silently emitted as
`0xc0`. This removes any ambiguity between a valid empty BAL and cases
where BAL data is missing or pruned.

Author: Sahil-4555

db/rawdb/accessors_chain_test.go

@@ -1171,7 +1171,10 @@ func TestBlockAccessListStorage(t *testing.T) {
 
 	decoded, err = types.DecodeBlockAccessListBytes(data)
 	require.NoError(t, err)
-	require.Nil(t, decoded)
+	// EIP-7928: Decoding 0xc0 (empty RLP list) should return an initialized empty slice,
+	// rather than nil, to distinguish a valid empty BAL from a missing/pruned one.
+	require.NotNil(t, decoded)
+	require.Empty(t, decoded)
 	require.NoError(t, decoded.Validate())
 	require.Equal(t, empty.BlockAccessListHash, decoded.Hash())
 }

execution/engineapi/engine_server.go

@@ -347,8 +347,13 @@ func (s *EngineServer) newPayload(ctx context.Context, req *engine_types.Executi
 			return nil, &rpc.InvalidParamsError{Message: "blockAccessList missing"}
 		}
 		if len(req.BlockAccessList) == 0 {
-			blockAccessList = nil
-			header.BlockAccessListHash = &empty.BlockAccessListHash
+			blockAccessList = make(types.BlockAccessList, 0)
+			hash := empty.BlockAccessListHash
+			header.BlockAccessListHash = &hash
+			blockAccessListBytes, err = types.EncodeBlockAccessListBytes(blockAccessList)
+			if err != nil {
+				return nil, &rpc.InvalidParamsError{Message: fmt.Sprintf("encode empty blockAccessList: %v", err)}
+			}
 		} else {
 			blockAccessList, err = types.DecodeBlockAccessListBytes(req.BlockAccessList)
 			if err != nil {
@@ -1079,6 +1084,9 @@ func assembledBlockToPayloadResponse(br *types.BlockWithReceipts, blockValue *ui
 		ep.SlotNumber = &sn
 	}
 	if header.BlockAccessListHash != nil && br.BlockAccessList != nil {
+		// EIP-7928: encode even when br.BlockAccessList is empty — an empty
+		// BAL serializes to 0xc0 via standard RLP rules. A nil BAL means
+		// the data is missing/not-populated and should not be emitted.
 		encoded, encErr := types.EncodeBlockAccessListBytes(br.BlockAccessList)
 		if encErr == nil {
 			ep.BlockAccessList = encoded

execution/engineapi/engine_server_getpayload_test.go

@@ -24,7 +24,9 @@ import (
 	"github.com/holiman/uint256"
 	"github.com/stretchr/testify/require"
 
+	"github.com/erigontech/erigon/cl/clparams"
 	"github.com/erigontech/erigon/common"
+	"github.com/erigontech/erigon/common/empty"
 	"github.com/erigontech/erigon/common/hexutil"
 	"github.com/erigontech/erigon/common/log/v3"
 	"github.com/erigontech/erigon/execution/builder"
@@ -74,6 +76,29 @@ func TestGetPayloadV4AcceptsEmptyRequestsBundle(t *testing.T) {
 	require.Len(t, resp.ExecutionRequests, 0)
 }
 
+func TestAssembledBlockToPayloadResponseIncludesCanonicalEmptyBAL(t *testing.T) {
+	t.Parallel()
+
+	baseFee := uint256.NewInt(1_000_000_000)
+	emptyBALHash := empty.BlockAccessListHash
+	header := &types.Header{
+		Number:              *uint256.NewInt(101),
+		Time:                1,
+		BaseFee:             baseFee,
+		GasLimit:            30_000_000,
+		BlockAccessListHash: &emptyBALHash,
+	}
+	block := types.NewBlockWithHeader(header)
+	br := &types.BlockWithReceipts{Block: block, BlockAccessList: make(types.BlockAccessList, 0), Requests: make(types.FlatRequests, 0)}
+
+	resp, err := assembledBlockToPayloadResponse(br, uint256.NewInt(0), clparams.GloasVersion)
+	require.NoError(t, err)
+
+	emptyBAL, err := types.EncodeBlockAccessListBytes(make(types.BlockAccessList, 0))
+	require.NoError(t, err)
+	require.Equal(t, hexutil.Bytes(emptyBAL), resp.ExecutionPayload.BlockAccessList)
+}
+
 func newProposingEngineServerForGetPayloadTests(stub execmodule.ExecutionModule) *EngineServer {
 	cfg := allForksChainConfig()
 	// GetPayloadV4 is valid on Prague but invalid once Osaka activates.

execution/execmodule/inserters.go

@@ -118,14 +118,7 @@ func (e *ExecModule) InsertBlocks(ctx context.Context, blocks []*types.RawBlock)
 			if header.BlockAccessListHash == nil {
 				return 0, fmt.Errorf("ethereumExecutionModule.InsertBlocks: block access list provided without hash for block %d", height)
 			}
-			balBytes := block.BlockAccessList
-			if len(balBytes) == 0 {
-				balBytes, err = types.EncodeBlockAccessListBytes(nil)
-				if err != nil {
-					return 0, fmt.Errorf("ethereumExecutionModule.InsertBlocks: encode empty block access list, block %d: %s", height, err)
-				}
-			}
-			if err := rawdb.WriteBlockAccessListBytes(blockOverlay, header.Hash(), height, balBytes); err != nil {
+			if err := rawdb.WriteBlockAccessListBytes(blockOverlay, header.Hash(), height, block.BlockAccessList); err != nil {
 				return 0, fmt.Errorf("ethereumExecutionModule.InsertBlocks: writeBlockAccessList, block %d: %s", height, err)
 			}
 		}

execution/types/block_access_list.go

@@ -523,6 +523,8 @@ func decodeBlockAccessList(out *BlockAccessList, s *rlp.Stream) error {
 	var size uint64
 	if size, err = s.List(); err != nil {
 		if errors.Is(err, rlp.EOL) {
+			// EOL at List() time means the BAL value is missing/pruned,
+			// not that an empty list (0xc0) was decoded. Return nil.
 			*out = nil
 			return nil
 		}
@@ -558,7 +560,9 @@ func decodeBlockAccessList(out *BlockAccessList, s *rlp.Stream) error {
 		return err
 	}
 	if len(changes) == 0 {
-		*out = nil
+		// EIP-7928: a genuine empty list (0xc0) was successfully decoded.
+		// Return an initialized empty slice, not nil.
+		*out = make(BlockAccessList, 0)
 		return nil
 	}
 	*out = changes
@@ -577,9 +581,6 @@ func DecodeBlockAccessListBytes(data []byte) (BlockAccessList, error) {
 
 // EncodeBlockAccessListBytes encodes a block access list into RLP bytes.
 func EncodeBlockAccessListBytes(bal BlockAccessList) ([]byte, error) {
-	if len(bal) == 0 {
-		return []byte{0xc0}, nil
-	}
 	if err := bal.Validate(); err != nil {
 		return nil, err
 	}

execution/types/block_access_list_test.go

@@ -180,3 +180,39 @@ func TestBlockAccessListHashEmpty(t *testing.T) {
 		t.Fatalf("empty BAL should be valid: %v", err)
 	}
 }
+
+// TestBlockAccessListEmptyRoundTrip verifies that an empty BAL encodes to the
+// canonical empty RLP list (0xc0) and decodes back to a non-nil empty slice.
+// EIP-7928 requires: "When no state changes are present, this field is the
+// empty RLP list 0xc0, i.e. rlp.encode([])."
+func TestBlockAccessListEmptyRoundTrip(t *testing.T) {
+	// Encode nil BAL — must produce 0xc0.
+	encoded, err := EncodeBlockAccessListBytes(nil)
+	if err != nil {
+		t.Fatalf("encode nil BAL: %v", err)
+	}
+	if !bytes.Equal(encoded, []byte{0xc0}) {
+		t.Fatalf("nil BAL encoding: got %x, want c0", encoded)
+	}
+
+	// Encode empty (non-nil) BAL — must also produce 0xc0.
+	encoded2, err := EncodeBlockAccessListBytes(make(BlockAccessList, 0))
+	if err != nil {
+		t.Fatalf("encode empty BAL: %v", err)
+	}
+	if !bytes.Equal(encoded2, []byte{0xc0}) {
+		t.Fatalf("empty BAL encoding: got %x, want c0", encoded2)
+	}
+
+	// Decode 0xc0 — must produce non-nil empty slice (not nil).
+	decoded, err := DecodeBlockAccessListBytes(encoded)
+	if err != nil {
+		t.Fatalf("decode empty BAL: %v", err)
+	}
+	if decoded == nil {
+		t.Fatal("decoded empty BAL must be non-nil")
+	}
+	if len(decoded) != 0 {
+		t.Fatalf("decoded empty BAL length: got %d, want 0", len(decoded))
+	}
+}