feat: registration of StateAccount payload type

Author: ARR4N

core/types/gen_account_rlp.go

@@ -7,33 +7,46 @@ import (
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
-type RLPPayload struct {
-	t *pseudo.Type
+type Extras[SA any] struct{}
+
+func RegisterExtras[SA any](extras Extras[SA]) {
+	if registeredExtras != nil {
+		panic("re-registration of Extras")
+	}
+	registeredExtras = &extraConstructors{
+		newStateAccount: pseudo.NewConstructor[SA]().Zero,
+	}
 }
 
-func NewRLPPayload[T any]() (*RLPPayload, *pseudo.Value[T]) {
-	var x T
-	return RLPPayloadOf(x)
+var registeredExtras *extraConstructors
+
+type extraConstructors struct {
+	newStateAccount func() *pseudo.Type
 }
 
-func RLPPayloadOf[T any](x T) (*RLPPayload, *pseudo.Value[T]) {
-	p := pseudo.From(x)
-	return &RLPPayload{p.Type}, p.Value
+type StateAccountExtra struct {
+	t *pseudo.Type
 }
 
 var _ interface {
 	rlp.Encoder
 	rlp.Decoder
-} = (*RLPPayload)(nil)
+} = (*StateAccountExtra)(nil)
 
-func (p *RLPPayload) EncodeRLP(w io.Writer) error {
-	if p == nil || p.t == nil {
+func (p *StateAccountExtra) EncodeRLP(w io.Writer) error {
+	switch r := registeredExtras; {
+	case r == nil:
 		return nil
+	case p == nil:
+		p = &StateAccountExtra{}
+		fallthrough
+	case p.t == nil:
+		p.t = r.newStateAccount()
 	}
 	return p.t.EncodeRLP(w)
 }
 
-func (p *RLPPayload) DecodeRLP(s *rlp.Stream) error {
+func (p *StateAccountExtra) DecodeRLP(s *rlp.Stream) error {
 	// DO NOT MERGE without implementation
 	return nil
 }

core/types/rlp_payload.libevm.go

@@ -34,7 +34,7 @@ type StateAccount struct {
 	Root     common.Hash // merkle root of the storage trie
 	CodeHash []byte
 
-	Extra *RLPPayload `rlp:"optional"`
+	Extra *StateAccountExtra
 }
 
 // NewEmptyStateAccount constructs an empty state account.

core/types/state_account.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/libevm/pseudo"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/holiman/uint256"
 	"github.com/stretchr/testify/require"
@@ -15,63 +16,92 @@ func TestStateAccountRLP(t *testing.T) {
 	// geth StateAccounts *before* any libevm modifications, thus locking in
 	// default behaviour. Encodings that involve a boolean payload were
 	// generated on ava-labs/coreth StateAccounts to guarantee equivalence.
-	tests := []struct {
-		name    string
-		acc     *StateAccount
-		wantHex string
-	}{
-		{
-			name: "vanilla geth account",
-			acc: &StateAccount{
-				Nonce:    0xcccccc,
-				Balance:  uint256.NewInt(0x555555),
-				Root:     common.MaxHash,
-				CodeHash: []byte{0x77, 0x77, 0x77},
+
+	type test struct {
+		name     string
+		register func()
+		acc      *StateAccount
+		wantHex  string
+	}
+
+	explicitFalseBoolean := test{
+		name: "explicit false-boolean extra",
+		register: func() {
+			RegisterExtras(Extras[bool]{})
+		},
+		acc: &StateAccount{
+			Nonce:    0x444444,
+			Balance:  uint256.NewInt(0x666666),
+			Root:     common.Hash{},
+			CodeHash: []byte{0xbb, 0xbb, 0xbb},
+			Extra: &StateAccountExtra{
+				t: pseudo.From(false).Type,
 			},
-			wantHex: `0xed83cccccc83555555a0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff83777777`,
 		},
+		wantHex: `0xee8344444483666666a0000000000000000000000000000000000000000000000000000000000000000083bbbbbb80`,
+	}
+
+	// The vanilla geth code won't set payloads so we need to ensure that the
+	// zero-value encoding is used instead of the null-value default as when
+	// no type is registered.
+	implicitFalseBoolean := explicitFalseBoolean
+	implicitFalseBoolean.name = "implicit false-boolean extra as zero-value of registered type"
+	// Clearing the Extra makes the `false` value implicit and due only to the
+	// fact that we register `bool`. Most importantly, note that `wantHex`
+	// remains identical.
+	implicitFalseBoolean.acc.Extra = nil
+
+	tests := []test{
+		explicitFalseBoolean,
+		implicitFalseBoolean,
 		{
-			name: "vanilla geth account",
+			name: "true-boolean extra",
+			register: func() {
+				RegisterExtras(Extras[bool]{})
+			},
 			acc: &StateAccount{
 				Nonce:    0x444444,
 				Balance:  uint256.NewInt(0x666666),
 				Root:     common.Hash{},
 				CodeHash: []byte{0xbb, 0xbb, 0xbb},
+				Extra: &StateAccountExtra{
+					t: pseudo.From(true).Type,
+				},
 			},
-			wantHex: `0xed8344444483666666a0000000000000000000000000000000000000000000000000000000000000000083bbbbbb`,
+			wantHex: `0xee8344444483666666a0000000000000000000000000000000000000000000000000000000000000000083bbbbbb01`,
 		},
 		{
-			name: "true boolean extra",
+			name: "vanilla geth account",
 			acc: &StateAccount{
-				Nonce:    0x444444,
-				Balance:  uint256.NewInt(0x666666),
-				Root:     common.Hash{},
-				CodeHash: []byte{0xbb, 0xbb, 0xbb},
-				Extra: func() *RLPPayload {
-					p, _ := RLPPayloadOf(true) // not an error being dropped
-					return p
-				}(),
+				Nonce:    0xcccccc,
+				Balance:  uint256.NewInt(0x555555),
+				Root:     common.MaxHash,
+				CodeHash: []byte{0x77, 0x77, 0x77},
 			},
-			wantHex: `0xee8344444483666666a0000000000000000000000000000000000000000000000000000000000000000083bbbbbb01`,
+			wantHex: `0xed83cccccc83555555a0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff83777777`,
 		},
 		{
-			name: "false boolean extra",
+			name: "vanilla geth account",
 			acc: &StateAccount{
 				Nonce:    0x444444,
 				Balance:  uint256.NewInt(0x666666),
 				Root:     common.Hash{},
 				CodeHash: []byte{0xbb, 0xbb, 0xbb},
-				Extra: func() *RLPPayload {
-					p, _ := RLPPayloadOf(false)
-					return p
-				}(),
 			},
-			wantHex: `0xee8344444483666666a0000000000000000000000000000000000000000000000000000000000000000083bbbbbb80`,
+			wantHex: `0xed8344444483666666a0000000000000000000000000000000000000000000000000000000000000000083bbbbbb`,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			if tt.register != nil {
+				registeredExtras = nil
+				tt.register()
+				t.Cleanup(func() {
+					registeredExtras = nil
+				})
+			}
+
 			got, err := rlp.EncodeToBytes(tt.acc)
 			require.NoError(t, err)
 			t.Logf("got: %#x", got)