test: vm.PrecompileEnvironment.Value()

Author: ARR4N

core/vm/contracts.libevm.go

@@ -104,9 +104,9 @@ func (args *evmCallArgs) run(p PrecompiledContract, input []byte, suppliedGas ui
 // PrecompiledStatefulContract is the stateful equivalent of a
 // [PrecompiledContract].
 //
-// Instead of receiving and returning gas limits, stateful precompiles use the
-// respective methods on [PrecompileEnvironment]. If a call to UseGas() returns
-// false, a stateful precompile SHOULD return [ErrOutOfGas].
+// Instead of receiving and returning gas arguments, stateful precompiles use
+// the respective methods on [PrecompileEnvironment]. If a call to UseGas()
+// returns false, a stateful precompile SHOULD return [ErrOutOfGas].
 type PrecompiledStatefulContract func(env PrecompileEnvironment, input []byte) (ret []byte, err error)
 
 // NewStatefulPrecompile constructs a new PrecompiledContract that can be used

core/vm/contracts.libevm_test.go

@@ -107,6 +107,7 @@ type statefulPrecompileOutput struct {
 	ChainID                 *big.Int
 	Addresses               *libevm.AddressContext
 	StateValue              common.Hash
+	ValueReceived           *uint256.Int
 	ReadOnly                bool
 	BlockNumber, Difficulty *big.Int
 	BlockTime               uint64
@@ -160,6 +161,7 @@ func TestNewStatefulPrecompile(t *testing.T) {
 			ChainID:          env.ChainConfig().ChainID,
 			Addresses:        env.Addresses(),
 			StateValue:       env.ReadOnlyState().GetState(precompile, slot),
+			ValueReceived:    env.Value(),
 			ReadOnly:         env.ReadOnly(),
 			BlockNumber:      env.BlockNumber(),
 			BlockTime:        env.BlockTime(),
@@ -186,7 +188,8 @@ func TestNewStatefulPrecompile(t *testing.T) {
 		Difficulty: rng.BigUint64(),
 	}
 	input := rng.Bytes(8)
-	value := rng.Hash()
+	stateValue := rng.Hash()
+	transferValue := rng.Uint256()
 	chainID := rng.BigUint64()
 
 	caller := common.HexToAddress("CA11E12") // caller of the precompile
@@ -202,13 +205,15 @@ func TestNewStatefulPrecompile(t *testing.T) {
 			&params.ChainConfig{ChainID: chainID},
 		),
 	)
-	state.SetState(precompile, slot, value)
+	state.SetState(precompile, slot, stateValue)
+	state.SetBalance(caller, new(uint256.Int).Not(uint256.NewInt(0)))
 	evm.Origin = eoa
 
 	tests := []struct {
-		name          string
-		call          func() ([]byte, uint64, error)
-		wantAddresses *libevm.AddressContext
+		name              string
+		call              func() ([]byte, uint64, error)
+		wantAddresses     *libevm.AddressContext
+		wantTransferValue *uint256.Int
 		// Note that this only covers evm.readOnly being true because of the
 		// precompile's call. See TestInheritReadOnly for alternate case.
 		wantReadOnly bool
@@ -217,28 +222,30 @@ func TestNewStatefulPrecompile(t *testing.T) {
 		{
 			name: "EVM.Call()",
 			call: func() ([]byte, uint64, error) {
-				return evm.Call(callerContract, precompile, input, gasLimit, uint256.NewInt(0))
+				return evm.Call(callerContract, precompile, input, gasLimit, transferValue)
 			},
 			wantAddresses: &libevm.AddressContext{
 				Origin: eoa,
 				Caller: caller,
 				Self:   precompile,
 			},
-			wantReadOnly: false,
-			wantCallType: vm.Call,
+			wantReadOnly:      false,
+			wantTransferValue: transferValue,
+			wantCallType:      vm.Call,
 		},
 		{
 			name: "EVM.CallCode()",
 			call: func() ([]byte, uint64, error) {
-				return evm.CallCode(callerContract, precompile, input, gasLimit, uint256.NewInt(0))
+				return evm.CallCode(callerContract, precompile, input, gasLimit, transferValue)
 			},
 			wantAddresses: &libevm.AddressContext{
 				Origin: eoa,
 				Caller: caller,
 				Self:   caller,
 			},
-			wantReadOnly: false,
-			wantCallType: vm.CallCode,
+			wantReadOnly:      false,
+			wantTransferValue: transferValue,
+			wantCallType:      vm.CallCode,
 		},
 		{
 			name: "EVM.DelegateCall()",
@@ -250,8 +257,9 @@ func TestNewStatefulPrecompile(t *testing.T) {
 				Caller: eoa, // inherited from caller
 				Self:   caller,
 			},
-			wantReadOnly: false,
-			wantCallType: vm.DelegateCall,
+			wantReadOnly:      false,
+			wantTransferValue: uint256.NewInt(0),
+			wantCallType:      vm.DelegateCall,
 		},
 		{
 			name: "EVM.StaticCall()",
@@ -263,8 +271,9 @@ func TestNewStatefulPrecompile(t *testing.T) {
 				Caller: caller,
 				Self:   precompile,
 			},
-			wantReadOnly: true,
-			wantCallType: vm.StaticCall,
+			wantReadOnly:      true,
+			wantTransferValue: uint256.NewInt(0),
+			wantCallType:      vm.StaticCall,
 		},
 	}
 
@@ -273,7 +282,8 @@ func TestNewStatefulPrecompile(t *testing.T) {
 			wantOutput := statefulPrecompileOutput{
 				ChainID:          chainID,
 				Addresses:        tt.wantAddresses,
-				StateValue:       value,
+				StateValue:       stateValue,
+				ValueReceived:    tt.wantTransferValue,
 				ReadOnly:         tt.wantReadOnly,
 				BlockNumber:      header.Number,
 				BlockTime:        header.Time,