github.com/ChainSafe/chainbridge-core@v1.4.2/chains/evm/calls/transactor/itx/itx_test.go (about)

     1  package itx_test
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"math/big"
     7  	"testing"
     8  
     9  	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/transactor"
    10  	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/transactor/itx"
    11  	mock_itx "github.com/ChainSafe/chainbridge-core/chains/evm/calls/transactor/itx/mock"
    12  	"github.com/ChainSafe/chainbridge-core/crypto/secp256k1"
    13  	"github.com/ethereum/go-ethereum/common"
    14  	"github.com/golang/mock/gomock"
    15  	"github.com/stretchr/testify/suite"
    16  )
    17  
    18  type TransactTestSuite struct {
    19  	suite.Suite
    20  	forwarder   *mock_itx.MockForwarder
    21  	relayCaller *mock_itx.MockRelayCaller
    22  	transactor  *itx.ITXTransactor
    23  	kp          *secp256k1.Keypair
    24  }
    25  
    26  func TestRunTransactTestSuite(t *testing.T) {
    27  	suite.Run(t, new(TransactTestSuite))
    28  }
    29  
    30  func (s *TransactTestSuite) SetupSuite()    {}
    31  func (s *TransactTestSuite) TearDownSuite() {}
    32  func (s *TransactTestSuite) SetupTest() {
    33  	gomockController := gomock.NewController(s.T())
    34  	s.kp, _ = secp256k1.NewKeypairFromPrivateKey(common.Hex2Bytes("e8e0f5427111dee651e63a6f1029da6929ebf7d2d61cefaf166cebefdf2c012e"))
    35  	s.forwarder = mock_itx.NewMockForwarder(gomockController)
    36  	s.relayCaller = mock_itx.NewMockRelayCaller(gomockController)
    37  	s.transactor = itx.NewITXTransactor(s.relayCaller, s.forwarder, s.kp)
    38  	s.forwarder.EXPECT().ChainId().Return(big.NewInt(5))
    39  }
    40  func (s *TransactTestSuite) TearDownTest() {}
    41  
    42  func (s *TransactTestSuite) TestTransact_FailedFetchingNonce() {
    43  	s.forwarder.EXPECT().LockNonce()
    44  	s.forwarder.EXPECT().UnlockNonce()
    45  	s.forwarder.EXPECT().UnsafeNonce().Return(nil, errors.New("error"))
    46  
    47  	to := common.HexToAddress("0x04005C8A516292af163b1AFe3D855b9f4f4631B5")
    48  	data := []byte{}
    49  	opts := transactor.TransactOptions{}
    50  	_, err := s.transactor.Transact(&to, data, opts)
    51  
    52  	s.NotNil(err)
    53  }
    54  
    55  func (s *TransactTestSuite) TestTransact_FailedFetchingForwarderData() {
    56  	s.forwarder.EXPECT().LockNonce()
    57  	s.forwarder.EXPECT().UnlockNonce()
    58  	s.forwarder.EXPECT().UnsafeNonce().Return(big.NewInt(1), nil)
    59  	to := common.HexToAddress("0x04005C8A516292af163b1AFe3D855b9f4f4631B5")
    60  	data := []byte{}
    61  	opts := transactor.TransactOptions{
    62  		GasLimit: 200000,
    63  		GasPrice: big.NewInt(1),
    64  		Priority: 1, // slow
    65  		Value:    big.NewInt(0),
    66  		ChainID:  big.NewInt(5),
    67  		Nonce:    big.NewInt(1),
    68  	}
    69  	s.forwarder.EXPECT().ForwarderData(&to, data, opts).Return(nil, errors.New("error"))
    70  
    71  	_, err := s.transactor.Transact(&to, data, opts)
    72  
    73  	s.NotNil(err)
    74  }
    75  
    76  func (s *TransactTestSuite) TestTransact_FailedSendingTransaction() {
    77  	s.forwarder.EXPECT().LockNonce()
    78  	s.forwarder.EXPECT().UnlockNonce()
    79  	s.forwarder.EXPECT().UnsafeNonce().Return(big.NewInt(1), nil)
    80  	to := common.HexToAddress("0x04005C8A516292af163b1AFe3D855b9f4f4631B5")
    81  	data := []byte{}
    82  	opts := transactor.TransactOptions{
    83  		GasLimit: 200000,
    84  		GasPrice: big.NewInt(1),
    85  		Priority: 1, // slow
    86  		Value:    big.NewInt(0),
    87  		ChainID:  big.NewInt(5),
    88  		Nonce:    big.NewInt(1),
    89  	}
    90  	s.forwarder.EXPECT().ForwarderData(&to, data, opts).Return([]byte{}, nil)
    91  	s.forwarder.EXPECT().ForwarderAddress().Return(to)
    92  	s.relayCaller.EXPECT().CallContext(
    93  		context.Background(),
    94  		gomock.Any(),
    95  		"relay_sendTransaction",
    96  		gomock.Any(),
    97  		gomock.Any(),
    98  	).Return(errors.New("error"))
    99  
   100  	_, err := s.transactor.Transact(&to, data, opts)
   101  
   102  	s.NotNil(err)
   103  }
   104  
   105  func (s *TransactTestSuite) TestTransact_SuccessfulSend() {
   106  	s.forwarder.EXPECT().LockNonce()
   107  	s.forwarder.EXPECT().UnlockNonce()
   108  	s.forwarder.EXPECT().UnsafeNonce().Return(big.NewInt(1), nil)
   109  	s.forwarder.EXPECT().UnsafeIncreaseNonce()
   110  	to := common.HexToAddress("0x04005C8A516292af163b1AFe3D855b9f4f4631B5")
   111  	data := []byte{}
   112  	opts := transactor.TransactOptions{
   113  		GasLimit: 200000,
   114  		GasPrice: big.NewInt(1),
   115  		Priority: 1, // slow
   116  		Value:    big.NewInt(0),
   117  		ChainID:  big.NewInt(5),
   118  		Nonce:    big.NewInt(1),
   119  	}
   120  	expectedSig := "0x68ad089b7daeabcdd76520377822cc32eba0b41ea702358bc8f7249bc296d408781eb60366a3bb6ad9fc62dca08bdf440a7c4f02e3680aa0b477a2dd5423d5af01"
   121  
   122  	s.forwarder.EXPECT().ForwarderData(&to, data, opts).Return([]byte{}, nil)
   123  	s.forwarder.EXPECT().ForwarderAddress().Return(to)
   124  	s.relayCaller.EXPECT().CallContext(
   125  		context.Background(),
   126  		gomock.Any(),
   127  		"relay_sendTransaction",
   128  		gomock.Any(),
   129  		expectedSig,
   130  	).Return(nil)
   131  
   132  	hash, err := s.transactor.Transact(&to, data, opts)
   133  
   134  	s.Nil(err)
   135  	s.NotNil(hash)
   136  }
   137  
   138  func (s *TransactTestSuite) TestTransact_SuccessfulSendWithDefaultOpts_WithSetPriority() {
   139  	s.forwarder.EXPECT().LockNonce()
   140  	s.forwarder.EXPECT().UnlockNonce()
   141  	s.forwarder.EXPECT().UnsafeNonce().Return(big.NewInt(1), nil)
   142  	s.forwarder.EXPECT().UnsafeIncreaseNonce()
   143  	to := common.HexToAddress("0x04005C8A516292af163b1AFe3D855b9f4f4631B5")
   144  	data := []byte{}
   145  	expectedOpts := transactor.TransactOptions{
   146  		GasLimit: 400000,
   147  		GasPrice: big.NewInt(1),
   148  		Priority: 2, // fast
   149  		Value:    big.NewInt(0),
   150  		ChainID:  big.NewInt(5),
   151  		Nonce:    big.NewInt(1),
   152  	}
   153  	expectedSig := "0x97e8845b060718b04c710e2e4bd786d80bc5d5843f41b0b461d756f5c5a5865f32fe1d82f838de6ac212d7caaf7e7f469510a75d3803173f5b5c21fec62a989900"
   154  
   155  	s.forwarder.EXPECT().ForwarderData(&to, data, expectedOpts).Return([]byte{}, nil)
   156  	s.forwarder.EXPECT().ForwarderAddress().Return(to)
   157  	s.relayCaller.EXPECT().CallContext(
   158  		context.Background(),
   159  		gomock.Any(),
   160  		"relay_sendTransaction",
   161  		gomock.Any(),
   162  		expectedSig,
   163  	).Return(nil)
   164  
   165  	hash, err := s.transactor.Transact(&to, data, transactor.TransactOptions{
   166  		Priority: 2,
   167  	})
   168  
   169  	s.Nil(err)
   170  	s.NotNil(hash)
   171  }
   172  
   173  func (s *TransactTestSuite) TestTransact_SuccessfulSendWithDefaultOpts_WithDefaultPriority() {
   174  	s.forwarder.EXPECT().LockNonce()
   175  	s.forwarder.EXPECT().UnlockNonce()
   176  	s.forwarder.EXPECT().UnsafeNonce().Return(big.NewInt(1), nil)
   177  	s.forwarder.EXPECT().UnsafeIncreaseNonce()
   178  	to := common.HexToAddress("0x04005C8A516292af163b1AFe3D855b9f4f4631B5")
   179  	data := []byte{}
   180  	expectedOpts := transactor.TransactOptions{
   181  		GasLimit: 400000,
   182  		GasPrice: big.NewInt(1),
   183  		Priority: 1, // slow
   184  		Value:    big.NewInt(0),
   185  		ChainID:  big.NewInt(5),
   186  		Nonce:    big.NewInt(1),
   187  	}
   188  	expectedSig := "0x97e8845b060718b04c710e2e4bd786d80bc5d5843f41b0b461d756f5c5a5865f32fe1d82f838de6ac212d7caaf7e7f469510a75d3803173f5b5c21fec62a989900"
   189  
   190  	s.forwarder.EXPECT().ForwarderData(&to, data, expectedOpts).Return([]byte{}, nil)
   191  	s.forwarder.EXPECT().ForwarderAddress().Return(to)
   192  	s.relayCaller.EXPECT().CallContext(
   193  		context.Background(),
   194  		gomock.Any(),
   195  		"relay_sendTransaction",
   196  		gomock.Any(),
   197  		expectedSig,
   198  	).Return(nil)
   199  
   200  	hash, err := s.transactor.Transact(&to, data, transactor.TransactOptions{})
   201  
   202  	s.Nil(err)
   203  	s.NotNil(hash)
   204  }