Merge branch 'main' into arr4n/reentrancy-guard

Author: ARR4N

core/state/statedb.libevm.go

@@ -82,6 +82,19 @@ func RegisterExtras(s StateDBHooks) {
 	registeredExtras.MustRegister(s)
 }
 
+// WithTempRegisteredExtras temporarily registers `s` as if calling
+// [RegisterExtras] the same type parameter. After `fn` returns, the
+// registration is returned to its former state, be that none or the types
+// originally passed to [RegisterExtras].
+//
+// This MUST NOT be used on a live chain. It is solely intended for off-chain
+// consumers that require access to extras. Said consumers SHOULD NOT, however
+// call this function directly. Use the libevm/temporary.WithRegisteredExtras()
+// function instead as it atomically overrides all possible packages.
+func WithTempRegisteredExtras(s StateDBHooks, fn func()) {
+	registeredExtras.TempOverride(s, fn)
+}
+
 // TestOnlyClearRegisteredExtras clears the arguments previously passed to
 // [RegisterExtras]. It panics if called from a non-testing call stack.
 //

core/state/statedb.libevm_test.go

@@ -150,6 +150,12 @@ func (highByteFlipper) TransformStateKey(_ common.Address, key common.Hash) comm
 	return flipHighByte(key)
 }
 
