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

     1  package precompute_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	types "github.com/prysmaticlabs/eth2-types"
     7  	"github.com/prysmaticlabs/go-bitfield"
     8  	"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
     9  	"github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
    10  	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
    11  	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
    12  	"github.com/prysmaticlabs/prysm/shared/params"
    13  	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
    14  	"github.com/prysmaticlabs/prysm/shared/testutil/require"
    15  )
    16  
    17  func TestProcessJustificationAndFinalizationPreCompute_ConsecutiveEpochs(t *testing.T) {
    18  	e := params.BeaconConfig().FarFutureEpoch
    19  	a := params.BeaconConfig().MaxEffectiveBalance
    20  	blockRoots := make([][]byte, params.BeaconConfig().SlotsPerEpoch*2+1)
    21  	for i := 0; i < len(blockRoots); i++ {
    22  		blockRoots[i] = []byte{byte(i)}
    23  	}
    24  	base := &pb.BeaconState{
    25  		Slot: params.BeaconConfig().SlotsPerEpoch*2 + 1,
    26  		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{
    27  			Epoch: 0,
    28  			Root:  params.BeaconConfig().ZeroHash[:],
    29  		},
    30  		CurrentJustifiedCheckpoint: &ethpb.Checkpoint{
    31  			Epoch: 0,
    32  			Root:  params.BeaconConfig().ZeroHash[:],
    33  		},
    34  		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
    35  		JustificationBits:   bitfield.Bitvector4{0x0F}, // 0b1111
    36  		Validators:          []*ethpb.Validator{{ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}},
    37  		Balances:            []uint64{a, a, a, a}, // validator total balance should be 128000000000
    38  		BlockRoots:          blockRoots,
    39  	}
    40  	state, err := v1.InitializeFromProto(base)
    41  	require.NoError(t, err)
    42  	attestedBalance := 4 * uint64(e) * 3 / 2
    43  	b := &precompute.Balance{PrevEpochTargetAttested: attestedBalance}
    44  	newState, err := precompute.ProcessJustificationAndFinalizationPreCompute(state, b)
    45  	require.NoError(t, err)
    46  	rt := [32]byte{byte(64)}
    47  	assert.DeepEqual(t, rt[:], newState.CurrentJustifiedCheckpoint().Root, "Unexpected justified root")
    48  	assert.Equal(t, types.Epoch(2), newState.CurrentJustifiedCheckpoint().Epoch, "Unexpected justified epoch")
    49  	assert.Equal(t, types.Epoch(0), newState.PreviousJustifiedCheckpoint().Epoch, "Unexpected previous justified epoch")
    50  	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], newState.FinalizedCheckpoint().Root, "Unexpected finalized root")
    51  	assert.Equal(t, types.Epoch(0), newState.FinalizedCheckpointEpoch(), "Unexpected finalized epoch")
    52  }
    53  
    54  func TestProcessJustificationAndFinalizationPreCompute_JustifyCurrentEpoch(t *testing.T) {
    55  	e := params.BeaconConfig().FarFutureEpoch
    56  	a := params.BeaconConfig().MaxEffectiveBalance
    57  	blockRoots := make([][]byte, params.BeaconConfig().SlotsPerEpoch*2+1)
    58  	for i := 0; i < len(blockRoots); i++ {
    59  		blockRoots[i] = []byte{byte(i)}
    60  	}
    61  	base := &pb.BeaconState{
    62  		Slot: params.BeaconConfig().SlotsPerEpoch*2 + 1,
    63  		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{
    64  			Epoch: 0,
    65  			Root:  params.BeaconConfig().ZeroHash[:],
    66  		},
    67  		CurrentJustifiedCheckpoint: &ethpb.Checkpoint{
    68  			Epoch: 0,
    69  			Root:  params.BeaconConfig().ZeroHash[:],
    70  		},
    71  		FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
    72  		JustificationBits:   bitfield.Bitvector4{0x03}, // 0b0011
    73  		Validators:          []*ethpb.Validator{{ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}},
    74  		Balances:            []uint64{a, a, a, a}, // validator total balance should be 128000000000
    75  		BlockRoots:          blockRoots,
    76  	}
    77  	state, err := v1.InitializeFromProto(base)
    78  	require.NoError(t, err)
    79  	attestedBalance := 4 * uint64(e) * 3 / 2
    80  	b := &precompute.Balance{PrevEpochTargetAttested: attestedBalance}
    81  	newState, err := precompute.ProcessJustificationAndFinalizationPreCompute(state, b)
    82  	require.NoError(t, err)
    83  	rt := [32]byte{byte(64)}
    84  	assert.DeepEqual(t, rt[:], newState.CurrentJustifiedCheckpoint().Root, "Unexpected current justified root")
    85  	assert.Equal(t, types.Epoch(2), newState.CurrentJustifiedCheckpoint().Epoch, "Unexpected justified epoch")
    86  	assert.Equal(t, types.Epoch(0), newState.PreviousJustifiedCheckpoint().Epoch, "Unexpected previous justified epoch")
    87  	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], newState.FinalizedCheckpoint().Root)
    88  	assert.Equal(t, types.Epoch(0), newState.FinalizedCheckpointEpoch(), "Unexpected finalized epoch")
    89  }
    90  
    91  func TestProcessJustificationAndFinalizationPreCompute_JustifyPrevEpoch(t *testing.T) {
    92  	e := params.BeaconConfig().FarFutureEpoch
    93  	a := params.BeaconConfig().MaxEffectiveBalance
    94  	blockRoots := make([][]byte, params.BeaconConfig().SlotsPerEpoch*2+1)
    95  	for i := 0; i < len(blockRoots); i++ {
    96  		blockRoots[i] = []byte{byte(i)}
    97  	}
    98  	base := &pb.BeaconState{
    99  		Slot: params.BeaconConfig().SlotsPerEpoch*2 + 1,
   100  		PreviousJustifiedCheckpoint: &ethpb.Checkpoint{
   101  			Epoch: 0,
   102  			Root:  params.BeaconConfig().ZeroHash[:],
   103  		},
   104  		CurrentJustifiedCheckpoint: &ethpb.Checkpoint{
   105  			Epoch: 0,
   106  			Root:  params.BeaconConfig().ZeroHash[:],
   107  		},
   108  		JustificationBits: bitfield.Bitvector4{0x03}, // 0b0011
   109  		Validators:        []*ethpb.Validator{{ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}},
   110  		Balances:          []uint64{a, a, a, a}, // validator total balance should be 128000000000
   111  		BlockRoots:        blockRoots, FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
   112  	}
   113  	state, err := v1.InitializeFromProto(base)
   114  	require.NoError(t, err)
   115  	attestedBalance := 4 * uint64(e) * 3 / 2
   116  	b := &precompute.Balance{PrevEpochTargetAttested: attestedBalance}
   117  	newState, err := precompute.ProcessJustificationAndFinalizationPreCompute(state, b)
   118  	require.NoError(t, err)
   119  	rt := [32]byte{byte(64)}
   120  	assert.DeepEqual(t, rt[:], newState.CurrentJustifiedCheckpoint().Root, "Unexpected current justified root")
   121  	assert.Equal(t, types.Epoch(0), newState.PreviousJustifiedCheckpoint().Epoch, "Unexpected previous justified epoch")
   122  	assert.Equal(t, types.Epoch(2), newState.CurrentJustifiedCheckpoint().Epoch, "Unexpected justified epoch")
   123  	assert.DeepEqual(t, params.BeaconConfig().ZeroHash[:], newState.FinalizedCheckpoint().Root)
   124  	assert.Equal(t, types.Epoch(0), newState.FinalizedCheckpointEpoch(), "Unexpected finalized epoch")
   125  }