feat(core/types): fine-grained Body RLP override

core/types/block.libevm.go

@@ -1,4 +1,4 @@
-// Copyright 2024 the libevm authors.
+// Copyright 2024-2025 the libevm authors.
 //
 // The libevm additions to go-ethereum are free software: you can redistribute
 // them and/or modify them under the terms of the GNU Lesser General Public License
@@ -22,6 +22,7 @@ import (
 	"io"
 
 	"github.com/ava-labs/libevm/libevm/pseudo"
+	"github.com/ava-labs/libevm/libevm/testonly"
 	"github.com/ava-labs/libevm/rlp"
 )
 
@@ -108,3 +109,93 @@ func (*NOOPHeaderHooks) DecodeRLP(h *Header, s *rlp.Stream) error {
 	type withoutMethods Header
 	return s.Decode((*withoutMethods)(h))
 }
+
+var (
+	_ interface {
+		rlp.Encoder
+		rlp.Decoder
+	} = (*Body)(nil)
+
+	// The implementations of [Body.EncodeRLP] and [Body.DecodeRLP] make
+	// assumptions about the struct fields, which we lock in here as a change
+	// detector. If this breaks then it MUST be updated and the RLP methods
+	// reviewed + new backwards-compatibility tests added.
+	_ = &Body{[]*Transaction{}, []*Header{}, []*Withdrawal{}}
+)
+
+// EncodeRLP implements the [rlp.Encoder] interface.
+func (b *Body) EncodeRLP(dst io.Writer) error {
+	w := rlp.NewEncoderBuffer(dst)
+
+	return w.InList(func() error {
+		if err := rlp.EncodeListToBuffer(w, b.Transactions); err != nil {
+			return err
+		}
+		if err := rlp.EncodeListToBuffer(w, b.Uncles); err != nil {
+			return err
+		}
+
+		hasLaterOptionalField := b.Withdrawals != nil
+		if err := b.hooks().AppendRLPFields(w, hasLaterOptionalField); err != nil {
+			return err
+		}
+		if !hasLaterOptionalField {
+			return nil
+		}
+		return rlp.EncodeListToBuffer(w, b.Withdrawals)
+	})
+}
+
+// DecodeRLP implements the [rlp.Decoder] interface.
+func (b *Body) DecodeRLP(s *rlp.Stream) error {
+	return s.FromList(func() error {
+		txs, err := rlp.DecodeList[Transaction](s)
+		if err != nil {
+			return err
+		}
+		uncles, err := rlp.DecodeList[Header](s)
+		if err != nil {
+			return err
+		}
+		*b = Body{
+			Transactions: txs,
+			Uncles:       uncles,
+		}
+
+		if err := b.hooks().DecodeExtraRLPFields(s); err != nil {
+			return err
+		}
+		if !s.MoreDataInList() {
+			return nil
+		}
+
+		ws, err := rlp.DecodeList[Withdrawal](s)
+		if err != nil {
+			return err
+		}
+		b.Withdrawals = ws
+		return nil
+	})
+}
+
+type BodyHooks interface {
+	AppendRLPFields(_ rlp.EncoderBuffer, mustWriteEmptyOptional bool) error
+	DecodeExtraRLPFields(*rlp.Stream) error
+}
+
+func TestOnlyRegisterBodyHooks(h BodyHooks) {
+	testonly.OrPanic(func() {
+		todoRegisteredBodyHooks = h
+	})
+}
+
+var todoRegisteredBodyHooks BodyHooks = NOOPBodyHooks{}
+
+func (b *Body) hooks() BodyHooks {
+	return todoRegisteredBodyHooks
+}
+
+type NOOPBodyHooks struct{}
+
+func (NOOPBodyHooks) AppendRLPFields(rlp.EncoderBuffer, bool) error { return nil }
+func (NOOPBodyHooks) DecodeExtraRLPFields(*rlp.Stream) error        { return nil }

core/types/rlp_backwards_compat.libevm_test.go

