github.com/prysmaticlabs/prysm@v1.4.4/proto/migration/migration_test.go (about)

     1  package migration
     2  
     3  import (
     4  	"testing"
     5  
     6  	types "github.com/prysmaticlabs/eth2-types"
     7  	"github.com/prysmaticlabs/go-bitfield"
     8  	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1"
     9  	ethpb_alpha "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
    10  	"github.com/prysmaticlabs/prysm/proto/eth/v1alpha1/wrapper"
    11  	"github.com/prysmaticlabs/prysm/shared/bytesutil"
    12  	"github.com/prysmaticlabs/prysm/shared/testutil"
    13  	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
    14  	"github.com/prysmaticlabs/prysm/shared/testutil/require"
    15  )
    16  
    17  var (
    18  	slot             = types.Slot(1)
    19  	epoch            = types.Epoch(1)
    20  	validatorIndex   = types.ValidatorIndex(1)
    21  	committeeIndex   = types.CommitteeIndex(1)
    22  	depositCount     = uint64(2)
    23  	attestingIndices = []uint64{1, 2}
    24  	parentRoot       = bytesutil.PadTo([]byte("parentroot"), 32)
    25  	stateRoot        = bytesutil.PadTo([]byte("stateroot"), 32)
    26  	signature        = bytesutil.PadTo([]byte("signature"), 96)
    27  	randaoReveal     = bytesutil.PadTo([]byte("randaoreveal"), 96)
    28  	depositRoot      = bytesutil.PadTo([]byte("depositroot"), 32)
    29  	blockHash        = bytesutil.PadTo([]byte("blockhash"), 32)
    30  	beaconBlockRoot  = bytesutil.PadTo([]byte("beaconblockroot"), 32)
    31  	sourceRoot       = bytesutil.PadTo([]byte("sourceroot"), 32)
    32  	targetRoot       = bytesutil.PadTo([]byte("targetroot"), 32)
    33  	bodyRoot         = bytesutil.PadTo([]byte("bodyroot"), 32)
    34  	aggregationBits  = bitfield.Bitlist{0x01}
    35  )
    36  
    37  func Test_BlockIfaceToV1BlockHeader(t *testing.T) {
    38  	alphaBlock := testutil.HydrateSignedBeaconBlock(&ethpb_alpha.SignedBeaconBlock{})
    39  	alphaBlock.Block.Slot = slot
    40  	alphaBlock.Block.ProposerIndex = validatorIndex
    41  	alphaBlock.Block.ParentRoot = parentRoot
    42  	alphaBlock.Block.StateRoot = stateRoot
    43  	alphaBlock.Signature = signature
    44  
    45  	v1Header, err := BlockIfaceToV1BlockHeader(wrapper.WrappedPhase0SignedBeaconBlock(alphaBlock))
    46  	require.NoError(t, err)
    47  	bodyRoot, err := alphaBlock.Block.Body.HashTreeRoot()
    48  	require.NoError(t, err)
    49  	assert.DeepEqual(t, bodyRoot[:], v1Header.Message.BodyRoot)
    50  	assert.Equal(t, slot, v1Header.Message.Slot)
    51  	assert.Equal(t, validatorIndex, v1Header.Message.ProposerIndex)
    52  	assert.DeepEqual(t, parentRoot, v1Header.Message.ParentRoot)
    53  	assert.DeepEqual(t, stateRoot, v1Header.Message.StateRoot)
    54  	assert.DeepEqual(t, signature, v1Header.Signature)
    55  }
    56  
    57  func Test_V1Alpha1AggregateAttAndProofToV1(t *testing.T) {
    58  	proof := [32]byte{1}
    59  	att := testutil.HydrateAttestation(&ethpb_alpha.Attestation{
    60  		Data: &ethpb_alpha.AttestationData{
    61  			Slot: 5,
    62  		},
    63  	})
    64  	alpha := &ethpb_alpha.AggregateAttestationAndProof{
    65  		AggregatorIndex: 1,
    66  		Aggregate:       att,
    67  		SelectionProof:  proof[:],
    68  	}
    69  	v1 := V1Alpha1AggregateAttAndProofToV1(alpha)
    70  	assert.Equal(t, v1.AggregatorIndex, types.ValidatorIndex(1))
    71  	assert.DeepSSZEqual(t, v1.Aggregate.Data.Slot, att.Data.Slot)
    72  	assert.DeepEqual(t, v1.SelectionProof, proof[:])
    73  }
    74  
    75  func Test_V1Alpha1BlockToV1BlockHeader(t *testing.T) {
    76  	alphaBlock := testutil.HydrateSignedBeaconBlock(&ethpb_alpha.SignedBeaconBlock{})
    77  	alphaBlock.Block.Slot = slot
    78  	alphaBlock.Block.ProposerIndex = validatorIndex
    79  	alphaBlock.Block.ParentRoot = parentRoot
    80  	alphaBlock.Block.StateRoot = stateRoot
    81  	alphaBlock.Signature = signature
    82  
    83  	v1Header, err := V1Alpha1BlockToV1BlockHeader(alphaBlock)
    84  	require.NoError(t, err)
    85  	bodyRoot, err := alphaBlock.Block.Body.HashTreeRoot()
    86  	require.NoError(t, err)
    87  	assert.DeepEqual(t, bodyRoot[:], v1Header.Message.BodyRoot)
    88  	assert.Equal(t, slot, v1Header.Message.Slot)
    89  	assert.Equal(t, validatorIndex, v1Header.Message.ProposerIndex)
    90  	assert.DeepEqual(t, parentRoot, v1Header.Message.ParentRoot)
    91  	assert.DeepEqual(t, stateRoot, v1Header.Message.StateRoot)
    92  	assert.DeepEqual(t, signature, v1Header.Signature)
    93  }
    94  
    95  func Test_V1Alpha1ToV1Block(t *testing.T) {
    96  	alphaBlock := testutil.HydrateSignedBeaconBlock(&ethpb_alpha.SignedBeaconBlock{})
    97  	alphaBlock.Block.Slot = slot
    98  	alphaBlock.Block.ProposerIndex = validatorIndex
    99  	alphaBlock.Block.ParentRoot = parentRoot
   100  	alphaBlock.Block.StateRoot = stateRoot
   101  	alphaBlock.Block.Body.RandaoReveal = randaoReveal
   102  	alphaBlock.Block.Body.Eth1Data = &ethpb_alpha.Eth1Data{
   103  		DepositRoot:  depositRoot,
   104  		DepositCount: depositCount,
   105  		BlockHash:    blockHash,
   106  	}
   107  	alphaBlock.Signature = signature
   108  
   109  	v1Block, err := V1Alpha1ToV1Block(alphaBlock)
   110  	require.NoError(t, err)
   111  	alphaRoot, err := alphaBlock.HashTreeRoot()
   112  	require.NoError(t, err)
   113  	v1Root, err := v1Block.HashTreeRoot()
   114  	require.NoError(t, err)
   115  	assert.DeepEqual(t, alphaRoot, v1Root)
   116  }
   117  
   118  func Test_V1ToV1Alpha1Block(t *testing.T) {
   119  	v1Block := testutil.HydrateV1SignedBeaconBlock(&ethpb.SignedBeaconBlock{})
   120  	v1Block.Block.Slot = slot
   121  	v1Block.Block.ProposerIndex = validatorIndex
   122  	v1Block.Block.ParentRoot = parentRoot
   123  	v1Block.Block.StateRoot = stateRoot
   124  	v1Block.Block.Body.RandaoReveal = randaoReveal
   125  	v1Block.Block.Body.Eth1Data = &ethpb.Eth1Data{
   126  		DepositRoot:  depositRoot,
   127  		DepositCount: depositCount,
   128  		BlockHash:    blockHash,
   129  	}
   130  	v1Block.Signature = signature
   131  
   132  	alphaBlock, err := V1ToV1Alpha1Block(v1Block)
   133  	require.NoError(t, err)
   134  	alphaRoot, err := alphaBlock.HashTreeRoot()
   135  	require.NoError(t, err)
   136  	v1Root, err := v1Block.HashTreeRoot()
   137  	require.NoError(t, err)
   138  	assert.DeepEqual(t, v1Root, alphaRoot)
   139  }
   140  
   141  func Test_V1Alpha1AttSlashingToV1(t *testing.T) {
   142  	alphaAttestation := &ethpb_alpha.IndexedAttestation{
   143  		AttestingIndices: attestingIndices,
   144  		Data: &ethpb_alpha.AttestationData{
   145  			Slot:            slot,
   146  			CommitteeIndex:  committeeIndex,
   147  			BeaconBlockRoot: beaconBlockRoot,
   148  			Source: &ethpb_alpha.Checkpoint{
   149  				Epoch: epoch,
   150  				Root:  sourceRoot,
   151  			},
   152  			Target: &ethpb_alpha.Checkpoint{
   153  				Epoch: epoch,
   154  				Root:  targetRoot,
   155  			},
   156  		},
   157  		Signature: signature,
   158  	}
   159  	alphaSlashing := &ethpb_alpha.AttesterSlashing{
   160  		Attestation_1: alphaAttestation,
   161  		Attestation_2: alphaAttestation,
   162  	}
   163  
   164  	v1Slashing := V1Alpha1AttSlashingToV1(alphaSlashing)
   165  	alphaRoot, err := alphaSlashing.HashTreeRoot()
   166  	require.NoError(t, err)
   167  	v1Root, err := v1Slashing.HashTreeRoot()
   168  	require.NoError(t, err)
   169  	assert.DeepEqual(t, alphaRoot, v1Root)
   170  }
   171  
   172  func Test_V1Alpha1ProposerSlashingToV1(t *testing.T) {
   173  	alphaHeader := testutil.HydrateSignedBeaconHeader(&ethpb_alpha.SignedBeaconBlockHeader{})
   174  	alphaHeader.Header.Slot = slot
   175  	alphaHeader.Header.ProposerIndex = validatorIndex
   176  	alphaHeader.Header.ParentRoot = parentRoot
   177  	alphaHeader.Header.StateRoot = stateRoot
   178  	alphaHeader.Header.BodyRoot = bodyRoot
   179  	alphaHeader.Signature = signature
   180  	alphaSlashing := &ethpb_alpha.ProposerSlashing{
   181  		Header_1: alphaHeader,
   182  		Header_2: alphaHeader,
   183  	}
   184  
   185  	v1Slashing := V1Alpha1ProposerSlashingToV1(alphaSlashing)
   186  	alphaRoot, err := alphaSlashing.HashTreeRoot()
   187  	require.NoError(t, err)
   188  	v1Root, err := v1Slashing.HashTreeRoot()
   189  	require.NoError(t, err)
   190  	assert.DeepEqual(t, alphaRoot, v1Root)
   191  }
   192  
   193  func Test_V1Alpha1ExitToV1(t *testing.T) {
   194  	alphaExit := &ethpb_alpha.SignedVoluntaryExit{
   195  		Exit: &ethpb_alpha.VoluntaryExit{
   196  			Epoch:          epoch,
   197  			ValidatorIndex: validatorIndex,
   198  		},
   199  		Signature: signature,
   200  	}
   201  
   202  	v1Exit := V1Alpha1ExitToV1(alphaExit)
   203  	alphaRoot, err := alphaExit.HashTreeRoot()
   204  	require.NoError(t, err)
   205  	v1Root, err := v1Exit.HashTreeRoot()
   206  	require.NoError(t, err)
   207  	assert.DeepEqual(t, alphaRoot, v1Root)
   208  }
   209  
   210  func Test_V1ExitToV1Alpha1(t *testing.T) {
   211  	v1Exit := &ethpb.SignedVoluntaryExit{
   212  		Message: &ethpb.VoluntaryExit{
   213  			Epoch:          epoch,
   214  			ValidatorIndex: validatorIndex,
   215  		},
   216  		Signature: signature,
   217  	}
   218  
   219  	alphaExit := V1ExitToV1Alpha1(v1Exit)
   220  	alphaRoot, err := alphaExit.HashTreeRoot()
   221  	require.NoError(t, err)
   222  	v1Root, err := v1Exit.HashTreeRoot()
   223  	require.NoError(t, err)
   224  	assert.DeepEqual(t, alphaRoot, v1Root)
   225  }
   226  
   227  func Test_V1AttSlashingToV1Alpha1(t *testing.T) {
   228  	v1Attestation := &ethpb.IndexedAttestation{
   229  		AttestingIndices: attestingIndices,
   230  		Data: &ethpb.AttestationData{
   231  			Slot:            slot,
   232  			Index:           committeeIndex,
   233  			BeaconBlockRoot: beaconBlockRoot,
   234  			Source: &ethpb.Checkpoint{
   235  				Epoch: epoch,
   236  				Root:  sourceRoot,
   237  			},
   238  			Target: &ethpb.Checkpoint{
   239  				Epoch: epoch,
   240  				Root:  targetRoot,
   241  			},
   242  		},
   243  		Signature: signature,
   244  	}
   245  	v1Slashing := &ethpb.AttesterSlashing{
   246  		Attestation_1: v1Attestation,
   247  		Attestation_2: v1Attestation,
   248  	}
   249  
   250  	alphaSlashing := V1AttSlashingToV1Alpha1(v1Slashing)
   251  	alphaRoot, err := alphaSlashing.HashTreeRoot()
   252  	require.NoError(t, err)
   253  	v1Root, err := v1Slashing.HashTreeRoot()
   254  	require.NoError(t, err)
   255  	assert.DeepEqual(t, v1Root, alphaRoot)
   256  }
   257  
   258  func Test_V1ProposerSlashingToV1Alpha1(t *testing.T) {
   259  	v1Header := &ethpb.SignedBeaconBlockHeader{
   260  		Message: &ethpb.BeaconBlockHeader{
   261  			Slot:          slot,
   262  			ProposerIndex: validatorIndex,
   263  			ParentRoot:    parentRoot,
   264  			StateRoot:     stateRoot,
   265  			BodyRoot:      bodyRoot,
   266  		},
   267  		Signature: signature,
   268  	}
   269  	v1Slashing := &ethpb.ProposerSlashing{
   270  		SignedHeader_1: v1Header,
   271  		SignedHeader_2: v1Header,
   272  	}
   273  
   274  	alphaSlashing := V1ProposerSlashingToV1Alpha1(v1Slashing)
   275  	alphaRoot, err := alphaSlashing.HashTreeRoot()
   276  	require.NoError(t, err)
   277  	v1Root, err := v1Slashing.HashTreeRoot()
   278  	require.NoError(t, err)
   279  	assert.DeepEqual(t, alphaRoot, v1Root)
   280  }
   281  
   282  func Test_V1Alpha1AttToV1(t *testing.T) {
   283  	alphaAtt := &ethpb_alpha.Attestation{
   284  		AggregationBits: aggregationBits,
   285  		Data: &ethpb_alpha.AttestationData{
   286  			Slot:            slot,
   287  			CommitteeIndex:  committeeIndex,
   288  			BeaconBlockRoot: beaconBlockRoot,
   289  			Source: &ethpb_alpha.Checkpoint{
   290  				Epoch: epoch,
   291  				Root:  sourceRoot,
   292  			},
   293  			Target: &ethpb_alpha.Checkpoint{
   294  				Epoch: epoch,
   295  				Root:  targetRoot,
   296  			},
   297  		},
   298  		Signature: signature,
   299  	}
   300  
   301  	v1Att := V1Alpha1AttestationToV1(alphaAtt)
   302  	v1Root, err := v1Att.HashTreeRoot()
   303  	require.NoError(t, err)
   304  	alphaRoot, err := alphaAtt.HashTreeRoot()
   305  	require.NoError(t, err)
   306  	assert.DeepEqual(t, v1Root, alphaRoot)
   307  }
   308  
   309  func Test_V1AttToV1Alpha1(t *testing.T) {
   310  	v1Att := &ethpb.Attestation{
   311  		AggregationBits: aggregationBits,
   312  		Data: &ethpb.AttestationData{
   313  			Slot:            slot,
   314  			Index:           committeeIndex,
   315  			BeaconBlockRoot: beaconBlockRoot,
   316  			Source: &ethpb.Checkpoint{
   317  				Epoch: epoch,
   318  				Root:  sourceRoot,
   319  			},
   320  			Target: &ethpb.Checkpoint{
   321  				Epoch: epoch,
   322  				Root:  targetRoot,
   323  			},
   324  		},
   325  		Signature: signature,
   326  	}
   327  
   328  	alphaAtt := V1AttToV1Alpha1(v1Att)
   329  	alphaRoot, err := alphaAtt.HashTreeRoot()
   330  	require.NoError(t, err)
   331  	v1Root, err := v1Att.HashTreeRoot()
   332  	require.NoError(t, err)
   333  	assert.DeepEqual(t, v1Root, alphaRoot)
   334  }
   335  
   336  func Test_BlockInterfaceToV1Block(t *testing.T) {
   337  	v1Alpha1Block := testutil.HydrateSignedBeaconBlock(&ethpb_alpha.SignedBeaconBlock{})
   338  	v1Alpha1Block.Block.Slot = slot
   339  	v1Alpha1Block.Block.ProposerIndex = validatorIndex
   340  	v1Alpha1Block.Block.ParentRoot = parentRoot
   341  	v1Alpha1Block.Block.StateRoot = stateRoot
   342  	v1Alpha1Block.Block.Body.RandaoReveal = randaoReveal
   343  	v1Alpha1Block.Block.Body.Eth1Data = &ethpb_alpha.Eth1Data{
   344  		DepositRoot:  depositRoot,
   345  		DepositCount: depositCount,
   346  		BlockHash:    blockHash,
   347  	}
   348  	v1Alpha1Block.Signature = signature
   349  
   350  	v1Block, err := SignedBeaconBlock(wrapper.WrappedPhase0SignedBeaconBlock(v1Alpha1Block))
   351  	require.NoError(t, err)
   352  	v1Root, err := v1Block.HashTreeRoot()
   353  	require.NoError(t, err)
   354  	v1Alpha1Root, err := v1Alpha1Block.HashTreeRoot()
   355  	require.NoError(t, err)
   356  	assert.DeepEqual(t, v1Root, v1Alpha1Root)
   357  }