+type noopHooks struct{}
+
+func (noopHooks) TransformStateKey(_ common.Address, key common.Hash) common.Hash {
+	return key
+}
+
 func TestTransformStateKey(t *testing.T) {
 	rawdb := rawdb.NewMemoryDatabase()
 	trie := triedb.NewDatabase(rawdb, nil)
@@ -209,6 +215,16 @@ func TestTransformStateKey(t *testing.T) {
 	assertCommittedEq(t, flippedKey, regularVal)
 	assertCommittedEq(t, flippedKey, flippedVal, noTransform)
 
+	t.Run("WithTempRegisteredExtras", func(t *testing.T) {
+		WithTempRegisteredExtras(noopHooks{}, func() {
+			// No-op hooks are equivalent to using the `noTransform` option.
+			// NOTE this is NOT the intended usage of [WithTempRegisteredExtras]
+			// and is simply an easy way to test the temporary registration.
+			assertEq(t, regularKey, regularVal)
+			assertEq(t, flippedKey, flippedVal)
+		})
+	})
+
 	updatedVal := common.Hash{'u', 'p', 'd', 'a', 't', 'e', 'd'}
 	sdb.SetState(addr, regularKey, updatedVal)
 	assertEq(t, regularKey, updatedVal)

core/types/block.libevm.go

@@ -130,7 +130,7 @@ type BlockBodyHooks interface {
 // to no type having been registered.
 type NOOPBlockBodyHooks struct{}
 
-var _ BlockBodyPayload[*NOOPBlockBodyHooks] = NOOPBlockBodyHooks{}
+var _ BlockBodyPayload[*NOOPBlockBodyHooks] = (*NOOPBlockBodyHooks)(nil)
 
 func (NOOPBlockBodyHooks) Copy() *NOOPBlockBodyHooks { return &NOOPBlockBodyHooks{} }
 

core/types/rlp_payload.libevm.go

@@ -44,17 +44,27 @@ import (
 // [Header] or [Block] / [Body] is a non-nil `HPtr` or `BPtr` respectively. 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 {
-		BlockBodyPayload[BPtr]
-		*B
-	},
+	H any, HPtr HeaderHooksPointer[H],
+	B any, BPtr BlockBodyHooksPointer[B, BPtr],
 	SA any,
 ]() ExtraPayloads[HPtr, BPtr, SA] {
-	extra := ExtraPayloads[HPtr, BPtr, SA]{
+	payloads, ctors := payloadsAndConstructors[H, HPtr, B, BPtr, SA]()
+	registeredExtras.MustRegister(ctors)
+	log.Info(
+		"Registered core/types extras",
+		"Header", log.TypeOf(pseudo.Zero[HPtr]().Value.Get()),
+		"Block/Body", log.TypeOf(pseudo.Zero[BPtr]().Value.Get()),
+		"StateAccount", log.TypeOf(pseudo.Zero[SA]().Value.Get()),
+	)
+	return payloads
+}
+
+func payloadsAndConstructors[
+	H any, HPtr HeaderHooksPointer[H],
+	B any, BPtr BlockBodyHooksPointer[B, BPtr],
+	SA any,
+]() (ExtraPayloads[HPtr, BPtr, SA], *extraConstructors) {
+	payloads := ExtraPayloads[HPtr, BPtr, SA]{
 		Header: pseudo.NewAccessor[*Header, HPtr](
 			(*Header).extraPayload,
 			func(h *Header, t *pseudo.Type) { h.extra = t },
@@ -72,7 +82,7 @@ func RegisterExtras[
 			func(a StateOrSlimAccount, t *pseudo.Type) { a.extra().t = t },
 		),
 	}
-	registeredExtras.MustRegister(&extraConstructors{
+	ctors := &extraConstructors{
 		stateAccountType: func() string {
 			var x SA
 			return fmt.Sprintf("%T", x)
@@ -84,23 +94,51 @@ func RegisterExtras[
 		newHeader:       pseudo.NewConstructor[H]().NewPointer, // i.e. non-nil HPtr
 		newBlockOrBody:  pseudo.NewConstructor[B]().NewPointer, // i.e. non-nil BPtr
 		newStateAccount: pseudo.NewConstructor[SA]().Zero,
-		hooks:           extra,
-	})
-	log.Info(
-		"Registered core/types extras",
-		"Header", log.TypeOf(pseudo.Zero[HPtr]().Value.Get()),
-		"Block/Body", log.TypeOf(pseudo.Zero[BPtr]().Value.Get()),
-		"StateAccount", log.TypeOf(pseudo.Zero[SA]().Value.Get()),
-	)
-	return extra
+		hooks:           payloads,
+	}
+	return payloads, ctors
+}
+
+// WithTempRegisteredExtras temporarily registers `HPtr`, `BPtr`, and `SA` as if
+// calling [RegisterExtras] the same type parameters. The [ExtraPayloads] are
+// passed to `fn` instead of being returned; the argument MUST NOT be persisted
+// beyond the life of `fn`. After `fn` returns, the registration is returned to
+// its former state, be that none or the types originally passed to
+// [RegisterExtras].
+//
+// This MUST NOT be used on a live chain. It is solely intended for off-chain
+// consumers that require access to extras. Said consumers SHOULD NOT, however
+// call this function directly. Use the libevm/temporary.WithRegisteredExtras()
+// function instead as it atomically overrides all possible packages.
+func WithTempRegisteredExtras[
+	H, B, SA any,
+	HPtr HeaderHooksPointer[H],
+	BPtr BlockBodyHooksPointer[B, BPtr],
+](fn func(ExtraPayloads[HPtr, BPtr, SA])) {
+	payloads, ctors := payloadsAndConstructors[H, HPtr, B, BPtr, SA]()
+	registeredExtras.TempOverride(ctors, func() { fn(payloads) })
+}
+
+// A HeaderHooksPointer is a type constraint for an implementation of
+// [HeaderHooks] with a pointer receiver.
+type HeaderHooksPointer[H any] interface {
+	HeaderHooks
+	*H
+}
+
+// A BlockBodyHooksPointer is a type constraint for an implementation of
+// [BlockBodyPayload] with a pointer receiver.
+type BlockBodyHooksPointer[B any, Self any] interface {
+	BlockBodyPayload[Self]
+	*B
 }
 
 // A BlockBodyPayload is an implementation of [BlockBodyHooks] that is also able
 // to clone itself. Both [Block.Body] and [Block.WithBody] require this
 // functionality to copy the payload between the types.
-type BlockBodyPayload[BPtr any] interface {
+type BlockBodyPayload[Self any] interface {
 	BlockBodyHooks
-	Copy() BPtr
+	Copy() Self
 }
 
 // TestOnlyClearRegisteredExtras clears the [Extras] previously passed to

core/types/tempextras.libevm_test.go

@@ -0,0 +1,76 @@
+// Copyright 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
+// as published by the Free Software Foundation, either version 3 of the License,
+// or (at your option) any later version.
+//
+// The libevm additions are distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
+// General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see
+// <http://www.gnu.org/licenses/>.
+
+package types
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/libevm/rlp"
+)
+
+type tempBlockBodyHooks struct {
+	X string
+	NOOPBlockBodyHooks
+}
+
+func (b *tempBlockBodyHooks) Copy() *tempBlockBodyHooks {
+	return &tempBlockBodyHooks{X: b.X}
+}
+
+func (b *tempBlockBodyHooks) BlockRLPFieldsForEncoding(*BlockRLPProxy) *rlp.Fields {
+	return &rlp.Fields{
+		Required: []any{b.X},
+	}
+}
+
+func TestTempRegisteredExtras(t *testing.T) {
+	TestOnlyClearRegisteredExtras()
+	t.Cleanup(TestOnlyClearRegisteredExtras)
+
+	rlpWithoutHooks, err := rlp.EncodeToBytes(&Block{})
+	require.NoErrorf(t, err, "rlp.EncodeToBytes(%T) without hooks", &Block{})
+
+	extras := RegisterExtras[NOOPHeaderHooks, *NOOPHeaderHooks, NOOPBlockBodyHooks, *NOOPBlockBodyHooks, bool]()
+	testPrimaryExtras := func(t *testing.T) {
+		t.Helper()
+		b := new(Block)
+		got, err := rlp.EncodeToBytes(b)
+		require.NoErrorf(t, err, "rlp.EncodeToBytes(%T) with %T hooks", b, extras.Block.Get(b))
+		assert.Equalf(t, rlpWithoutHooks, got, "rlp.EncodeToBytes(%T) with noop hooks; expect same as without hooks", b)
+	}
+
+	t.Run("before_temp", testPrimaryExtras)
+	t.Run("WithTempRegisteredExtras", func(t *testing.T) {
+		WithTempRegisteredExtras(func(extras ExtraPayloads[*NOOPHeaderHooks, *tempBlockBodyHooks, bool]) {
+			const val = "Hello, world"
+			b := new(Block)
+			payload := &tempBlockBodyHooks{X: val}
+			extras.Block.Set(b, payload)
+
+			got, err := rlp.EncodeToBytes(b)
+			require.NoErrorf(t, err, "rlp.EncodeToBytes(%T) with %T hooks", b, extras.Block.Get(b))
+			want, err := rlp.EncodeToBytes([]string{val})
+			require.NoErrorf(t, err, "rlp.EncodeToBytes(%T{%[1]v})", []string{val})
+
+			assert.Equalf(t, want, got, "rlp.EncodeToBytes(%T) with %T hooks", b, payload)
+		})
+	})
+	t.Run("after_temp", testPrimaryExtras)
+}

core/vm/contracts.libevm.go

@@ -241,7 +241,7 @@ func (args *evmCallArgs) env() *environment {
 		self = args.addr
 
 	case DelegateCall:
-		value = nil
+		value = nil // inherited from `args.caller` inside [Contract.AsDelegate]
 		fallthrough
 	case CallCode:
 		self = args.caller.Address()

core/vm/contracts.libevm_test.go

@@ -109,7 +109,7 @@ type statefulPrecompileOutput struct {
 	ChainID                 *big.Int
 	Addresses               *libevm.AddressContext
 	StateValue              common.Hash
-	ValueReceived           *uint256.Int
+	CallValue               *uint256.Int
 	ReadOnly                bool
 	BlockNumber, Difficulty *big.Int
 	BlockTime               uint64
@@ -169,7 +169,7 @@ func TestNewStatefulPrecompile(t *testing.T) {
 			ChainID:          env.ChainConfig().ChainID,
 			Addresses:        env.Addresses(),
 			StateValue:       env.ReadOnlyState().GetState(precompile, slot),
-			ValueReceived:    env.Value(),
+			CallValue:        env.Value(),
 			ReadOnly:         env.ReadOnly(),
 			BlockNumber:      env.BlockNumber(),
 			BlockTime:        env.BlockTime(),
@@ -197,12 +197,13 @@ func TestNewStatefulPrecompile(t *testing.T) {
 	}
 	input := rng.Bytes(8)
 	stateValue := rng.Hash()
-	transferValue := rng.Uint256()
+	callCallerValue := rng.Uint256()
+	callPrecompileValue := rng.Uint256()
 	chainID := rng.BigUint64()
 
 	caller := common.HexToAddress("CA11E12") // caller of the precompile
 	eoa := common.HexToAddress("E0A")        // caller of the precompile-caller
-	callerContract := vm.NewContract(vm.AccountRef(eoa), vm.AccountRef(caller), uint256.NewInt(0), 1e6)
+	callerContract := vm.NewContract(vm.AccountRef(eoa), vm.AccountRef(caller), callCallerValue, 1e6)
 
 	state, evm := ethtest.NewZeroEVM(
 		t,
@@ -225,10 +226,10 @@ func TestNewStatefulPrecompile(t *testing.T) {
 	}
 
 	tests := []struct {
-		name              string
-		call              func() ([]byte, uint64, error)
-		wantAddresses     *libevm.AddressContext
-		wantTransferValue *uint256.Int
+		name          string
+		call          func() ([]byte, uint64, error)
+		wantAddresses *libevm.AddressContext
+		wantCallValue *uint256.Int
 		// Note that this only covers evm.readOnly being true because of the
 		// precompile's call. See TestInheritReadOnly for alternate case.
 		wantReadOnly bool
@@ -237,21 +238,21 @@ func TestNewStatefulPrecompile(t *testing.T) {
 		{
 			name: "EVM.Call()",
 			call: func() ([]byte, uint64, error) {
-				return evm.Call(callerContract, precompile, input, gasLimit, transferValue)
+				return evm.Call(callerContract, precompile, input, gasLimit, callPrecompileValue)
 			},
 			wantAddresses: &libevm.AddressContext{
 				Origin:      eoa,
 				EVMSemantic: rawAddresses,
 				Raw:         &rawAddresses,
 			},
-			wantReadOnly:      false,
-			wantTransferValue: transferValue,
-			wantCallType:      vm.Call,
+			wantReadOnly:  false,
+			wantCallValue: callPrecompileValue,
+			wantCallType:  vm.Call,
 		},
 		{
 			name: "EVM.CallCode()",
 			call: func() ([]byte, uint64, error) {
-				return evm.CallCode(callerContract, precompile, input, gasLimit, transferValue)
+				return evm.CallCode(callerContract, precompile, input, gasLimit, callPrecompileValue)
 			},
 			wantAddresses: &libevm.AddressContext{
 				Origin: eoa,
@@ -261,9 +262,9 @@ func TestNewStatefulPrecompile(t *testing.T) {
 				},
 				Raw: &rawAddresses,
 			},
-			wantReadOnly:      false,
-			wantTransferValue: transferValue,
-			wantCallType:      vm.CallCode,
+			wantReadOnly:  false,
+			wantCallValue: callPrecompileValue,
+			wantCallType:  vm.CallCode,
 		},
 		{
 			name: "EVM.DelegateCall()",
@@ -278,9 +279,9 @@ func TestNewStatefulPrecompile(t *testing.T) {
 				},
 				Raw: &rawAddresses,
 			},
-			wantReadOnly:      false,
-			wantTransferValue: uint256.NewInt(0),
-			wantCallType:      vm.DelegateCall,
+			wantReadOnly:  false,
+			wantCallValue: callCallerValue, // Important difference from [vm.EVM.Call]
+			wantCallType:  vm.DelegateCall,
 		},
 		{
 			name: "EVM.StaticCall()",
@@ -292,9 +293,9 @@ func TestNewStatefulPrecompile(t *testing.T) {
 				EVMSemantic: rawAddresses,
 				Raw:         &rawAddresses,
 			},
-			wantReadOnly:      true,
-			wantTransferValue: uint256.NewInt(0),
-			wantCallType:      vm.StaticCall,
+			wantReadOnly:  true,
+			wantCallValue: uint256.NewInt(0),
+			wantCallType:  vm.StaticCall,
 		},
 	}
 
@@ -304,7 +305,7 @@ func TestNewStatefulPrecompile(t *testing.T) {
 				ChainID:          chainID,
 				Addresses:        tt.wantAddresses,
 				StateValue:       stateValue,
-				ValueReceived:    tt.wantTransferValue,
+				CallValue:        tt.wantCallValue,
 				ReadOnly:         tt.wantReadOnly,
 				BlockNumber:      header.Number,
 				BlockTime:        header.Time,