@@ -1,4 +1,4 @@
-// Copyright 2024 the libevm authors.
+// Copyright 2024-2025 the libevm authors.
 //
 // The libevm additions to go-ethereum are free software: you can redistribute
 // them and/or modify them under the terms of the GNU Lesser General Public License
@@ -18,12 +18,16 @@ package types_test
 
 import (
 	"encoding/hex"
+	"fmt"
 	"testing"
 
+	"github.com/google/go-cmp/cmp"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/ava-labs/libevm/common"
 	. "github.com/ava-labs/libevm/core/types"
+	"github.com/ava-labs/libevm/libevm/cmpeth"
 	"github.com/ava-labs/libevm/libevm/ethtest"
 	"github.com/ava-labs/libevm/rlp"
 )
@@ -106,3 +110,211 @@ func testHeaderRLPBackwardsCompatibility(t *testing.T) {
 		assert.Equal(t, hdr, got)
 	})
 }
+
+func TestBodyRLPBackwardsCompatibility(t *testing.T) {
+	t.Parallel()
+	for seed := uint64(0); seed < 1_000; seed++ {
+		seed := seed
+		t.Run(fmt.Sprintf("seed_%d", seed), func(t *testing.T) {
+			t.Parallel()
+			testBodyRLPBackwardsCompatibility(t, seed)
+		})
+	}
+}
+
+//nolint:thelper
+func testBodyRLPBackwardsCompatibility(t *testing.T, seed uint64) {
+	rng := ethtest.NewPseudoRand(seed)
+
+	body := &Body{
+		// As this is a round-trip test, the slices MUST NOT be nil as the rlp
+		// package will always set them.
+		Transactions: []*Transaction{},
+		Uncles:       []*Header{},
+	}
+	for i, n := 0, rng.Intn(5); i < n; i++ {
+		tx := NewTx(&LegacyTx{
+			Nonce: rng.Uint64(),
+		})
+		body.Transactions = append(body.Transactions, tx)
+	}
+	for i, n := 0, rng.Intn(5); i < n; i++ {
+		body.Uncles = append(body.Uncles, &Header{
+			ParentHash: rng.Hash(),
+		})
+	}
+
+	var withdrawals Withdrawals
+	for i, n := 0, rng.Intn(4)+1; i < n; i++ {
+		withdrawals = append(withdrawals, &Withdrawal{
+			Index: rng.Uint64(),
+		})
+	}
+
+	tests := []struct {
+		name        string
+		withdrawals []*Withdrawal
+	}{
+		{
+			name: "with_nil_Withdrawals",
+		},
+		{
+			name: "with_empty_Withdrawals",
+			// As the struct field has an `rlp:"optional"` tag, we need to
+			// differentiate between nil (nothing added to RLP) and an empty
+			// slice (empty list added to RLP).
+			withdrawals: []*Withdrawal{},
+		},
+		{
+			name:        "with_Withdrawals",
+			withdrawals: withdrawals,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			body.Withdrawals = tt.withdrawals
+
+			// The original [Body] doesn't implement [rlp.Encoder] nor
+			// [rlp.Decoder] so we can use a methodless equivalent as the gold
+			// standard.
+			type withoutMethods Body
+			wantRLP, err := rlp.EncodeToBytes((*withoutMethods)(body))
+			require.NoErrorf(t, err, "rlp.EncodeToBytes([%T with methods stripped])", body)
+
+			t.Run("Encode", func(t *testing.T) {
+				got, err := rlp.EncodeToBytes(body)
+				require.NoErrorf(t, err, "rlp.EncodeToBytes(%T)", body)
+				assert.Equalf(t, wantRLP, got, "rlp.EncodeToBytes(%T)", body)
+			})
+
+			t.Run("Decode", func(t *testing.T) {
+				got := new(Body)
+				err := rlp.DecodeBytes(wantRLP, got)
+				require.NoErrorf(t, err, "rlp.DecodeBytes(..., %T)", got)
+
+				opts := cmp.Options{
+					cmpeth.CompareHeadersByHash(),
+					cmpeth.CompareTransactionsByBinary(t),
+				}
+				if diff := cmp.Diff(body, got, opts); diff != "" {
+					t.Errorf("rlp.DecodeBytes(rlp.EncodeToBytes(%T)) diff (-want +got):\n%s", body, diff)
+				}
+			})
+		})
+	}
+}
+
+// cChainBodyExtras carries the same additional fields as the ava-labs/coreth
+// [Body] and implements [BodyHooks] to achieve equivalent RLP {en,de}coding.
+type cChainBodyExtras struct {
+	Version uint32
+	ExtData *[]byte
+}
+
+var _ BodyHooks = (*cChainBodyExtras)(nil)
+
+func (e *cChainBodyExtras) AppendRLPFields(b rlp.EncoderBuffer, _ bool) error {
+	b.WriteUint64(uint64(e.Version))
+	if e.ExtData != nil {
+		b.WriteString(string(*e.ExtData))
+	} else {
+		b.WriteString("")
+	}
+	return nil
+}
+
+func (e *cChainBodyExtras) DecodeExtraRLPFields(s *rlp.Stream) error {
+	if err := s.Decode(&e.Version); err != nil {
+		return err
+	}
+
+	buf, err := s.Bytes()
+	if err != nil {
+		return err
+	}
+	if len(buf) > 0 {
+		e.ExtData = &buf
+	} else {
+		// Respect the `rlp:"nil"` field tag.
+		e.ExtData = nil
+	}
+
+	return nil
+}
+
+func TestBodyRLPCChainCompat(t *testing.T) {
+	// The inputs to this test were used to generate the expected RLP with
+	// ava-labs/coreth. This serves as both an example of how to use [BodyHooks]
+	// and a test of compatibility.
+
+	t.Cleanup(func() {
+		TestOnlyRegisterBodyHooks(NOOPBodyHooks{})
+	})
+
+	to := common.HexToAddress(`decafc0ffeebad`)
+	body := &Body{
+		Transactions: []*Transaction{
+			NewTx(&LegacyTx{
+				Nonce: 42,
+				To:    &to,
+			}),
+		},
+		Uncles: []*Header{ /* RLP encoding differs in ava-labs/coreth */ },
+	}
+
+	const version = 314159
+	tests := []struct {
+		name  string
+		extra *cChainBodyExtras
+		// WARNING: changing these values might break backwards compatibility of
+		// RLP encoding!
+		wantRLPHex string
+	}{
+		{
+			extra: &cChainBodyExtras{
+				Version: version,
+			},
+			wantRLPHex: `e5dedd2a80809400000000000000000000000000decafc0ffeebad8080808080c08304cb2f80`,
+		},
+		{
+			extra: &cChainBodyExtras{
+				Version: version,
+				ExtData: &[]byte{1, 4, 2, 8, 5, 7},
+			},
+			wantRLPHex: `ebdedd2a80809400000000000000000000000000decafc0ffeebad8080808080c08304cb2f86010402080507`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			wantRLP, err := hex.DecodeString(tt.wantRLPHex)
+			require.NoError(t, err)
+
+			t.Run("Encode", func(t *testing.T) {
+				TestOnlyRegisterBodyHooks(tt.extra)
+				got, err := rlp.EncodeToBytes(body)
+				require.NoError(t, err)
+				assert.Equal(t, wantRLP, got)
+			})
+
+			t.Run("Decode", func(t *testing.T) {
+				var extra cChainBodyExtras
+				TestOnlyRegisterBodyHooks(&extra)
+
+				got := new(Body)
+				err := rlp.DecodeBytes(wantRLP, got)
+				require.NoError(t, err)
+				assert.Equal(t, tt.extra, &extra)
+
+				opts := cmp.Options{
+					cmpeth.CompareHeadersByHash(),
+					cmpeth.CompareTransactionsByBinary(t),
+				}
+				if diff := cmp.Diff(body, got, opts); diff != "" {
+					t.Errorf("%s", diff)
+				}
+			})
+		})
+	}
+}