Rename short variable names to differentiate block vs body

- `B` -> `BlockExtra`
- `BPtr` -> `BlockExtraPtr`

core/types/block.libevm.go

@@ -43,7 +43,7 @@ func (h *Header) hooks() HeaderHooks {
 	return new(NOOPHeaderHooks)
 }
 
-func (e ExtraPayloads[HPtr, BPtr, SA]) hooksFromHeader(h *Header) HeaderHooks {
+func (e ExtraPayloads[HPtr, BlockExtraPtr, SA]) hooksFromHeader(h *Header) HeaderHooks {
 	return e.Header.Get(h)
 }
 
@@ -125,7 +125,7 @@ func (b *Block) hooks() BlockHooks {
 	return new(NOOPBlockHooks)
 }
 
-func (e ExtraPayloads[HPtr, BPtr, SA]) hooksFromBlock(b *Block) BlockHooks {
+func (e ExtraPayloads[HPtr, BlockExtraPtr, SA]) hooksFromBlock(b *Block) BlockHooks {
 	return e.Block.Get(b)
 }
 

core/types/rlp_payload.libevm.go

@@ -40,24 +40,24 @@ import (
 // [ExtraPayloads] returned by RegisterExtras. The default `SA` value accessed
 // in this manner will be a zero-value `SA` while the default value from a
 // [Header] is a non-nil `HPtr` and the default value from a [Block] is a non-nil
-// `BPtr`. The latter guarantee ensures that hooks won't be called on nil-pointer receivers.
+// `BlockExtraPtr`. The latter guarantee ensures that hooks won't be called on nil-pointer receivers.
 func RegisterExtras[
 	H any, HPtr interface {
 		HeaderHooks
 		*H
 	},
-	B any, BPtr interface {
+	BlockExtra any, BlockExtraPtr interface {
 		BlockHooks
-		*B
+		*BlockExtra
 	},
 	SA any,
-]() ExtraPayloads[HPtr, BPtr, SA] {
-	extra := ExtraPayloads[HPtr, BPtr, SA]{
+]() ExtraPayloads[HPtr, BlockExtraPtr, SA] {
+	extra := ExtraPayloads[HPtr, BlockExtraPtr, SA]{
 		Header: pseudo.NewAccessor[*Header, HPtr](
 			(*Header).extraPayload,
 			func(h *Header, t *pseudo.Type) { h.extra = t },
 		),
-		Block: pseudo.NewAccessor[*Block, BPtr](
+		Block: pseudo.NewAccessor[*Block, BlockExtraPtr](
 			(*Block).extraPayload,
 			func(b *Block, t *pseudo.Type) { b.extra = t },
 		),
@@ -71,11 +71,11 @@ func RegisterExtras[
 			var x SA
 			return fmt.Sprintf("%T", x)
 		}(),
-		// The [ExtraPayloads] that we returns is based on [HPtr,BPtr,SA], not [H,B,SA]
-		// so our constructors MUST match that. This guarantees that calls to
+		// The [ExtraPayloads] that we returns is based on [HPtr,BlockExtraPtr,SA], not
+		// [H,BlockExtra,SA] so our constructors MUST match that. This guarantees that calls to
 		// the [HeaderHooks] and [BlockHooks] methods will never be performed on a nil pointer.
-		newHeader:         pseudo.NewConstructor[H]().NewPointer, // i.e. non-nil HPtr
-		newBlock:          pseudo.NewConstructor[B]().NewPointer, // i.e. non-nil BPtr
+		newHeader:         pseudo.NewConstructor[H]().NewPointer,          // i.e. non-nil HPtr
+		newBlock:          pseudo.NewConstructor[BlockExtra]().NewPointer, // i.e. non-nil BlockExtraPtr
 		newStateAccount:   pseudo.NewConstructor[SA]().Zero,
 		cloneStateAccount: extra.cloneStateAccount,
 		hooks:             extra,
@@ -119,13 +119,13 @@ func (e *StateAccountExtra) clone() *StateAccountExtra {
 // ExtraPayloads provides strongly typed access to the extra payload carried by
 // [Header], [Block], [StateAccount], and [SlimAccount] structs. The only valid way to
 // construct an instance is by a call to [RegisterExtras].
-type ExtraPayloads[HPtr HeaderHooks, BPtr BlockHooks, SA any] struct {
+type ExtraPayloads[HPtr HeaderHooks, BlockExtraPtr BlockHooks, SA any] struct {
 	Header       pseudo.Accessor[*Header, HPtr]
-	Block        pseudo.Accessor[*Block, BPtr]
+	Block        pseudo.Accessor[*Block, BlockExtraPtr]
 	StateAccount pseudo.Accessor[StateOrSlimAccount, SA] // Also provides [SlimAccount] access.
 }
 
-func (ExtraPayloads[HPtr, BPtr, SA]) cloneStateAccount(s *StateAccountExtra) *StateAccountExtra {
+func (ExtraPayloads[HPtr, BlockExtraPtr, SA]) cloneStateAccount(s *StateAccountExtra) *StateAccountExtra {
 	v := pseudo.MustNewValue[SA](s.t)
 	return &StateAccountExtra{
 		t: pseudo.From(v.Get()).Type,