github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/evm/proposal_handler_test.go (about)

     1  package evm_test
     2  
     3  import (
     4  	ethcmn "github.com/ethereum/go-ethereum/common"
     5  	ttypes "github.com/fibonacci-chain/fbc/libs/tendermint/types"
     6  	"github.com/fibonacci-chain/fbc/x/evm"
     7  	"github.com/fibonacci-chain/fbc/x/evm/types"
     8  	govtypes "github.com/fibonacci-chain/fbc/x/gov/types"
     9  )
    10  
    11  func (suite *EvmTestSuite) TestProposalHandler_ManageContractDeploymentWhitelistProposal() {
    12  	addr1 := ethcmn.BytesToAddress([]byte{0x0}).Bytes()
    13  	addr2 := ethcmn.BytesToAddress([]byte{0x1}).Bytes()
    14  
    15  	proposal := types.NewManageContractDeploymentWhitelistProposal(
    16  		"default title",
    17  		"default description",
    18  		types.AddressList{addr1, addr2},
    19  		true,
    20  	)
    21  
    22  	suite.govHandler = evm.NewManageContractDeploymentWhitelistProposalHandler(suite.app.EvmKeeper)
    23  	govProposal := govtypes.Proposal{
    24  		Content: proposal,
    25  	}
    26  
    27  	testCases := []struct {
    28  		msg                   string
    29  		prepare               func()
    30  		targetAddrListToCheck types.AddressList
    31  	}{
    32  		{
    33  			"add address into whitelist",
    34  			func() {},
    35  			types.AddressList{addr1, addr2},
    36  		},
    37  		{
    38  			"add address repeatedly",
    39  			func() {},
    40  			types.AddressList{addr1, addr2},
    41  		},
    42  		{
    43  			"delete an address from whitelist",
    44  			func() {
    45  				proposal.IsAdded = false
    46  				proposal.DistributorAddrs = types.AddressList{addr1}
    47  				govProposal.Content = proposal
    48  			},
    49  			types.AddressList{addr2},
    50  		},
    51  		{
    52  			"delete an address from whitelist",
    53  			func() {
    54  				proposal.IsAdded = false
    55  				proposal.DistributorAddrs = types.AddressList{addr1}
    56  				govProposal.Content = proposal
    57  			},
    58  			types.AddressList{addr2},
    59  		},
    60  		{
    61  			"delete two addresses from whitelist which contains one of them only",
    62  			func() {
    63  				proposal.DistributorAddrs = types.AddressList{addr1, addr2}
    64  				govProposal.Content = proposal
    65  			},
    66  			types.AddressList{},
    67  		},
    68  		{
    69  			"delete two addresses from whitelist which contains none of them",
    70  			func() {},
    71  			types.AddressList{},
    72  		},
    73  	}
    74  
    75  	for _, tc := range testCases {
    76  		suite.Run(tc.msg, func() {
    77  			tc.prepare()
    78  
    79  			err := suite.govHandler(suite.ctx, &govProposal)
    80  			suite.Require().NoError(err)
    81  
    82  			// check the whitelist with target address list
    83  			curWhitelist := suite.stateDB.GetContractDeploymentWhitelist()
    84  			suite.Require().Equal(len(tc.targetAddrListToCheck), len(curWhitelist))
    85  
    86  			for i, addr := range curWhitelist {
    87  				suite.Require().Equal(tc.targetAddrListToCheck[i], addr)
    88  			}
    89  		})
    90  	}
    91  }
    92  
    93  func (suite *EvmTestSuite) TestProposalHandler_ManageContractBlockedListProposal() {
    94  	addr1 := ethcmn.BytesToAddress([]byte{0x0}).Bytes()
    95  	addr2 := ethcmn.BytesToAddress([]byte{0x1}).Bytes()
    96  
    97  	proposal := types.NewManageContractBlockedListProposal(
    98  		"default title",
    99  		"default description",
   100  		types.AddressList{addr1, addr2},
   101  		true,
   102  	)
   103  
   104  	suite.govHandler = evm.NewManageContractDeploymentWhitelistProposalHandler(suite.app.EvmKeeper)
   105  	govProposal := govtypes.Proposal{
   106  		Content: proposal,
   107  	}
   108  
   109  	testCases := []struct {
   110  		msg                   string
   111  		prepare               func()
   112  		targetAddrListToCheck types.AddressList
   113  	}{
   114  		{
   115  			"add address into blocked list",
   116  			func() {},
   117  			types.AddressList{addr1, addr2},
   118  		},
   119  		{
   120  			"add address repeatedly",
   121  			func() {},
   122  			types.AddressList{addr1, addr2},
   123  		},
   124  		{
   125  			"delete an address from blocked list",
   126  			func() {
   127  				proposal.IsAdded = false
   128  				proposal.ContractAddrs = types.AddressList{addr1}
   129  				govProposal.Content = proposal
   130  			},
   131  			types.AddressList{addr2},
   132  		},
   133  		{
   134  			"delete an address from blocked list",
   135  			func() {
   136  				proposal.IsAdded = false
   137  				proposal.ContractAddrs = types.AddressList{addr1}
   138  				govProposal.Content = proposal
   139  			},
   140  			types.AddressList{addr2},
   141  		},
   142  		{
   143  			"delete two addresses from blocked list which contains one of them only",
   144  			func() {
   145  				proposal.ContractAddrs = types.AddressList{addr1, addr2}
   146  				govProposal.Content = proposal
   147  			},
   148  			types.AddressList{},
   149  		},
   150  		{
   151  			"delete two addresses from blocked list which contains none of them",
   152  			func() {},
   153  			types.AddressList{},
   154  		},
   155  	}
   156  
   157  	for _, tc := range testCases {
   158  		suite.Run(tc.msg, func() {
   159  			tc.prepare()
   160  
   161  			err := suite.govHandler(suite.ctx, &govProposal)
   162  			suite.Require().NoError(err)
   163  
   164  			// check the blocked list with target address list
   165  			curBlockedList := suite.stateDB.GetContractBlockedList()
   166  			suite.Require().Equal(len(tc.targetAddrListToCheck), len(curBlockedList))
   167  
   168  			for i, addr := range curBlockedList {
   169  				suite.Require().Equal(tc.targetAddrListToCheck[i], addr)
   170  			}
   171  		})
   172  	}
   173  }
   174  
   175  func (suite *EvmTestSuite) TestProposalHandler_ManageContractMethodBlockedListProposal() {
   176  	addr1 := ethcmn.BytesToAddress([]byte{0x0}).Bytes()
   177  	addr2 := ethcmn.BytesToAddress([]byte{0x1}).Bytes()
   178  	bcMethodOne1 := types.BlockedContract{
   179  		Address: addr1,
   180  		BlockMethods: types.ContractMethods{
   181  			types.ContractMethod{
   182  				Sign:  "aaaa",
   183  				Extra: "aaaa()",
   184  			},
   185  		},
   186  	}
   187  	bcMethodTwo1 := types.BlockedContract{
   188  		Address: addr2,
   189  		BlockMethods: types.ContractMethods{
   190  			types.ContractMethod{
   191  				Sign:  "bbbb",
   192  				Extra: "bbbb()",
   193  			},
   194  		},
   195  	}
   196  
   197  	bcMethodOne2 := types.BlockedContract{
   198  		Address: addr1,
   199  		BlockMethods: types.ContractMethods{
   200  			types.ContractMethod{
   201  				Sign:  "bbbb",
   202  				Extra: "bbbb()",
   203  			},
   204  		},
   205  	}
   206  	expectBcMethodOne2 := types.NewBlockContract(addr1, bcMethodOne1.BlockMethods)
   207  	expectBcMethodOne2.BlockMethods = append(expectBcMethodOne2.BlockMethods, bcMethodOne2.BlockMethods...)
   208  
   209  	proposal := types.NewManageContractMethodBlockedListProposal(
   210  		"default title",
   211  		"default description",
   212  		types.BlockedContractList{bcMethodOne1, bcMethodTwo1},
   213  		true,
   214  	)
   215  
   216  	suite.govHandler = evm.NewManageContractDeploymentWhitelistProposalHandler(suite.app.EvmKeeper)
   217  	govProposal := govtypes.Proposal{
   218  		Content: proposal,
   219  	}
   220  
   221  	testCases := []struct {
   222  		msg                   string
   223  		prepare               func()
   224  		targetAddrListToCheck types.BlockedContractList
   225  		success               bool
   226  	}{
   227  		{
   228  			"add address into blocked list",
   229  			func() {},
   230  			types.BlockedContractList{bcMethodOne1, bcMethodTwo1},
   231  			true,
   232  		},
   233  		{
   234  			"add address repeatedly",
   235  			func() {},
   236  			types.BlockedContractList{bcMethodOne1, bcMethodTwo1},
   237  			true,
   238  		},
   239  		{
   240  			"add method into contract method blocked list",
   241  			func() {
   242  				//reset data
   243  				suite.stateDB.DeleteContractBlockedList(types.AddressList{addr1, addr2})
   244  				suite.stateDB.InsertContractMethodBlockedList(types.BlockedContractList{bcMethodOne1})
   245  				proposal.ContractList = types.BlockedContractList{bcMethodOne2, bcMethodTwo1}
   246  				govProposal.Content = proposal
   247  			},
   248  			types.BlockedContractList{*expectBcMethodOne2, bcMethodTwo1},
   249  			true,
   250  		},
   251  		{
   252  			"add method into contract method which has same addr int blocked list",
   253  			func() {
   254  				//reset data
   255  				suite.stateDB.DeleteContractBlockedList(types.AddressList{addr1, addr2})
   256  				suite.stateDB.SetContractBlockedList(types.AddressList{addr1})
   257  				proposal.ContractList = types.BlockedContractList{bcMethodOne1, bcMethodTwo1}
   258  				govProposal.Content = proposal
   259  			},
   260  			types.BlockedContractList{bcMethodOne1, bcMethodTwo1},
   261  			true,
   262  		},
   263  		{
   264  			"delete all method from blocked list",
   265  			func() {
   266  				proposal.IsAdded = false
   267  				proposal.ContractList = types.BlockedContractList{bcMethodOne1}
   268  				govProposal.Content = proposal
   269  			},
   270  			types.BlockedContractList{bcMethodTwo1},
   271  			true,
   272  		},
   273  		{
   274  			"delete a method from blocked list",
   275  			func() {
   276  				//reset data
   277  				suite.stateDB.DeleteContractBlockedList(types.AddressList{addr1, addr2})
   278  				suite.stateDB.InsertContractMethodBlockedList(types.BlockedContractList{*expectBcMethodOne2, bcMethodTwo1})
   279  				proposal.IsAdded = false
   280  				proposal.ContractList = types.BlockedContractList{bcMethodOne1, bcMethodTwo1}
   281  				govProposal.Content = proposal
   282  			},
   283  			types.BlockedContractList{bcMethodOne2},
   284  			true,
   285  		},
   286  		{
   287  			"delete a method from blocked list which is contract all method blocked",
   288  			func() {
   289  				//reset data
   290  				suite.stateDB.DeleteContractBlockedList(types.AddressList{addr1, addr2})
   291  				suite.stateDB.SetContractBlockedList(types.AddressList{addr1})
   292  				proposal.IsAdded = false
   293  				proposal.ContractList = types.BlockedContractList{bcMethodOne1, bcMethodTwo1}
   294  				govProposal.Content = proposal
   295  			},
   296  			types.BlockedContractList{types.BlockedContract{Address: addr1}},
   297  			false,
   298  		},
   299  		{
   300  			"delete two addresses from blocked list which contains one of them only",
   301  			func() {
   302  				//reset data
   303  				suite.stateDB.DeleteContractBlockedList(types.AddressList{addr1, addr2})
   304  				suite.stateDB.InsertContractMethodBlockedList(types.BlockedContractList{bcMethodTwo1})
   305  
   306  				proposal.IsAdded = false
   307  				proposal.ContractList = types.BlockedContractList{bcMethodOne1, bcMethodTwo1}
   308  				govProposal.Content = proposal
   309  			},
   310  			types.BlockedContractList{bcMethodTwo1},
   311  			false,
   312  		},
   313  		{
   314  			"delete two addresses from blocked list which contains none of them",
   315  			func() {
   316  				//reset data
   317  				suite.stateDB.DeleteContractBlockedList(types.AddressList{addr1, addr2})
   318  				proposal.IsAdded = false
   319  				proposal.ContractList = types.BlockedContractList{bcMethodOne1, bcMethodTwo1}
   320  				govProposal.Content = proposal
   321  			},
   322  			types.BlockedContractList{},
   323  			false,
   324  		},
   325  	}
   326  
   327  	for _, tc := range testCases {
   328  		suite.Run(tc.msg, func() {
   329  			tc.prepare()
   330  
   331  			err := suite.govHandler(suite.ctx, &govProposal)
   332  			if tc.success {
   333  				suite.Require().NoError(err)
   334  			} else {
   335  				suite.Require().Error(err)
   336  			}
   337  
   338  			// check the blocked list with target address list
   339  			curBlockedList := suite.stateDB.GetContractMethodBlockedList()
   340  			suite.Require().Equal(len(tc.targetAddrListToCheck), len(curBlockedList))
   341  			ok := types.BlockedContractListIsEqual(suite.T(), curBlockedList, tc.targetAddrListToCheck)
   342  			suite.Require().True(ok)
   343  		})
   344  	}
   345  }
   346  
   347  func (suite *EvmTestSuite) TestProposalHandler_ManageSysContractAddressProposal() {
   348  	addr1 := ethcmn.BytesToAddress([]byte{0x3}).Bytes()
   349  	addr2 := ethcmn.BytesToAddress([]byte{0x4}).Bytes()
   350  
   351  	suite.govHandler = evm.NewManageContractDeploymentWhitelistProposalHandler(suite.app.EvmKeeper)
   352  
   353  	govProposal := &govtypes.Proposal{}
   354  
   355  	ttypes.UnittestOnlySetMilestoneVenus3Height(-1)
   356  
   357  	testCases := []struct {
   358  		msg     string
   359  		prepare func()
   360  		fnCheck func()
   361  		success bool
   362  	}{
   363  		{
   364  			msg: "add a sys contract address addr1",
   365  			prepare: func() {
   366  				proposal := types.NewManageSysContractAddressProposal(
   367  					"default title",
   368  					"default description",
   369  					addr1,
   370  					true,
   371  				)
   372  				govProposal.Content = proposal
   373  			},
   374  			fnCheck: func() {
   375  				reAddr, err := suite.app.EvmKeeper.GetSysContractAddress(suite.ctx)
   376  				suite.Require().NoError(err)
   377  				suite.Require().Equal(addr1, reAddr[:])
   378  			},
   379  			success: true,
   380  		},
   381  		{
   382  			msg: "add a sys contract address addr2",
   383  			prepare: func() {
   384  				proposal := types.NewManageSysContractAddressProposal(
   385  					"default title",
   386  					"default description",
   387  					addr2,
   388  					true,
   389  				)
   390  				govProposal.Content = proposal
   391  			},
   392  			fnCheck: func() {
   393  				reAddr, err := suite.app.EvmKeeper.GetSysContractAddress(suite.ctx)
   394  				suite.Require().NoError(err)
   395  				suite.Require().Equal(addr2, reAddr[:])
   396  			},
   397  			success: true,
   398  		},
   399  		{
   400  			msg: "del a sys contract address",
   401  			prepare: func() {
   402  				proposal := types.NewManageSysContractAddressProposal(
   403  					"default title",
   404  					"default description",
   405  					addr2,
   406  					false,
   407  				)
   408  				govProposal.Content = proposal
   409  			},
   410  			fnCheck: func() {
   411  				reAddr, err := suite.app.EvmKeeper.GetSysContractAddress(suite.ctx)
   412  				suite.Require().Error(err)
   413  				suite.Require().Nil(reAddr)
   414  			},
   415  			success: true,
   416  		},
   417  	}
   418  
   419  	for _, tc := range testCases {
   420  		suite.Run(tc.msg, func() {
   421  			tc.prepare()
   422  
   423  			err := suite.govHandler(suite.ctx, govProposal)
   424  			if tc.success {
   425  				suite.Require().NoError(err)
   426  			} else {
   427  				suite.Require().Error(err)
   428  			}
   429  		})
   430  	}
   431  }