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

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