github.com/prysmaticlabs/prysm@v1.4.4/beacon-chain/core/helpers/signing_root_test.go (about) 1 package helpers_test 2 3 import ( 4 "bytes" 5 "testing" 6 7 fuzz "github.com/google/gofuzz" 8 "github.com/prysmaticlabs/prysm/beacon-chain/core/helpers" 9 iface "github.com/prysmaticlabs/prysm/beacon-chain/state/interface" 10 ethereum_beacon_p2p_v1 "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1" 11 eth "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1" 12 "github.com/prysmaticlabs/prysm/shared/bls" 13 "github.com/prysmaticlabs/prysm/shared/bytesutil" 14 "github.com/prysmaticlabs/prysm/shared/params" 15 "github.com/prysmaticlabs/prysm/shared/testutil" 16 "github.com/prysmaticlabs/prysm/shared/testutil/assert" 17 "github.com/prysmaticlabs/prysm/shared/testutil/require" 18 ) 19 20 func TestSigningRoot_ComputeSigningRoot(t *testing.T) { 21 emptyBlock := testutil.NewBeaconBlock() 22 _, err := helpers.ComputeSigningRoot(emptyBlock, bytesutil.PadTo([]byte{'T', 'E', 'S', 'T'}, 32)) 23 assert.NoError(t, err, "Could not compute signing root of block") 24 } 25 26 func TestSigningRoot_ComputeDomain(t *testing.T) { 27 tests := []struct { 28 epoch uint64 29 domainType [4]byte 30 domain []byte 31 }{ 32 {epoch: 1, domainType: [4]byte{4, 0, 0, 0}, domain: []byte{4, 0, 0, 0, 245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169}}, 33 {epoch: 2, domainType: [4]byte{4, 0, 0, 0}, domain: []byte{4, 0, 0, 0, 245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169}}, 34 {epoch: 2, domainType: [4]byte{5, 0, 0, 0}, domain: []byte{5, 0, 0, 0, 245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169}}, 35 {epoch: 3, domainType: [4]byte{4, 0, 0, 0}, domain: []byte{4, 0, 0, 0, 245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169}}, 36 {epoch: 3, domainType: [4]byte{5, 0, 0, 0}, domain: []byte{5, 0, 0, 0, 245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169}}, 37 } 38 for _, tt := range tests { 39 if got, err := helpers.ComputeDomain(tt.domainType, nil, nil); !bytes.Equal(got, tt.domain) { 40 t.Errorf("wanted domain version: %d, got: %d", tt.domain, got) 41 } else { 42 require.NoError(t, err) 43 } 44 } 45 } 46 47 func TestSigningRoot_ComputeDomainAndSign(t *testing.T) { 48 tests := []struct { 49 name string 50 genState func(t *testing.T) (iface.BeaconState, []bls.SecretKey) 51 genBlock func(t *testing.T, st iface.BeaconState, keys []bls.SecretKey) *eth.SignedBeaconBlock 52 domainType [4]byte 53 want []byte 54 }{ 55 { 56 name: "block proposer", 57 genState: func(t *testing.T) (iface.BeaconState, []bls.SecretKey) { 58 beaconState, privKeys := testutil.DeterministicGenesisState(t, 100) 59 require.NoError(t, beaconState.SetSlot(beaconState.Slot()+1)) 60 return beaconState, privKeys 61 }, 62 genBlock: func(t *testing.T, st iface.BeaconState, keys []bls.SecretKey) *eth.SignedBeaconBlock { 63 block, err := testutil.GenerateFullBlock(st, keys, nil, 1) 64 require.NoError(t, err) 65 return block 66 }, 67 domainType: params.BeaconConfig().DomainBeaconProposer, 68 want: []byte{ 69 0xad, 0xd8, 0xf0, 0xd1, 0xae, 0x82, 0xaa, 0x3, 0x9a, 0xcd, 0x8e, 0xb7, 0x84, 0x14, 0x1c, 0x21, 0x81, 70 0xbc, 0x1b, 0x2, 0xb5, 0x6d, 0x4c, 0x76, 0x36, 0x5f, 0xba, 0x6e, 0x33, 0x9e, 0xda, 0xe, 0x36, 0xe1, 71 0xf, 0x30, 0xae, 0x6, 0x44, 0xd4, 0x38, 0x21, 0xf0, 0x45, 0xc2, 0x54, 0x68, 0x2f, 0x12, 0xcc, 0x27, 72 0x45, 0x72, 0x5, 0xaf, 0xb4, 0x85, 0x60, 0xdb, 0x7a, 0x1f, 0xe7, 0xa8, 0x62, 0xf5, 0x71, 0xac, 0x88, 73 0x8c, 0xd3, 0xba, 0x4d, 0xa3, 0x3d, 0x3b, 0x87, 0x9b, 0x23, 0xae, 0xe4, 0x46, 0xc6, 0x36, 0xca, 0xa5, 74 0xa1, 0x2d, 0x9e, 0x7, 0xc1, 0x40, 0xed, 0x99, 0xfd, 0xae, 0xce, 75 }, 76 }, 77 } 78 79 for _, tt := range tests { 80 t.Run(tt.name, func(t *testing.T) { 81 beaconState, privKeys := tt.genState(t) 82 idx, err := helpers.BeaconProposerIndex(beaconState) 83 require.NoError(t, err) 84 block := tt.genBlock(t, beaconState, privKeys) 85 got, err := helpers.ComputeDomainAndSign( 86 beaconState, helpers.CurrentEpoch(beaconState), block, tt.domainType, privKeys[idx]) 87 require.NoError(t, err) 88 require.DeepEqual(t, tt.want, got, "Incorrect signature") 89 }) 90 } 91 } 92 93 func TestSigningRoot_ComputeForkDigest(t *testing.T) { 94 tests := []struct { 95 version []byte 96 root [32]byte 97 result [4]byte 98 }{ 99 {version: []byte{'A', 'B', 'C', 'D'}, root: [32]byte{'i', 'o', 'p'}, result: [4]byte{0x69, 0x5c, 0x26, 0x47}}, 100 {version: []byte{'i', 'm', 'n', 'a'}, root: [32]byte{'z', 'a', 'b'}, result: [4]byte{0x1c, 0x38, 0x84, 0x58}}, 101 {version: []byte{'b', 'w', 'r', 't'}, root: [32]byte{'r', 'd', 'c'}, result: [4]byte{0x83, 0x34, 0x38, 0x88}}, 102 } 103 for _, tt := range tests { 104 digest, err := helpers.ComputeForkDigest(tt.version, tt.root[:]) 105 require.NoError(t, err) 106 assert.Equal(t, tt.result, digest, "Wanted domain version: %#x, got: %#x", digest, tt.result) 107 } 108 } 109 110 func TestFuzzverifySigningRoot_10000(t *testing.T) { 111 fuzzer := fuzz.NewWithSeed(0) 112 state := ðereum_beacon_p2p_v1.BeaconState{} 113 pubkey := [48]byte{} 114 sig := [96]byte{} 115 domain := [4]byte{} 116 var p []byte 117 var s []byte 118 var d []byte 119 for i := 0; i < 10000; i++ { 120 fuzzer.Fuzz(state) 121 fuzzer.Fuzz(&pubkey) 122 fuzzer.Fuzz(&sig) 123 fuzzer.Fuzz(&domain) 124 fuzzer.Fuzz(state) 125 fuzzer.Fuzz(&p) 126 fuzzer.Fuzz(&s) 127 fuzzer.Fuzz(&d) 128 err := helpers.VerifySigningRoot(state, pubkey[:], sig[:], domain[:]) 129 _ = err 130 err = helpers.VerifySigningRoot(state, p, s, d) 131 _ = err 132 } 133 }