github.com/unicornultrafoundation/go-u2u@v1.0.0-rc1.0.20240205080301-e74a83d3fadc/gossip/heavycheck_test.go (about)

     1  package gossip
     2  
     3  import (
     4  	"bytes"
     5  	"math"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/suite"
     9  	"github.com/unicornultrafoundation/go-helios/hash"
    10  	"github.com/unicornultrafoundation/go-helios/native/idx"
    11  	"github.com/unicornultrafoundation/go-u2u/core/types"
    12  
    13  	"github.com/unicornultrafoundation/go-u2u/eventcheck/epochcheck"
    14  	"github.com/unicornultrafoundation/go-u2u/eventcheck/heavycheck"
    15  	"github.com/unicornultrafoundation/go-u2u/native"
    16  )
    17  
    18  type LLRHeavyCheckTestSuite struct {
    19  	suite.Suite
    20  
    21  	env        *testEnv
    22  	me         *native.MutableEventPayload
    23  	startEpoch idx.Epoch
    24  }
    25  
    26  func (s *LLRHeavyCheckTestSuite) SetupSuite() {
    27  	s.T().Log("setting up test suite")
    28  
    29  	const (
    30  		validatorsNum = 10
    31  		startEpoch    = 1
    32  	)
    33  
    34  	env := newTestEnv(startEpoch, validatorsNum)
    35  
    36  	em := env.emitters[0]
    37  	e, err := em.EmitEvent()
    38  	s.Require().NoError(err)
    39  	s.Require().NotNil(e)
    40  
    41  	s.env = env
    42  	s.me = mutableEventPayloadFromImmutable(e)
    43  	s.startEpoch = idx.Epoch(startEpoch)
    44  }
    45  
    46  func (s *LLRHeavyCheckTestSuite) TearDownSuite() {
    47  	s.T().Log("tearing down test suite")
    48  	s.env.Close()
    49  }
    50  
    51  func (s *LLRHeavyCheckTestSuite) TestHeavyCheckValidateEV() {
    52  
    53  	var ev native.LlrSignedEpochVote
    54  
    55  	testCases := []struct {
    56  		name    string
    57  		errExp  error
    58  		pretest func()
    59  	}{
    60  		{
    61  			"validateEV returns nil",
    62  			nil,
    63  			func() {
    64  				ev = native.LlrSignedEpochVote{
    65  					Val: native.LlrEpochVote{
    66  						Epoch: s.startEpoch + 1,
    67  						Vote:  hash.HexToHash("0x01"),
    68  					},
    69  				}
    70  				s.me.SetVersion(1)
    71  				s.me.SetEpochVote(ev.Val)
    72  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
    73  				s.me.SetCreator(3)
    74  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
    75  
    76  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
    77  				s.Require().NoError(err)
    78  				sSig := native.Signature{}
    79  				copy(sSig[:], sig)
    80  				s.me.SetSig(sSig)
    81  				ev = native.AsSignedEpochVote(s.me)
    82  			},
    83  		},
    84  		{
    85  			"validateEV returns ErrUnknownEpochEV",
    86  			heavycheck.ErrUnknownEpochEV,
    87  			func() {
    88  				ev = native.LlrSignedEpochVote{
    89  					Val: native.LlrEpochVote{
    90  						Epoch: s.startEpoch,
    91  						Vote:  hash.HexToHash("0x01"),
    92  					},
    93  				}
    94  				s.me.SetVersion(1)
    95  				s.me.SetEpochVote(ev.Val)
    96  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
    97  				s.me.SetCreator(3)
    98  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
    99  
   100  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   101  				s.Require().NoError(err)
   102  				sSig := native.Signature{}
   103  				copy(sSig[:], sig)
   104  				s.me.SetSig(sSig)
   105  				ev = native.AsSignedEpochVote(s.me)
   106  			},
   107  		},
   108  		{
   109  			"epochcheck.ErrAuth",
   110  			epochcheck.ErrAuth,
   111  			func() {
   112  				ev = native.LlrSignedEpochVote{
   113  					Val: native.LlrEpochVote{
   114  						Epoch: s.startEpoch + 1,
   115  						Vote:  hash.HexToHash("0x01"),
   116  					},
   117  				}
   118  
   119  				s.me.SetVersion(1)
   120  				s.me.SetEpochVote(ev.Val)
   121  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
   122  				s.me.SetCreator(100)
   123  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   124  
   125  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   126  				s.Require().NoError(err)
   127  				sSig := native.Signature{}
   128  				copy(sSig[:], sig)
   129  				s.me.SetSig(sSig)
   130  				ev = native.AsSignedEpochVote(s.me)
   131  			},
   132  		},
   133  		{
   134  			"ErrWrongPayloadHash",
   135  			heavycheck.ErrWrongPayloadHash,
   136  			func() {
   137  				ev = native.LlrSignedEpochVote{
   138  					Val: native.LlrEpochVote{
   139  						Epoch: s.startEpoch + 1,
   140  						Vote:  hash.HexToHash("0x01"),
   141  					},
   142  				}
   143  
   144  				s.me.SetVersion(1)
   145  				s.me.SetEpochVote(ev.Val)
   146  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
   147  				s.me.SetCreator(3)
   148  				s.me.SetPayloadHash(hash.Hash{})
   149  
   150  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   151  				s.Require().NoError(err)
   152  				sSig := native.Signature{}
   153  				copy(sSig[:], sig)
   154  				s.me.SetSig(sSig)
   155  				ev = native.AsSignedEpochVote(s.me)
   156  			},
   157  		},
   158  
   159  		{
   160  			"ErrWrongEventSig",
   161  			heavycheck.ErrWrongEventSig,
   162  			func() {
   163  				ev = native.LlrSignedEpochVote{
   164  					Val: native.LlrEpochVote{
   165  						Epoch: s.startEpoch + 1,
   166  						Vote:  hash.HexToHash("0x01"),
   167  					},
   168  				}
   169  
   170  				s.me.SetVersion(1)
   171  				s.me.SetEpochVote(ev.Val)
   172  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
   173  				s.me.SetCreator(4)
   174  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   175  
   176  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   177  				s.Require().NoError(err)
   178  				sSig := native.Signature{}
   179  				copy(sSig[:], sig)
   180  				s.me.SetSig(sSig)
   181  				ev = native.AsSignedEpochVote(s.me)
   182  				ev.Signed.Locator.Creator = 5
   183  			},
   184  		},
   185  	}
   186  
   187  	for _, tc := range testCases {
   188  		tc := tc
   189  		s.Run(tc.name, func() {
   190  			s.SetupSuite()
   191  			tc.pretest()
   192  
   193  			err := s.env.checkers.Heavycheck.ValidateEV(ev)
   194  
   195  			if tc.errExp != nil {
   196  				s.Require().Error(err)
   197  				s.Require().EqualError(err, tc.errExp.Error())
   198  			} else {
   199  				s.Require().NoError(err)
   200  			}
   201  		})
   202  	}
   203  
   204  }
   205  
   206  func (s *LLRHeavyCheckTestSuite) TestHeavyCheckValidateBVs() {
   207  	var bv native.LlrSignedBlockVotes
   208  
   209  	testCases := []struct {
   210  		name    string
   211  		errExp  error
   212  		pretest func()
   213  	}{
   214  		{
   215  			"success",
   216  			nil,
   217  			func() {
   218  				bv = native.LlrSignedBlockVotes{
   219  					Val: native.LlrBlockVotes{
   220  						Start: 1,
   221  						Epoch: s.startEpoch,
   222  						Votes: []hash.Hash{
   223  							hash.Zero,
   224  							hash.HexToHash("0x01"),
   225  						},
   226  					},
   227  				}
   228  
   229  				s.me.SetVersion(1)
   230  				s.me.SetBlockVotes(bv.Val)
   231  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   232  				s.me.SetCreator(2)
   233  
   234  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   235  
   236  				sig, err := s.env.signer.Sign(s.env.pubkeys[1], s.me.HashToSign().Bytes())
   237  				s.Require().NoError(err)
   238  				sSig := native.Signature{}
   239  				copy(sSig[:], sig)
   240  				s.me.SetSig(sSig)
   241  
   242  				bv = native.AsSignedBlockVotes(s.me)
   243  			},
   244  		},
   245  		{
   246  			"ErrUnknownEpochBVs",
   247  			heavycheck.ErrUnknownEpochBVs,
   248  			func() {
   249  				bv = native.LlrSignedBlockVotes{
   250  					Val: native.LlrBlockVotes{
   251  						Start: 1,
   252  						Epoch: 25,
   253  						Votes: []hash.Hash{
   254  							hash.Zero,
   255  							hash.HexToHash("0x01"),
   256  						},
   257  					},
   258  				}
   259  
   260  				s.me.SetVersion(1)
   261  				s.me.SetBlockVotes(bv.Val)
   262  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
   263  				s.me.SetCreator(2)
   264  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   265  
   266  				sig, err := s.env.signer.Sign(s.env.pubkeys[1], s.me.HashToSign().Bytes())
   267  				s.Require().NoError(err)
   268  				sSig := native.Signature{}
   269  				copy(sSig[:], sig)
   270  				s.me.SetSig(sSig)
   271  
   272  				bv = native.AsSignedBlockVotes(s.me)
   273  			},
   274  		},
   275  		{
   276  			"ErrImpossibleBVsEpoch",
   277  			heavycheck.ErrImpossibleBVsEpoch,
   278  			func() {
   279  				bv = native.LlrSignedBlockVotes{
   280  					Val: native.LlrBlockVotes{
   281  						Start: 0,
   282  						Epoch: s.startEpoch,
   283  						Votes: []hash.Hash{
   284  							hash.Zero,
   285  							hash.HexToHash("0x01"),
   286  						},
   287  					},
   288  				}
   289  
   290  				s.me.SetVersion(1)
   291  				s.me.SetBlockVotes(bv.Val)
   292  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
   293  				s.me.SetCreator(2)
   294  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   295  
   296  				sig, err := s.env.signer.Sign(s.env.pubkeys[1], s.me.HashToSign().Bytes())
   297  				s.Require().NoError(err)
   298  				sSig := native.Signature{}
   299  				copy(sSig[:], sig)
   300  				s.me.SetSig(sSig)
   301  
   302  				bv = native.AsSignedBlockVotes(s.me)
   303  			},
   304  		},
   305  		{
   306  			"ErrUnknownEpochBVs",
   307  			heavycheck.ErrUnknownEpochBVs,
   308  			func() {
   309  				bv = native.LlrSignedBlockVotes{
   310  					Val: native.LlrBlockVotes{
   311  						Start: 1,
   312  						Epoch: 0,
   313  						Votes: []hash.Hash{
   314  							hash.Zero,
   315  							hash.HexToHash("0x01"),
   316  						},
   317  					},
   318  				}
   319  				s.me.SetVersion(1)
   320  				s.me.SetBlockVotes(bv.Val)
   321  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
   322  				s.me.SetCreator(3)
   323  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   324  
   325  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   326  				s.Require().NoError(err)
   327  				sSig := native.Signature{}
   328  				copy(sSig[:], sig)
   329  				s.me.SetSig(sSig)
   330  				bv = native.AsSignedBlockVotes(s.me)
   331  			},
   332  		},
   333  		{
   334  			"epochcheck.ErrAuth",
   335  			epochcheck.ErrAuth,
   336  			func() {
   337  				bv = native.LlrSignedBlockVotes{
   338  					Val: native.LlrBlockVotes{
   339  						Start: 1,
   340  						Epoch: s.startEpoch,
   341  						Votes: []hash.Hash{
   342  							hash.Zero,
   343  							hash.HexToHash("0x01"),
   344  						},
   345  					},
   346  				}
   347  
   348  				invalidValidatorID := idx.ValidatorID(100)
   349  
   350  				s.me.SetVersion(1)
   351  				s.me.SetBlockVotes(bv.Val)
   352  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
   353  				s.me.SetCreator(invalidValidatorID)
   354  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   355  
   356  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   357  				s.Require().NoError(err)
   358  				sSig := native.Signature{}
   359  				copy(sSig[:], sig)
   360  				s.me.SetSig(sSig)
   361  				bv = native.AsSignedBlockVotes(s.me)
   362  			},
   363  		},
   364  		{
   365  			"ErrWrongPayloadHash",
   366  			heavycheck.ErrWrongPayloadHash,
   367  			func() {
   368  				bv = native.LlrSignedBlockVotes{
   369  					Val: native.LlrBlockVotes{
   370  						Start: 1,
   371  						Epoch: s.startEpoch,
   372  						Votes: []hash.Hash{
   373  							hash.Zero,
   374  							hash.HexToHash("0x01"),
   375  						},
   376  					},
   377  				}
   378  				emptyPayload := hash.Hash{}
   379  
   380  				s.me.SetVersion(1)
   381  				s.me.SetBlockVotes(bv.Val)
   382  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
   383  				s.me.SetCreator(3)
   384  				s.me.SetPayloadHash(emptyPayload)
   385  
   386  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   387  				s.Require().NoError(err)
   388  				sSig := native.Signature{}
   389  				copy(sSig[:], sig)
   390  				s.me.SetSig(sSig)
   391  				bv = native.AsSignedBlockVotes(s.me)
   392  			},
   393  		},
   394  		{
   395  			"ErrWrongEventSig",
   396  			heavycheck.ErrWrongEventSig,
   397  			func() {
   398  				bv = native.LlrSignedBlockVotes{
   399  					Val: native.LlrBlockVotes{
   400  						Start: 1,
   401  						Epoch: s.startEpoch,
   402  						Votes: []hash.Hash{
   403  							hash.Zero,
   404  							hash.HexToHash("0x01"),
   405  						},
   406  					},
   407  				}
   408  
   409  				s.me.SetVersion(1)
   410  				s.me.SetBlockVotes(bv.Val)
   411  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
   412  				s.me.SetCreator(4)
   413  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   414  
   415  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   416  				s.Require().NoError(err)
   417  				sSig := native.Signature{}
   418  				copy(sSig[:], sig)
   419  				s.me.SetSig(sSig)
   420  				bv = native.AsSignedBlockVotes(s.me)
   421  				bv.Signed.Locator.Creator = 5
   422  			},
   423  		},
   424  	}
   425  
   426  	for _, tc := range testCases {
   427  		tc := tc
   428  		s.Run(tc.name, func() {
   429  			s.SetupSuite()
   430  			tc.pretest()
   431  
   432  			err := s.env.checkers.Heavycheck.ValidateBVs(bv)
   433  
   434  			if tc.errExp != nil {
   435  				s.Require().Error(err)
   436  				s.Require().EqualError(err, tc.errExp.Error())
   437  			} else {
   438  				s.Require().NoError(err)
   439  			}
   440  		})
   441  	}
   442  }
   443  
   444  func mutableEventPayloadFromImmutable(e *native.EventPayload) *native.MutableEventPayload {
   445  	me := &native.MutableEventPayload{}
   446  	me.SetVersion(e.Version())
   447  	me.SetNetForkID(e.NetForkID())
   448  	me.SetCreator(e.Creator())
   449  	me.SetEpoch(e.Epoch())
   450  	me.SetCreationTime(e.CreationTime())
   451  	me.SetMedianTime(e.MedianTime())
   452  	me.SetPrevEpochHash(e.PrevEpochHash())
   453  	me.SetExtra(e.Extra())
   454  	me.SetGasPowerLeft(e.GasPowerLeft())
   455  	me.SetGasPowerUsed(e.GasPowerUsed())
   456  	me.SetPayloadHash(e.PayloadHash())
   457  	me.SetSig(e.Sig())
   458  	me.SetTxs(e.Txs())
   459  	me.SetMisbehaviourProofs(e.MisbehaviourProofs())
   460  	me.SetBlockVotes(e.BlockVotes())
   461  	me.SetEpochVote(e.EpochVote())
   462  	return me
   463  }
   464  
   465  func (s *LLRHeavyCheckTestSuite) TestHeavyCheckValidateEvent() {
   466  
   467  	testCases := []struct {
   468  		name    string
   469  		errExp  error
   470  		pretest func()
   471  	}{
   472  		{
   473  			"success",
   474  			nil,
   475  			func() {
   476  				s.me.SetVersion(1)
   477  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   478  				s.me.SetCreator(3)
   479  				s.me.SetSeq(idx.Event(1))
   480  				s.me.SetFrame(idx.Frame(1))
   481  				s.me.SetLamport(idx.Lamport(1))
   482  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   483  
   484  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   485  				s.Require().NoError(err)
   486  				sSig := native.Signature{}
   487  				copy(sSig[:], sig)
   488  				s.me.SetSig(sSig)
   489  			},
   490  		},
   491  		{
   492  			"epochcheck.ErrNotRelevant",
   493  			epochcheck.ErrNotRelevant,
   494  			func() {
   495  				s.me.SetVersion(1)
   496  				s.me.SetEpoch(idx.Epoch(s.startEpoch + 1))
   497  				s.me.SetCreator(3)
   498  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   499  
   500  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   501  				s.Require().NoError(err)
   502  				sSig := native.Signature{}
   503  				copy(sSig[:], sig)
   504  				s.me.SetSig(sSig)
   505  			},
   506  		},
   507  		{
   508  			"epochcheck.ErrAuth",
   509  			epochcheck.ErrAuth,
   510  			func() {
   511  				s.me.SetVersion(1)
   512  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   513  				s.me.SetSeq(idx.Event(1))
   514  				s.me.SetFrame(idx.Frame(1))
   515  				s.me.SetLamport(idx.Lamport(1))
   516  				invalidCreator := idx.ValidatorID(100)
   517  				s.me.SetCreator(invalidCreator)
   518  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   519  
   520  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   521  				s.Require().NoError(err)
   522  				sSig := native.Signature{}
   523  				copy(sSig[:], sig)
   524  				s.me.SetSig(sSig)
   525  			},
   526  		},
   527  		{
   528  			"ErrWrongEventSig",
   529  			heavycheck.ErrWrongEventSig,
   530  			func() {
   531  				s.me.SetVersion(1)
   532  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   533  				s.me.SetCreator(3)
   534  				s.me.SetSeq(idx.Event(1))
   535  				s.me.SetFrame(idx.Frame(1))
   536  				s.me.SetLamport(idx.Lamport(1))
   537  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   538  
   539  				sig, err := s.env.signer.Sign(s.env.pubkeys[1], s.me.HashToSign().Bytes())
   540  				s.Require().NoError(err)
   541  				sSig := native.Signature{}
   542  				copy(sSig[:], sig)
   543  				s.me.SetSig(sSig)
   544  			},
   545  		},
   546  		{
   547  			"ErrMalformedTxSig",
   548  			heavycheck.ErrMalformedTxSig,
   549  			func() {
   550  				s.me.SetVersion(1)
   551  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   552  				s.me.SetCreator(3)
   553  				s.me.SetSeq(idx.Event(1))
   554  				s.me.SetFrame(idx.Frame(1))
   555  				s.me.SetLamport(idx.Lamport(1))
   556  				h := hash.BytesToEvent(bytes.Repeat([]byte{math.MaxUint8}, 32))
   557  				tx1 := types.NewTx(&types.LegacyTx{
   558  					Nonce:    math.MaxUint64,
   559  					GasPrice: h.Big(),
   560  					Gas:      math.MaxUint64,
   561  					To:       nil,
   562  					Value:    h.Big(),
   563  					Data:     []byte{},
   564  				})
   565  				txs := types.Transactions{}
   566  				txs = append(txs, tx1)
   567  				s.me.SetTxs(txs)
   568  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   569  
   570  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   571  				s.Require().NoError(err)
   572  				sSig := native.Signature{}
   573  				copy(sSig[:], sig)
   574  				s.me.SetSig(sSig)
   575  			},
   576  		},
   577  		{
   578  			"ErrWrongPayloadHash",
   579  			heavycheck.ErrWrongPayloadHash,
   580  			func() {
   581  				s.me.SetVersion(1)
   582  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   583  				s.me.SetSeq(idx.Event(1))
   584  				s.me.SetFrame(idx.Frame(1))
   585  				s.me.SetLamport(idx.Lamport(1))
   586  				s.me.SetCreator(3)
   587  
   588  				invalidPayloadHash := hash.Hash{}
   589  				s.me.SetPayloadHash(invalidPayloadHash)
   590  
   591  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   592  				s.Require().NoError(err)
   593  				sSig := native.Signature{}
   594  				copy(sSig[:], sig)
   595  				s.me.SetSig(sSig)
   596  			},
   597  		},
   598  		{
   599  			"EpochVote().Epoch == 0",
   600  			nil,
   601  			func() {
   602  				ev := native.LlrSignedEpochVote{
   603  					Val: native.LlrEpochVote{
   604  						Epoch: 0,
   605  						Vote:  hash.HexToHash("0x01"),
   606  					},
   607  				}
   608  
   609  				s.me.SetEpochVote(ev.Val)
   610  				s.me.SetVersion(1)
   611  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   612  				s.me.SetSeq(idx.Event(1))
   613  				s.me.SetFrame(idx.Frame(1))
   614  				s.me.SetLamport(idx.Lamport(1))
   615  				s.me.SetCreator(3)
   616  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   617  
   618  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   619  				s.Require().NoError(err)
   620  				sSig := native.Signature{}
   621  				copy(sSig[:], sig)
   622  				s.me.SetSig(sSig)
   623  
   624  				ev = native.AsSignedEpochVote(s.me)
   625  			},
   626  		},
   627  		{
   628  			"EpochVote().Epoch != 0, matchPubkey returns heavycheck.ErrUnknownEpochEV",
   629  			heavycheck.ErrUnknownEpochEV,
   630  			func() {
   631  				ev := native.LlrSignedEpochVote{
   632  					Val: native.LlrEpochVote{
   633  						Epoch: s.startEpoch,
   634  						Vote:  hash.HexToHash("0x01"),
   635  					},
   636  				}
   637  
   638  				s.me.SetEpochVote(ev.Val)
   639  				s.me.SetVersion(1)
   640  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   641  				s.me.SetSeq(idx.Event(1))
   642  				s.me.SetFrame(idx.Frame(1))
   643  				s.me.SetLamport(idx.Lamport(1))
   644  				s.me.SetCreator(3)
   645  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   646  
   647  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   648  				s.Require().NoError(err)
   649  				sSig := native.Signature{}
   650  				copy(sSig[:], sig)
   651  				s.me.SetSig(sSig)
   652  
   653  				ev = native.AsSignedEpochVote(s.me)
   654  			},
   655  		},
   656  		{
   657  			"EpochVote().Epoch != 0, matchPubkey returns epochcheck.ErrAuth",
   658  			epochcheck.ErrAuth,
   659  			func() {
   660  				ev := native.LlrSignedEpochVote{
   661  					Val: native.LlrEpochVote{
   662  						Epoch: s.startEpoch + 1,
   663  						Vote:  hash.HexToHash("0x01"),
   664  					},
   665  				}
   666  
   667  				s.me.SetEpochVote(ev.Val)
   668  				s.me.SetVersion(1)
   669  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   670  				s.me.SetSeq(idx.Event(1))
   671  				s.me.SetFrame(idx.Frame(1))
   672  				s.me.SetLamport(idx.Lamport(1))
   673  				invalidCreator := idx.ValidatorID(100)
   674  				s.me.SetCreator(invalidCreator)
   675  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   676  
   677  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   678  				s.Require().NoError(err)
   679  				sSig := native.Signature{}
   680  				copy(sSig[:], sig)
   681  				s.me.SetSig(sSig)
   682  
   683  				ev = native.AsSignedEpochVote(s.me)
   684  			},
   685  		},
   686  		{
   687  			"EpochVote().Epoch != 0, matchPubkey returns nil",
   688  			nil,
   689  			func() {
   690  				ev := native.LlrSignedEpochVote{
   691  					Val: native.LlrEpochVote{
   692  						Epoch: s.startEpoch + 1,
   693  						Vote:  hash.HexToHash("0x01"),
   694  					},
   695  				}
   696  
   697  				s.me.SetEpochVote(ev.Val)
   698  				s.me.SetVersion(1)
   699  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   700  				s.me.SetSeq(idx.Event(1))
   701  				s.me.SetFrame(idx.Frame(1))
   702  				s.me.SetLamport(idx.Lamport(1))
   703  				s.me.SetCreator(3)
   704  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   705  
   706  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   707  				s.Require().NoError(err)
   708  				sSig := native.Signature{}
   709  				copy(sSig[:], sig)
   710  				s.me.SetSig(sSig)
   711  
   712  				ev = native.AsSignedEpochVote(s.me)
   713  			},
   714  		},
   715  		{
   716  			"BlockVote().Epoch == 0",
   717  			nil,
   718  			func() {
   719  				bv := native.LlrSignedBlockVotes{
   720  					Val: native.LlrBlockVotes{
   721  						Start: 1,
   722  						Epoch: 0,
   723  						Votes: []hash.Hash{
   724  							hash.Zero,
   725  							hash.HexToHash("0x01"),
   726  						},
   727  					},
   728  				}
   729  
   730  				s.me.SetBlockVotes(bv.Val)
   731  				s.me.SetVersion(1)
   732  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   733  				s.me.SetSeq(idx.Event(1))
   734  				s.me.SetFrame(idx.Frame(1))
   735  				s.me.SetLamport(idx.Lamport(1))
   736  				s.me.SetCreator(3)
   737  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   738  
   739  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   740  				s.Require().NoError(err)
   741  				sSig := native.Signature{}
   742  				copy(sSig[:], sig)
   743  				s.me.SetSig(sSig)
   744  			},
   745  		},
   746  		{
   747  			"BlockVote().Epoch != 0, validateBVsEpoch returns nil",
   748  			nil,
   749  			func() {
   750  				bv := native.LlrSignedBlockVotes{
   751  					Val: native.LlrBlockVotes{
   752  						Start: 1,
   753  						Epoch: s.startEpoch,
   754  						Votes: []hash.Hash{
   755  							hash.Zero,
   756  							hash.HexToHash("0x01"),
   757  						},
   758  					},
   759  				}
   760  
   761  				s.me.SetBlockVotes(bv.Val)
   762  				s.me.SetVersion(1)
   763  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   764  				s.me.SetSeq(idx.Event(1))
   765  				s.me.SetFrame(idx.Frame(1))
   766  				s.me.SetLamport(idx.Lamport(1))
   767  				s.me.SetCreator(3)
   768  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   769  
   770  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   771  				s.Require().NoError(err)
   772  				sSig := native.Signature{}
   773  				copy(sSig[:], sig)
   774  				s.me.SetSig(sSig)
   775  			},
   776  		},
   777  		{
   778  			"blockvote epoch is 0, block vote epoch does not match event epoch,matchPubkey returns nil",
   779  			nil,
   780  			func() {
   781  				bv := native.LlrSignedBlockVotes{
   782  					Val: native.LlrBlockVotes{
   783  						Start: 1,
   784  						Epoch: s.startEpoch,
   785  						Votes: []hash.Hash{
   786  							hash.Zero,
   787  							hash.HexToHash("0x01"),
   788  						},
   789  					},
   790  				}
   791  
   792  				s.me.SetBlockVotes(bv.Val)
   793  				s.me.SetVersion(1)
   794  				s.me.SetEpoch(idx.Epoch(s.startEpoch))
   795  				s.me.SetSeq(idx.Event(1))
   796  				s.me.SetFrame(idx.Frame(1))
   797  				s.me.SetLamport(idx.Lamport(1))
   798  				s.me.SetCreator(3)
   799  				s.me.SetPayloadHash(native.CalcPayloadHash(s.me))
   800  
   801  				sig, err := s.env.signer.Sign(s.env.pubkeys[2], s.me.HashToSign().Bytes())
   802  				s.Require().NoError(err)
   803  				sSig := native.Signature{}
   804  				copy(sSig[:], sig)
   805  				s.me.SetSig(sSig)
   806  				bv = native.AsSignedBlockVotes(s.me)
   807  			},
   808  		},
   809  	}
   810  
   811  	for _, tc := range testCases {
   812  		tc := tc
   813  		s.Run(tc.name, func() {
   814  			s.SetupSuite()
   815  			tc.pretest()
   816  
   817  			err := s.env.checkers.Heavycheck.ValidateEvent(s.me)
   818  
   819  			if tc.errExp != nil {
   820  				s.Require().Error(err)
   821  				s.Require().EqualError(err, tc.errExp.Error())
   822  			} else {
   823  				s.Require().NoError(err)
   824  			}
   825  		})
   826  	}
   827  }
   828  
   829  func TestLLRHeavyCheckTestSuite(t *testing.T) {
   830  	t.Skip() // skip until fixed
   831  	suite.Run(t, new(LLRHeavyCheckTestSuite))
   832  }