github.com/ChainSafe/chainbridge-core@v1.4.2/chains/evm/calls/contracts/bridge/bridge_test.go (about)

     1  package bridge_test
     2  
     3  import (
     4  	"encoding/hex"
     5  	"errors"
     6  	"math/big"
     7  	"testing"
     8  
     9  	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/contracts/bridge"
    10  	mock_calls "github.com/ChainSafe/chainbridge-core/chains/evm/calls/mock"
    11  	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/transactor"
    12  
    13  	mock_transactor "github.com/ChainSafe/chainbridge-core/chains/evm/calls/transactor/mock"
    14  	"github.com/ChainSafe/chainbridge-core/chains/evm/executor/proposal"
    15  	"github.com/ChainSafe/chainbridge-core/relayer/message"
    16  	"github.com/ethereum/go-ethereum/common"
    17  	"github.com/golang/mock/gomock"
    18  	"github.com/stretchr/testify/suite"
    19  )
    20  
    21  type ProposalStatusTestSuite struct {
    22  	suite.Suite
    23  	mockContractCaller *mock_calls.MockContractCallerDispatcher
    24  	mockTransactor     *mock_transactor.MockTransactor
    25  	bridgeAddress      common.Address
    26  	bridgeContract     *bridge.BridgeContract
    27  	proposal           proposal.Proposal
    28  }
    29  
    30  var (
    31  	testContractAddress   = "0x5f75ce92326e304962b22749bd71e36976171285"
    32  	testInteractorAddress = "0x1B33100D4f077f027042c01241D617b264d77931"
    33  	testRelayerAddress    = "0x0E223343BE5E126d7Cd1F6228F8F86fA04aD80fe"
    34  	testHandlerAddress    = "0xb157b07c616860546464b733a056be414167a09b"
    35  	testResourceId        = [32]byte{66}
    36  	testDomainId          = uint8(0)
    37  	metadata              = message.Metadata{}
    38  )
    39  
    40  func TestRunProposalStatusTestSuite(t *testing.T) {
    41  	suite.Run(t, new(ProposalStatusTestSuite))
    42  }
    43  
    44  func (s *ProposalStatusTestSuite) SetupSuite()    {}
    45  func (s *ProposalStatusTestSuite) TearDownSuite() {}
    46  func (s *ProposalStatusTestSuite) SetupTest() {
    47  	gomockController := gomock.NewController(s.T())
    48  	s.mockContractCaller = mock_calls.NewMockContractCallerDispatcher(gomockController)
    49  	s.mockTransactor = mock_transactor.NewMockTransactor(gomockController)
    50  	s.bridgeAddress = common.HexToAddress("0x3162226db165D8eA0f51720CA2bbf44Db2105ADF")
    51  	s.bridgeContract = bridge.NewBridgeContract(s.mockContractCaller, common.HexToAddress(testContractAddress), s.mockTransactor)
    52  
    53  	s.proposal = *proposal.NewProposal(
    54  		uint8(1),
    55  		uint8(2),
    56  		uint64(1),
    57  		testResourceId,
    58  		[]byte{},
    59  		common.HexToAddress(testHandlerAddress),
    60  		common.HexToAddress(testContractAddress),
    61  		metadata,
    62  	)
    63  }
    64  func (s *ProposalStatusTestSuite) TearDownTest() {}
    65  
    66  func (s *ProposalStatusTestSuite) TestProposalContractCall_StatusFailed() {
    67  	s.mockContractCaller.EXPECT().CallContract(gomock.Any(), gomock.Any(), nil).Return(nil, errors.New("error"))
    68  	s.mockContractCaller.EXPECT().From().Times(1).Return(common.Address{})
    69  	bc := bridge.NewBridgeContract(s.mockContractCaller, common.Address{}, s.mockTransactor)
    70  	status, err := bc.ProposalStatus(&proposal.Proposal{})
    71  	s.Equal(message.ProposalStatus{}, status)
    72  	s.NotNil(err)
    73  }
    74  
    75  func (s *ProposalStatusTestSuite) TestProposalStatus_FailedUnpack() {
    76  	s.mockContractCaller.EXPECT().CallContract(gomock.Any(), gomock.Any(), nil).Return([]byte("invalid"), nil)
    77  	s.mockContractCaller.EXPECT().From().Times(1).Return(common.Address{})
    78  	bc := bridge.NewBridgeContract(s.mockContractCaller, common.Address{}, s.mockTransactor)
    79  	status, err := bc.ProposalStatus(&proposal.Proposal{})
    80  
    81  	s.Equal(message.ProposalStatus{}, status)
    82  	s.NotNil(err)
    83  }
    84  
    85  func (s *ProposalStatusTestSuite) TestProposalStatus_SuccessfulCall() {
    86  	proposalStatus, _ := hex.DecodeString("0000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000001f")
    87  	s.mockContractCaller.EXPECT().CallContract(gomock.Any(), gomock.Any(), nil).Return(proposalStatus, nil)
    88  	s.mockContractCaller.EXPECT().From().Times(1).Return(common.Address{})
    89  	bc := bridge.NewBridgeContract(s.mockContractCaller, common.Address{}, s.mockTransactor)
    90  	status, err := bc.ProposalStatus(&proposal.Proposal{})
    91  
    92  	s.Nil(err)
    93  	s.Equal(status.YesVotesTotal, uint8(3))
    94  	s.Equal(status.Status, message.ProposalStatusExecuted)
    95  }
    96  
    97  func (s *ProposalStatusTestSuite) TestPrepare_WithdrawInput_Success() {
    98  	handlerAddress := common.HexToAddress("0x3167776db165D8eA0f51790CA2bbf44Db5105ADF")
    99  	tokenAddress := common.HexToAddress("0x3f709398808af36ADBA86ACC617FeB7F5B7B193E")
   100  	recipientAddress := common.HexToAddress("0x8e5F72B158BEDf0ab50EDa78c70dFC118158C272")
   101  	amountOrTokenId := big.NewInt(1)
   102  
   103  	s.mockTransactor.EXPECT().Transact(&s.bridgeAddress, gomock.Any(), gomock.Any()).Times(1).Return(
   104  		&common.Hash{}, nil,
   105  	)
   106  
   107  	bc := bridge.NewBridgeContract(s.mockContractCaller, s.bridgeAddress, s.mockTransactor)
   108  	inputBytes, err := bc.Withdraw(
   109  		handlerAddress, tokenAddress, recipientAddress, amountOrTokenId, transactor.TransactOptions{},
   110  	)
   111  	s.NotNil(inputBytes)
   112  	s.Nil(err)
   113  }
   114  
   115  func (s *ProposalStatusTestSuite) TestDeployContract_Success() {
   116  	bc := bridge.NewBridgeContract(s.mockContractCaller, s.bridgeAddress, s.mockTransactor)
   117  	a := common.HexToAddress("0x12847465a15b58D4351AfB47F0CBbeebE93B06e3")
   118  	address, err := bc.PackMethod("",
   119  		uint8(1),
   120  		[]common.Address{a},
   121  		big.NewInt(0).SetUint64(1),
   122  		big.NewInt(0).SetUint64(1),
   123  		big.NewInt(0),
   124  	)
   125  	s.Nil(err)
   126  	s.NotNil(address)
   127  }
   128  
   129  func (s *ProposalStatusTestSuite) TestBridge_AddRelayer_Success() {
   130  	s.mockTransactor.EXPECT().Transact(
   131  		gomock.Any(),
   132  		gomock.Any(),
   133  		gomock.Any(),
   134  	).Return(&common.Hash{1, 2, 3, 4, 5}, nil)
   135  	res, err := s.bridgeContract.AddRelayer(common.HexToAddress(testRelayerAddress), transactor.DefaultTransactionOptions)
   136  	s.Equal(
   137  		&common.Hash{1, 2, 3, 4, 5},
   138  		res,
   139  	)
   140  	s.Nil(err)
   141  }
   142  
   143  func (s *ProposalStatusTestSuite) TestBridge_AdminSetGenericResource_Success() {
   144  	s.mockTransactor.EXPECT().Transact(
   145  		gomock.Any(),
   146  		gomock.Any(),
   147  		gomock.Any(),
   148  	).Return(&common.Hash{10, 11, 12, 13, 14}, nil)
   149  	res, err := s.bridgeContract.AdminSetGenericResource(common.HexToAddress(testHandlerAddress), [32]byte{1}, common.HexToAddress(testInteractorAddress), [4]byte{2}, big.NewInt(0), [4]byte{3}, transactor.DefaultTransactionOptions)
   150  	s.Equal(
   151  		&common.Hash{10, 11, 12, 13, 14},
   152  		res,
   153  	)
   154  	s.Nil(err)
   155  }
   156  
   157  func (s *ProposalStatusTestSuite) TestBridge_AdminSetResource_Success() {
   158  	s.mockTransactor.EXPECT().Transact(
   159  		gomock.Any(),
   160  		gomock.Any(),
   161  		gomock.Any(),
   162  	).Return(&common.Hash{10, 11, 12, 13, 14, 15, 16}, nil)
   163  	res, err := s.bridgeContract.AdminSetResource(common.HexToAddress(testHandlerAddress), testResourceId, common.HexToAddress(testContractAddress), transactor.DefaultTransactionOptions)
   164  	s.Equal(
   165  		&common.Hash{10, 11, 12, 13, 14, 15, 16},
   166  		res,
   167  	)
   168  	s.Nil(err)
   169  }
   170  
   171  func (s *ProposalStatusTestSuite) TestBridge_SetDepositNonce_Success() {
   172  	s.mockTransactor.EXPECT().Transact(
   173  		gomock.Any(),
   174  		gomock.Any(),
   175  		gomock.Any(),
   176  	).Return(&common.Hash{20, 21, 22, 23}, nil)
   177  	res, err := s.bridgeContract.SetDepositNonce(testDomainId, uint64(0), transactor.DefaultTransactionOptions)
   178  	s.Equal(
   179  		&common.Hash{20, 21, 22, 23},
   180  		res,
   181  	)
   182  	s.Nil(err)
   183  }
   184  
   185  func (s *ProposalStatusTestSuite) TestBridge_SetThresholdInput_Success() {
   186  	s.mockTransactor.EXPECT().Transact(
   187  		gomock.Any(),
   188  		gomock.Any(),
   189  		gomock.Any(),
   190  	).Return(&common.Hash{22, 23, 24, 25}, nil)
   191  	res, err := s.bridgeContract.AdminChangeRelayerThreshold(uint64(2), transactor.DefaultTransactionOptions)
   192  	s.Equal(
   193  		&common.Hash{22, 23, 24, 25},
   194  		res,
   195  	)
   196  	s.Nil(err)
   197  }
   198  
   199  func (s *ProposalStatusTestSuite) TestBridge_SetBurnableInput_Success() {
   200  	s.mockTransactor.EXPECT().Transact(
   201  		gomock.Any(),
   202  		gomock.Any(),
   203  		gomock.Any(),
   204  	).Return(&common.Hash{25, 26, 27, 28}, nil)
   205  	res, err := s.bridgeContract.SetBurnableInput(common.HexToAddress(testHandlerAddress), common.HexToAddress(testContractAddress), transactor.DefaultTransactionOptions)
   206  	s.Equal(
   207  		&common.Hash{25, 26, 27, 28},
   208  		res,
   209  	)
   210  	s.Nil(err)
   211  }
   212  
   213  func (s *ProposalStatusTestSuite) TestBridge_Erc20Deposit_Success() {
   214  	s.mockTransactor.EXPECT().Transact(
   215  		gomock.Any(),
   216  		gomock.Any(),
   217  		gomock.Any(),
   218  	).Return(&common.Hash{30, 31, 32, 33}, nil)
   219  	res, err := s.bridgeContract.Erc20Deposit(common.HexToAddress(testInteractorAddress), big.NewInt(10), testResourceId, testDomainId, transactor.DefaultTransactionOptions)
   220  	s.Equal(
   221  		&common.Hash{30, 31, 32, 33},
   222  		res,
   223  	)
   224  	s.Nil(err)
   225  }
   226  
   227  func (s *ProposalStatusTestSuite) TestBridge_Erc721Deposit_Success() {
   228  	s.mockTransactor.EXPECT().Transact(
   229  		gomock.Any(),
   230  		gomock.Any(),
   231  		gomock.Any(),
   232  	).Return(&common.Hash{32, 33, 34, 35}, nil)
   233  	res, err := s.bridgeContract.Erc721Deposit(big.NewInt(55), "token_uri", common.HexToAddress(testInteractorAddress), testResourceId, testDomainId, transactor.DefaultTransactionOptions)
   234  	s.Equal(
   235  		&common.Hash{32, 33, 34, 35},
   236  		res,
   237  	)
   238  	s.Nil(err)
   239  }
   240  
   241  func (s *ProposalStatusTestSuite) TestBridge_GenericDeposit_Success() {
   242  	s.mockTransactor.EXPECT().Transact(
   243  		gomock.Any(),
   244  		gomock.Any(),
   245  		gomock.Any(),
   246  	).Return(&common.Hash{35, 36, 37, 38}, nil)
   247  	res, err := s.bridgeContract.GenericDeposit([]byte{1, 2, 3}, testResourceId, testDomainId, transactor.DefaultTransactionOptions)
   248  	s.Equal(
   249  		&common.Hash{35, 36, 37, 38},
   250  		res,
   251  	)
   252  	s.Nil(err)
   253  }
   254  
   255  func (s *ProposalStatusTestSuite) TestBridge_ExecuteProposal_Success() {
   256  	s.mockTransactor.EXPECT().Transact(
   257  		gomock.Any(),
   258  		gomock.Any(),
   259  		gomock.Any(),
   260  	).Return(&common.Hash{36, 37, 38}, nil)
   261  	res, err := s.bridgeContract.ExecuteProposal(&s.proposal, transactor.DefaultTransactionOptions)
   262  	s.Equal(
   263  		&common.Hash{36, 37, 38},
   264  		res,
   265  	)
   266  	s.Nil(err)
   267  }
   268  
   269  func (s *ProposalStatusTestSuite) TestBridge_VoteProposal_Success() {
   270  	s.mockTransactor.EXPECT().Transact(
   271  		gomock.Any(),
   272  		gomock.Any(),
   273  		gomock.Any(),
   274  	).Return(&common.Hash{37, 38, 39}, nil)
   275  	res, err := s.bridgeContract.VoteProposal(&s.proposal, transactor.DefaultTransactionOptions)
   276  	s.Equal(
   277  		&common.Hash{37, 38, 39},
   278  		res,
   279  	)
   280  	s.Nil(err)
   281  }
   282  
   283  func (s *ProposalStatusTestSuite) TestBridge_SimulateVoteProposal_Success() {
   284  	s.mockContractCaller.EXPECT().From().Return(common.HexToAddress(testInteractorAddress))
   285  	s.mockContractCaller.EXPECT().CallContract(
   286  		gomock.Any(),
   287  		gomock.Any(),
   288  		nil,
   289  	).Return([]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10}, nil)
   290  	err := s.bridgeContract.SimulateVoteProposal(&s.proposal)
   291  	s.Nil(err)
   292  }
   293  
   294  func (s *ProposalStatusTestSuite) TestBridge_Pause_Success() {
   295  	s.mockTransactor.EXPECT().Transact(
   296  		gomock.Any(),
   297  		gomock.Any(),
   298  		gomock.Any(),
   299  	).Return(&common.Hash{40, 41, 42}, nil)
   300  	res, err := s.bridgeContract.Pause(transactor.DefaultTransactionOptions)
   301  	s.Equal(
   302  		&common.Hash{40, 41, 42},
   303  		res,
   304  	)
   305  	s.Nil(err)
   306  }
   307  
   308  func (s *ProposalStatusTestSuite) TestBridge_Unpause_Success() {
   309  	s.mockTransactor.EXPECT().Transact(
   310  		gomock.Any(),
   311  		gomock.Any(),
   312  		gomock.Any(),
   313  	).Return(&common.Hash{42, 43, 44}, nil)
   314  	res, err := s.bridgeContract.Unpause(transactor.DefaultTransactionOptions)
   315  	s.Equal(
   316  		&common.Hash{42, 43, 44},
   317  		res,
   318  	)
   319  	s.Nil(err)
   320  }
   321  
   322  func (s *ProposalStatusTestSuite) TestBridge_Withdraw_Success() {
   323  	s.mockTransactor.EXPECT().Transact(
   324  		gomock.Any(),
   325  		gomock.Any(),
   326  		gomock.Any(),
   327  	).Return(&common.Hash{44, 45, 46}, nil)
   328  	res, err := s.bridgeContract.Withdraw(
   329  		common.HexToAddress(testHandlerAddress),
   330  		common.HexToAddress(testContractAddress),
   331  		common.HexToAddress(testInteractorAddress),
   332  		big.NewInt(5), transactor.DefaultTransactionOptions,
   333  	)
   334  	s.Equal(
   335  		&common.Hash{44, 45, 46},
   336  		res,
   337  	)
   338  	s.Nil(err)
   339  }
   340  
   341  func (s *ProposalStatusTestSuite) TestBridge_GetThreshold_Success() {
   342  	s.mockContractCaller.EXPECT().From().Return(common.HexToAddress(testInteractorAddress))
   343  	s.mockContractCaller.EXPECT().CallContract(
   344  		gomock.Any(),
   345  		gomock.Any(),
   346  		nil,
   347  	).Return([]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2}, nil)
   348  	res, err := s.bridgeContract.GetThreshold()
   349  	s.Equal(
   350  		uint8(2),
   351  		res,
   352  	)
   353  	s.Nil(err)
   354  }
   355  
   356  func (s *ProposalStatusTestSuite) TestBridge_IsRelayer_Success() {
   357  	s.mockContractCaller.EXPECT().From().Return(common.HexToAddress(testInteractorAddress))
   358  	s.mockContractCaller.EXPECT().CallContract(
   359  		gomock.Any(),
   360  		gomock.Any(),
   361  		nil,
   362  	).Return([]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, nil)
   363  	res, err := s.bridgeContract.IsRelayer(common.HexToAddress(testInteractorAddress))
   364  	s.Equal(
   365  		true,
   366  		res,
   367  	)
   368  	s.Nil(err)
   369  }
   370  
   371  func (s *ProposalStatusTestSuite) TestBridge_ProposalStatus_Success() {
   372  	proposalStatus, _ := hex.DecodeString("0000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000001f")
   373  	s.mockContractCaller.EXPECT().From().Return(common.HexToAddress(testInteractorAddress))
   374  	s.mockContractCaller.EXPECT().CallContract(
   375  		gomock.Any(),
   376  		gomock.Any(),
   377  		nil,
   378  	).Return(proposalStatus, nil)
   379  	res, err := s.bridgeContract.ProposalStatus(&s.proposal)
   380  	s.Equal(
   381  		message.ProposalStatus(message.ProposalStatus{Status: 0x3, YesVotes: big.NewInt(28), YesVotesTotal: 0x3, ProposedBlock: big.NewInt(31)}),
   382  		res,
   383  	)
   384  	s.Nil(err)
   385  }
   386  
   387  func (s *ProposalStatusTestSuite) TestBridge_IsProposalVotedBy_Success() {
   388  	s.mockContractCaller.EXPECT().From().Return(common.HexToAddress(testInteractorAddress))
   389  	s.mockContractCaller.EXPECT().CallContract(
   390  		gomock.Any(),
   391  		gomock.Any(),
   392  		nil,
   393  	).Return([]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, nil)
   394  	res, err := s.bridgeContract.IsProposalVotedBy(common.HexToAddress(testHandlerAddress), &s.proposal)
   395  	s.Equal(
   396  		true,
   397  		res,
   398  	)
   399  	s.Nil(err)
   400  }
   401  
   402  func (s *ProposalStatusTestSuite) TestBridge_GetHandlerAddressForResourceID_Success() {
   403  	s.mockContractCaller.EXPECT().From().Return(common.HexToAddress(testInteractorAddress))
   404  	s.mockContractCaller.EXPECT().CallContract(
   405  		gomock.Any(),
   406  		gomock.Any(),
   407  		nil,
   408  	).Return([]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5}, nil)
   409  	res, err := s.bridgeContract.GetHandlerAddressForResourceID(testResourceId)
   410  	s.Equal(
   411  		common.HexToAddress("0x0000000000000000000000000000000102030405"),
   412  		res,
   413  	)
   414  	s.Nil(err)
   415  }