github.com/prysmaticlabs/prysm@v1.4.4/beacon-chain/core/epoch/precompute/slashing_test.go (about)

     1  package precompute_test
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
     8  	"github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
     9  	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
    10  	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
    11  	"github.com/prysmaticlabs/prysm/shared/params"
    12  	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
    13  	"github.com/prysmaticlabs/prysm/shared/testutil/require"
    14  	"google.golang.org/protobuf/proto"
    15  )
    16  
    17  func TestProcessSlashingsPrecompute_NotSlashedWithSlashedTrue(t *testing.T) {
    18  	s, err := v1.InitializeFromProto(&pb.BeaconState{
    19  		Slot:       0,
    20  		Validators: []*ethpb.Validator{{Slashed: true}},
    21  		Balances:   []uint64{params.BeaconConfig().MaxEffectiveBalance},
    22  		Slashings:  []uint64{0, 1e9},
    23  	})
    24  	require.NoError(t, err)
    25  	pBal := &precompute.Balance{ActiveCurrentEpoch: params.BeaconConfig().MaxEffectiveBalance}
    26  	require.NoError(t, precompute.ProcessSlashingsPrecompute(s, pBal))
    27  
    28  	wanted := params.BeaconConfig().MaxEffectiveBalance
    29  	assert.Equal(t, wanted, s.Balances()[0], "Unexpected slashed balance")
    30  }
    31  
    32  func TestProcessSlashingsPrecompute_NotSlashedWithSlashedFalse(t *testing.T) {
    33  	s, err := v1.InitializeFromProto(&pb.BeaconState{
    34  		Slot:       0,
    35  		Validators: []*ethpb.Validator{{}},
    36  		Balances:   []uint64{params.BeaconConfig().MaxEffectiveBalance},
    37  		Slashings:  []uint64{0, 1e9},
    38  	})
    39  	require.NoError(t, err)
    40  	pBal := &precompute.Balance{ActiveCurrentEpoch: params.BeaconConfig().MaxEffectiveBalance}
    41  	require.NoError(t, precompute.ProcessSlashingsPrecompute(s, pBal))
    42  
    43  	wanted := params.BeaconConfig().MaxEffectiveBalance
    44  	assert.Equal(t, wanted, s.Balances()[0], "Unexpected slashed balance")
    45  }
    46  
    47  func TestProcessSlashingsPrecompute_SlashedLess(t *testing.T) {
    48  	tests := []struct {
    49  		state *pb.BeaconState
    50  		want  uint64
    51  	}{
    52  		{
    53  			state: &pb.BeaconState{
    54  				Validators: []*ethpb.Validator{
    55  					{Slashed: true,
    56  						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
    57  						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
    58  					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance}},
    59  				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
    60  				Slashings: []uint64{0, 1e9},
    61  			},
    62  			// penalty    = validator balance / increment * (2*total_penalties) / total_balance * increment
    63  			// 1000000000 = (32 * 1e9)        / (1 * 1e9) * (1*1e9)             / (32*1e9)      * (1 * 1e9)
    64  			want: uint64(31000000000), // 32 * 1e9 - 1000000000
    65  		},
    66  		{
    67  			state: &pb.BeaconState{
    68  				Validators: []*ethpb.Validator{
    69  					{Slashed: true,
    70  						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
    71  						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
    72  					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
    73  					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
    74  				},
    75  				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
    76  				Slashings: []uint64{0, 1e9},
    77  			},
    78  			// penalty    = validator balance / increment * (2*total_penalties) / total_balance * increment
    79  			// 500000000 = (32 * 1e9)        / (1 * 1e9) * (1*1e9)             / (32*1e9)      * (1 * 1e9)
    80  			want: uint64(32000000000), // 32 * 1e9 - 500000000
    81  		},
    82  		{
    83  			state: &pb.BeaconState{
    84  				Validators: []*ethpb.Validator{
    85  					{Slashed: true,
    86  						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
    87  						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
    88  					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
    89  					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
    90  				},
    91  				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
    92  				Slashings: []uint64{0, 2 * 1e9},
    93  			},
    94  			// penalty    = validator balance / increment * (3*total_penalties) / total_balance * increment
    95  			// 1000000000 = (32 * 1e9)        / (1 * 1e9) * (1*2e9)             / (64*1e9)      * (1 * 1e9)
    96  			want: uint64(31000000000), // 32 * 1e9 - 1000000000
    97  		},
    98  		{
    99  			state: &pb.BeaconState{
   100  				Validators: []*ethpb.Validator{
   101  					{Slashed: true,
   102  						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
   103  						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement},
   104  					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement}},
   105  				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement, params.BeaconConfig().MaxEffectiveBalance - params.BeaconConfig().EffectiveBalanceIncrement},
   106  				Slashings: []uint64{0, 1e9},
   107  			},
   108  			// penalty    = validator balance           / increment * (3*total_penalties) / total_balance        * increment
   109  			// 2000000000 = (32  * 1e9 - 1*1e9)         / (1 * 1e9) * (2*1e9)             / (31*1e9)             * (1 * 1e9)
   110  			want: uint64(30000000000), // 32 * 1e9 - 2000000000
   111  		},
   112  	}
   113  
   114  	for i, tt := range tests {
   115  		t.Run(fmt.Sprint(i), func(t *testing.T) {
   116  			ab := uint64(0)
   117  			for i, b := range tt.state.Balances {
   118  				// Skip validator 0 since it's slashed
   119  				if i == 0 {
   120  					continue
   121  				}
   122  				ab += b
   123  			}
   124  			pBal := &precompute.Balance{ActiveCurrentEpoch: ab}
   125  
   126  			original := proto.Clone(tt.state)
   127  			state, err := v1.InitializeFromProto(tt.state)
   128  			require.NoError(t, err)
   129  			require.NoError(t, precompute.ProcessSlashingsPrecompute(state, pBal))
   130  			assert.Equal(t, tt.want, state.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d; wanted %d", original, state.Balances()[0])
   131  		})
   132  	}
   133  }