github.com/ChainSafe/chainbridge-core@v1.4.2/chains/evm/executor/message-handler_test.go (about)

     1  package executor_test
     2  
     3  import (
     4  	"errors"
     5  
     6  	"testing"
     7  
     8  	"github.com/ChainSafe/chainbridge-core/chains/evm/executor"
     9  	"github.com/ChainSafe/chainbridge-core/relayer/message"
    10  	"github.com/ethereum/go-ethereum/common"
    11  	"github.com/stretchr/testify/suite"
    12  )
    13  
    14  var errIncorrectERC20PayloadLen = errors.New("malformed payload. Len  of payload should be 2")
    15  var errIncorrectERC721PayloadLen = errors.New("malformed payload. Len  of payload should be 3")
    16  var errIncorrectGenericPayloadLen = errors.New("malformed payload. Len  of payload should be 1")
    17  
    18  var errIncorrectAmount = errors.New("wrong payload amount format")
    19  var errIncorrectRecipient = errors.New("wrong payload recipient format")
    20  var errIncorrectTokenID = errors.New("wrong payload tokenID format")
    21  var errIncorrectMetadata = errors.New("wrong payload metadata format")
    22  
    23  //ERC20
    24  type Erc20HandlerTestSuite struct {
    25  	suite.Suite
    26  }
    27  
    28  func TestRunErc20HandlerTestSuite(t *testing.T) {
    29  	suite.Run(t, new(Erc20HandlerTestSuite))
    30  }
    31  
    32  func (s *Erc20HandlerTestSuite) SetupSuite()    {}
    33  func (s *Erc20HandlerTestSuite) TearDownSuite() {}
    34  func (s *Erc20HandlerTestSuite) SetupTest()     {}
    35  func (s *Erc20HandlerTestSuite) TearDownTest()  {}
    36  
    37  func (s *Erc20HandlerTestSuite) TestErc20HandleMessage() {
    38  	message := &message.Message{
    39  		Source:       1,
    40  		Destination:  0,
    41  		DepositNonce: 1,
    42  		ResourceId:   [32]byte{0},
    43  		Type:         message.FungibleTransfer,
    44  		Payload: []interface{}{
    45  			[]byte{2}, // amount
    46  			[]byte{241, 229, 143, 177, 119, 4, 194, 218, 132, 121, 165, 51, 249, 250, 212, 173, 9, 147, 202, 107}, // recipientAddress
    47  		},
    48  		Metadata: message.Metadata{
    49  			Priority: uint8(1),
    50  		},
    51  	}
    52  
    53  	prop, err := executor.ERC20MessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
    54  
    55  	s.Nil(err)
    56  	s.NotNil(prop)
    57  }
    58  
    59  func (s *Erc20HandlerTestSuite) TestErc20HandleMessageIncorrectDataLen() {
    60  	message := &message.Message{
    61  		Source:       1,
    62  		Destination:  0,
    63  		DepositNonce: 1,
    64  		ResourceId:   [32]byte{0},
    65  		Type:         message.FungibleTransfer,
    66  		Payload: []interface{}{
    67  			[]byte{2}, // amount
    68  		},
    69  		Metadata: message.Metadata{
    70  			Priority: uint8(1),
    71  		},
    72  	}
    73  
    74  	prop, err := executor.ERC20MessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
    75  
    76  	s.Nil(prop)
    77  	s.NotNil(err)
    78  	s.EqualError(err, errIncorrectERC20PayloadLen.Error())
    79  }
    80  
    81  func (s *Erc20HandlerTestSuite) TestErc20HandleMessageIncorrectAmount() {
    82  	message := &message.Message{
    83  		Source:       1,
    84  		Destination:  0,
    85  		DepositNonce: 1,
    86  		ResourceId:   [32]byte{0},
    87  		Type:         message.FungibleTransfer,
    88  		Payload: []interface{}{
    89  			"incorrectAmount", // amount
    90  			[]byte{241, 229, 143, 177, 119, 4, 194, 218, 132, 121, 165, 51, 249, 250, 212, 173, 9, 147, 202, 107}, // recipientAddress
    91  		},
    92  		Metadata: message.Metadata{
    93  			Priority: uint8(1),
    94  		},
    95  	}
    96  
    97  	prop, err := executor.ERC20MessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
    98  
    99  	s.Nil(prop)
   100  	s.NotNil(err)
   101  	s.EqualError(err, errIncorrectAmount.Error())
   102  }
   103  
   104  func (s *Erc20HandlerTestSuite) TestErc20HandleMessageIncorrectRecipient() {
   105  	message := &message.Message{
   106  		Source:       1,
   107  		Destination:  0,
   108  		DepositNonce: 1,
   109  		ResourceId:   [32]byte{0},
   110  		Type:         message.FungibleTransfer,
   111  		Payload: []interface{}{
   112  			[]byte{2},            // amount
   113  			"incorrectRecipient", // recipientAddress
   114  		},
   115  		Metadata: message.Metadata{
   116  			Priority: uint8(1),
   117  		},
   118  	}
   119  
   120  	prop, err := executor.ERC20MessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
   121  
   122  	s.Nil(prop)
   123  	s.NotNil(err)
   124  	s.EqualError(err, errIncorrectRecipient.Error())
   125  }
   126  
   127  // ERC721
   128  type Erc721HandlerTestSuite struct {
   129  	suite.Suite
   130  }
   131  
   132  func TestRunErc721HandlerTestSuite(t *testing.T) {
   133  	suite.Run(t, new(Erc721HandlerTestSuite))
   134  }
   135  
   136  func (s *Erc721HandlerTestSuite) SetupSuite()    {}
   137  func (s *Erc721HandlerTestSuite) TearDownSuite() {}
   138  func (s *Erc721HandlerTestSuite) SetupTest()     {}
   139  func (s *Erc721HandlerTestSuite) TearDownTest()  {}
   140  
   141  func (s *Erc721HandlerTestSuite) TestErc721MessageHandlerEmptyMetadata() {
   142  	message := &message.Message{
   143  		Source:       1,
   144  		Destination:  0,
   145  		DepositNonce: 1,
   146  		ResourceId:   [32]byte{0},
   147  		Type:         message.FungibleTransfer,
   148  		Payload: []interface{}{
   149  			[]byte{2}, // tokenID
   150  			[]byte{241, 229, 143, 177, 119, 4, 194, 218, 132, 121, 165, 51, 249, 250, 212, 173, 9, 147, 202, 107}, // recipientAddress
   151  			[]byte{}, // metadata
   152  		},
   153  		Metadata: message.Metadata{
   154  			Priority: uint8(1),
   155  		},
   156  	}
   157  
   158  	prop, err := executor.ERC721MessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
   159  
   160  	s.Nil(err)
   161  	s.NotNil(prop)
   162  }
   163  
   164  func (s *Erc721HandlerTestSuite) TestErc721MessageHandlerIncorrectDataLen() {
   165  	message := &message.Message{
   166  		Source:       1,
   167  		Destination:  0,
   168  		DepositNonce: 1,
   169  		ResourceId:   [32]byte{0},
   170  		Type:         message.FungibleTransfer,
   171  		Payload: []interface{}{
   172  			[]byte{2}, // tokenID
   173  		},
   174  		Metadata: message.Metadata{
   175  			Priority: uint8(1),
   176  		},
   177  	}
   178  
   179  	prop, err := executor.ERC721MessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
   180  
   181  	s.Nil(prop)
   182  	s.NotNil(err)
   183  	s.EqualError(err, errIncorrectERC721PayloadLen.Error())
   184  }
   185  
   186  func (s *Erc721HandlerTestSuite) TestErc721MessageHandlerIncorrectAmount() {
   187  	message := &message.Message{
   188  		Source:       1,
   189  		Destination:  0,
   190  		DepositNonce: 1,
   191  		ResourceId:   [32]byte{0},
   192  		Type:         message.FungibleTransfer,
   193  		Payload: []interface{}{
   194  			"incorrectAmount", // tokenID
   195  			[]byte{241, 229, 143, 177, 119, 4, 194, 218, 132, 121, 165, 51, 249, 250, 212, 173, 9, 147, 202, 107}, // recipientAddress
   196  			[]byte{}, // metadata
   197  		},
   198  		Metadata: message.Metadata{
   199  			Priority: uint8(1),
   200  		},
   201  	}
   202  
   203  	prop, err := executor.ERC721MessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
   204  
   205  	s.Nil(prop)
   206  	s.NotNil(err)
   207  	s.EqualError(err, errIncorrectTokenID.Error())
   208  }
   209  
   210  func (s *Erc721HandlerTestSuite) TestErc721MessageHandlerIncorrectRecipient() {
   211  	message := &message.Message{
   212  		Source:       1,
   213  		Destination:  0,
   214  		DepositNonce: 1,
   215  		ResourceId:   [32]byte{0},
   216  		Type:         message.FungibleTransfer,
   217  		Payload: []interface{}{
   218  			[]byte{2}, // amount
   219  			"incorrectRecipient",
   220  			[]byte{}, // metadata
   221  		},
   222  		Metadata: message.Metadata{
   223  			Priority: uint8(1),
   224  		},
   225  	}
   226  
   227  	prop, err := executor.ERC721MessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
   228  
   229  	s.Nil(prop)
   230  	s.NotNil(err)
   231  	s.EqualError(err, errIncorrectRecipient.Error())
   232  }
   233  
   234  func (s *Erc721HandlerTestSuite) TestErc721MessageHandlerIncorrectMetadata() {
   235  	message := &message.Message{
   236  		Source:       1,
   237  		Destination:  0,
   238  		DepositNonce: 1,
   239  		ResourceId:   [32]byte{0},
   240  		Type:         message.FungibleTransfer,
   241  		Payload: []interface{}{
   242  			[]byte{2}, // amount
   243  			[]byte{241, 229, 143, 177, 119, 4, 194, 218, 132, 121, 165, 51, 249, 250, 212, 173, 9, 147, 202, 107}, // recipientAddress
   244  			"incorrectMetadata", // metadata
   245  		},
   246  		Metadata: message.Metadata{
   247  			Priority: uint8(1),
   248  		},
   249  	}
   250  
   251  	prop, err := executor.ERC721MessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
   252  
   253  	s.Nil(prop)
   254  	s.NotNil(err)
   255  	s.EqualError(err, errIncorrectMetadata.Error())
   256  }
   257  
   258  // GENERIC
   259  type GenericHandlerTestSuite struct {
   260  	suite.Suite
   261  }
   262  
   263  func TestRunGenericHandlerTestSuite(t *testing.T) {
   264  	suite.Run(t, new(GenericHandlerTestSuite))
   265  }
   266  
   267  func (s *GenericHandlerTestSuite) SetupSuite()    {}
   268  func (s *GenericHandlerTestSuite) TearDownSuite() {}
   269  func (s *GenericHandlerTestSuite) SetupTest()     {}
   270  func (s *GenericHandlerTestSuite) TearDownTest()  {}
   271  func (s *GenericHandlerTestSuite) TestGenericHandleEvent() {
   272  	message := &message.Message{
   273  		Source:       1,
   274  		Destination:  0,
   275  		DepositNonce: 1,
   276  		ResourceId:   [32]byte{0},
   277  		Type:         message.FungibleTransfer,
   278  		Payload: []interface{}{
   279  			[]byte{}, // metadata
   280  		},
   281  		Metadata: message.Metadata{
   282  			Priority: uint8(1),
   283  		},
   284  	}
   285  
   286  	prop, err := executor.GenericMessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
   287  
   288  	s.Nil(err)
   289  	s.NotNil(prop)
   290  }
   291  
   292  func (s *GenericHandlerTestSuite) TestGenericHandleEventIncorrectDataLen() {
   293  	message := &message.Message{
   294  		Source:       1,
   295  		Destination:  0,
   296  		DepositNonce: 1,
   297  		ResourceId:   [32]byte{0},
   298  		Type:         message.FungibleTransfer,
   299  		Payload:      []interface{}{},
   300  		Metadata: message.Metadata{
   301  			Priority: uint8(1),
   302  		},
   303  	}
   304  
   305  	prop, err := executor.GenericMessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
   306  
   307  	s.Nil(prop)
   308  	s.NotNil(err)
   309  	s.EqualError(err, errIncorrectGenericPayloadLen.Error())
   310  }
   311  
   312  func (s *GenericHandlerTestSuite) TestGenericHandleEventIncorrectMetadata() {
   313  	message := &message.Message{
   314  		Source:       1,
   315  		Destination:  0,
   316  		DepositNonce: 1,
   317  		ResourceId:   [32]byte{0},
   318  		Type:         message.FungibleTransfer,
   319  		Payload: []interface{}{
   320  			"incorrectMetadata", // metadata
   321  		},
   322  		Metadata: message.Metadata{
   323  			Priority: uint8(1),
   324  		},
   325  	}
   326  
   327  	prop, err := executor.GenericMessageHandler(message, common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"), common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b"))
   328  
   329  	s.Nil(prop)
   330  	s.NotNil(err)
   331  	s.EqualError(err, errIncorrectMetadata.Error())
   332  }