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

     1  package listener_test
     2  
     3  import (
     4  	"errors"
     5  	"math/big"
     6  	"testing"
     7  
     8  	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/contracts/deposit"
     9  	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/events"
    10  	"github.com/ChainSafe/chainbridge-core/chains/evm/listener"
    11  	"github.com/ChainSafe/chainbridge-core/relayer/message"
    12  	"github.com/ethereum/go-ethereum/common"
    13  	"github.com/ethereum/go-ethereum/common/math"
    14  	"github.com/stretchr/testify/suite"
    15  )
    16  
    17  var errIncorrectDataLen = errors.New("invalid calldata length: less than 84 bytes")
    18  
    19  type Erc20HandlerTestSuite struct {
    20  	suite.Suite
    21  }
    22  
    23  func TestRunErc20HandlerTestSuite(t *testing.T) {
    24  	suite.Run(t, new(Erc20HandlerTestSuite))
    25  }
    26  
    27  func (s *Erc20HandlerTestSuite) SetupSuite()    {}
    28  func (s *Erc20HandlerTestSuite) TearDownSuite() {}
    29  func (s *Erc20HandlerTestSuite) SetupTest()     {}
    30  func (s *Erc20HandlerTestSuite) TearDownTest()  {}
    31  
    32  func (s *Erc20HandlerTestSuite) TestErc20HandleEvent() {
    33  	// 0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b
    34  	recipientByteSlice := []byte{241, 229, 143, 177, 119, 4, 194, 218, 132, 121, 165, 51, 249, 250, 212, 173, 9, 147, 202, 107}
    35  
    36  	calldata := deposit.ConstructErc20DepositData(recipientByteSlice, big.NewInt(2))
    37  	depositLog := &events.Deposit{
    38  		DestinationDomainID: 0,
    39  		ResourceID:          [32]byte{0},
    40  		DepositNonce:        1,
    41  		SenderAddress:       common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"),
    42  		Data:                calldata,
    43  		HandlerResponse:     []byte{},
    44  	}
    45  
    46  	sourceID := uint8(1)
    47  	amountParsed := calldata[:32]
    48  	recipientAddressParsed := calldata[64:]
    49  
    50  	expected := &message.Message{
    51  		Source:       sourceID,
    52  		Destination:  depositLog.DestinationDomainID,
    53  		DepositNonce: depositLog.DepositNonce,
    54  		ResourceId:   depositLog.ResourceID,
    55  		Type:         message.FungibleTransfer,
    56  		Payload: []interface{}{
    57  			amountParsed,
    58  			recipientAddressParsed,
    59  		},
    60  	}
    61  
    62  	message, err := listener.Erc20DepositHandler(sourceID, depositLog.DestinationDomainID, depositLog.DepositNonce, depositLog.ResourceID, depositLog.Data, depositLog.HandlerResponse)
    63  
    64  	s.Nil(err)
    65  	s.NotNil(message)
    66  	s.Equal(message, expected)
    67  }
    68  
    69  func (s *Erc20HandlerTestSuite) TestErc20HandleEventWithPriority() {
    70  	// 0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b
    71  	recipientByteSlice := []byte{241, 229, 143, 177, 119, 4, 194, 218, 132, 121, 165, 51, 249, 250, 212, 173, 9, 147, 202, 107}
    72  
    73  	calldata := deposit.ConstructErc20DepositDataWithPriority(recipientByteSlice, big.NewInt(2), uint8(1))
    74  	depositLog := &events.Deposit{
    75  		DestinationDomainID: 0,
    76  		ResourceID:          [32]byte{0},
    77  		DepositNonce:        1,
    78  		SenderAddress:       common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"),
    79  		Data:                calldata,
    80  		HandlerResponse:     []byte{},
    81  	}
    82  
    83  	sourceID := uint8(1)
    84  	amountParsed := calldata[:32]
    85  	// 32-64 is recipient address length
    86  	recipientAddressLength := big.NewInt(0).SetBytes(calldata[32:64])
    87  
    88  	// 64 - (64 + recipient address length) is recipient address
    89  	recipientAddressParsed := calldata[64:(64 + recipientAddressLength.Int64())]
    90  	expected := &message.Message{
    91  		Source:       sourceID,
    92  		Destination:  depositLog.DestinationDomainID,
    93  		DepositNonce: depositLog.DepositNonce,
    94  		ResourceId:   depositLog.ResourceID,
    95  		Type:         message.FungibleTransfer,
    96  		Payload: []interface{}{
    97  			amountParsed,
    98  			recipientAddressParsed,
    99  		},
   100  		Metadata: message.Metadata{
   101  			Priority: uint8(1),
   102  		},
   103  	}
   104  
   105  	message, err := listener.Erc20DepositHandler(sourceID, depositLog.DestinationDomainID, depositLog.DepositNonce, depositLog.ResourceID, depositLog.Data, depositLog.HandlerResponse)
   106  
   107  	s.Nil(err)
   108  	s.NotNil(message)
   109  	s.Equal(message, expected)
   110  }
   111  
   112  func (s *Erc20HandlerTestSuite) TestErc20HandleEventIncorrectDataLen() {
   113  	metadata := []byte("0xdeadbeef")
   114  
   115  	var calldata []byte
   116  	calldata = append(calldata, math.PaddedBigBytes(big.NewInt(int64(len(metadata))), 32)...)
   117  	calldata = append(calldata, metadata...)
   118  
   119  	depositLog := &events.Deposit{
   120  		DestinationDomainID: 0,
   121  		ResourceID:          [32]byte{0},
   122  		DepositNonce:        1,
   123  		SenderAddress:       common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"),
   124  		Data:                calldata,
   125  		HandlerResponse:     []byte{},
   126  	}
   127  
   128  	sourceID := uint8(1)
   129  
   130  	message, err := listener.Erc20DepositHandler(sourceID, depositLog.DestinationDomainID, depositLog.DepositNonce, depositLog.ResourceID, depositLog.Data, depositLog.HandlerResponse)
   131  
   132  	s.Nil(message)
   133  	s.EqualError(err, errIncorrectDataLen.Error())
   134  }
   135  
   136  type Erc721HandlerTestSuite struct {
   137  	suite.Suite
   138  }
   139  
   140  func TestRunErc721HandlerTestSuite(t *testing.T) {
   141  	suite.Run(t, new(Erc721HandlerTestSuite))
   142  }
   143  
   144  func (s *Erc721HandlerTestSuite) SetupSuite()    {}
   145  func (s *Erc721HandlerTestSuite) TearDownSuite() {}
   146  func (s *Erc721HandlerTestSuite) SetupTest()     {}
   147  func (s *Erc721HandlerTestSuite) TearDownTest()  {}
   148  
   149  func (s *Erc721HandlerTestSuite) TestErc721DepositHandlerEmptyMetadata() {
   150  	recipient := common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b")
   151  
   152  	calldata := deposit.ConstructErc721DepositData(recipient.Bytes(), big.NewInt(2), []byte{})
   153  	depositLog := &events.Deposit{
   154  		DestinationDomainID: 0,
   155  		ResourceID:          [32]byte{0},
   156  		DepositNonce:        1,
   157  		Data:                calldata,
   158  		HandlerResponse:     []byte{},
   159  	}
   160  
   161  	sourceID := uint8(1)
   162  	tokenId := calldata[:32]
   163  	recipientAddressParsed := calldata[64:84]
   164  	var metadata []byte
   165  
   166  	expected := &message.Message{
   167  		Source:       sourceID,
   168  		Destination:  depositLog.DestinationDomainID,
   169  		DepositNonce: depositLog.DepositNonce,
   170  		ResourceId:   depositLog.ResourceID,
   171  		Type:         message.NonFungibleTransfer,
   172  		Payload: []interface{}{
   173  			tokenId,
   174  			recipientAddressParsed,
   175  			metadata,
   176  		},
   177  	}
   178  
   179  	m, err := listener.Erc721DepositHandler(sourceID, depositLog.DestinationDomainID, depositLog.DepositNonce, depositLog.ResourceID, depositLog.Data, depositLog.HandlerResponse)
   180  	s.Nil(err)
   181  	s.NotNil(m)
   182  	s.Equal(expected, m)
   183  }
   184  
   185  func (s *Erc721HandlerTestSuite) TestErc721DepositHandlerIncorrectDataLen() {
   186  	metadata := []byte("0xdeadbeef")
   187  
   188  	var calldata []byte
   189  	calldata = append(calldata, math.PaddedBigBytes(big.NewInt(int64(len(metadata))), 16)...)
   190  	calldata = append(calldata, metadata...)
   191  
   192  	depositLog := &events.Deposit{
   193  		DestinationDomainID: 0,
   194  		ResourceID:          [32]byte{0},
   195  		DepositNonce:        1,
   196  		SenderAddress:       common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"),
   197  		Data:                calldata,
   198  		HandlerResponse:     []byte{},
   199  	}
   200  
   201  	sourceID := uint8(1)
   202  
   203  	m, err := listener.Erc721DepositHandler(sourceID, depositLog.DestinationDomainID, depositLog.DepositNonce, depositLog.ResourceID, depositLog.Data, depositLog.HandlerResponse)
   204  	s.Nil(m)
   205  	s.EqualError(err, "invalid calldata length: less than 84 bytes")
   206  }
   207  
   208  func (s *Erc721HandlerTestSuite) TestErc721DepositHandler() {
   209  	recipient := common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b")
   210  	metadata := []byte("metadata.url")
   211  
   212  	calldata := deposit.ConstructErc721DepositData(recipient.Bytes(), big.NewInt(2), metadata)
   213  	depositLog := &events.Deposit{
   214  		DestinationDomainID: 0,
   215  		ResourceID:          [32]byte{0},
   216  		DepositNonce:        1,
   217  		Data:                calldata,
   218  		HandlerResponse:     []byte{},
   219  	}
   220  
   221  	sourceID := uint8(1)
   222  	tokenId := calldata[:32]
   223  	recipientAddressParsed := calldata[64:84]
   224  	parsedMetadata := calldata[116:128]
   225  
   226  	expected := &message.Message{
   227  		Source:       sourceID,
   228  		Destination:  depositLog.DestinationDomainID,
   229  		DepositNonce: depositLog.DepositNonce,
   230  		ResourceId:   depositLog.ResourceID,
   231  		Type:         message.NonFungibleTransfer,
   232  		Payload: []interface{}{
   233  			tokenId,
   234  			recipientAddressParsed,
   235  			parsedMetadata,
   236  		},
   237  	}
   238  
   239  	m, err := listener.Erc721DepositHandler(sourceID, depositLog.DestinationDomainID, depositLog.DepositNonce, depositLog.ResourceID, depositLog.Data, depositLog.HandlerResponse)
   240  	s.Nil(err)
   241  	s.NotNil(m)
   242  	s.Equal(expected, m)
   243  }
   244  func (s *Erc721HandlerTestSuite) TestErc721DepositHandlerWithPriority() {
   245  	recipient := common.HexToAddress("0xf1e58fb17704c2da8479a533f9fad4ad0993ca6b")
   246  	metadata := []byte("metadata.url")
   247  
   248  	calldata := deposit.ConstructErc721DepositDataWithPriority(recipient.Bytes(), big.NewInt(2), metadata, uint8(1))
   249  	depositLog := &events.Deposit{
   250  		DestinationDomainID: 0,
   251  		ResourceID:          [32]byte{0},
   252  		DepositNonce:        1,
   253  		Data:                calldata,
   254  		HandlerResponse:     []byte{},
   255  	}
   256  
   257  	sourceID := uint8(1)
   258  	tokenId := calldata[:32]
   259  
   260  	// 32 - 64 is recipient address length
   261  	recipientAddressLength := big.NewInt(0).SetBytes(calldata[32:64])
   262  
   263  	// 64 - (64 + recipient address length) is recipient address
   264  	recipientAddressParsed := calldata[64:(64 + recipientAddressLength.Int64())]
   265  
   266  	// (64 + recipient address length) - ((64 + recipient address length) + 32) is metadata length
   267  	metadataLength := big.NewInt(0).SetBytes(
   268  		calldata[(64 + recipientAddressLength.Int64()):((64 + recipientAddressLength.Int64()) + 32)],
   269  	)
   270  
   271  	metadataStart := (64 + recipientAddressLength.Int64()) + 32
   272  	parsedMetadata := calldata[metadataStart : metadataStart+metadataLength.Int64()]
   273  
   274  	expected := &message.Message{
   275  		Source:       sourceID,
   276  		Destination:  depositLog.DestinationDomainID,
   277  		DepositNonce: depositLog.DepositNonce,
   278  		ResourceId:   depositLog.ResourceID,
   279  		Type:         message.NonFungibleTransfer,
   280  		Payload: []interface{}{
   281  			tokenId,
   282  			recipientAddressParsed,
   283  			parsedMetadata,
   284  		},
   285  		Metadata: message.Metadata{
   286  			Priority: uint8(1),
   287  		},
   288  	}
   289  
   290  	m, err := listener.Erc721DepositHandler(sourceID, depositLog.DestinationDomainID, depositLog.DepositNonce, depositLog.ResourceID, depositLog.Data, depositLog.HandlerResponse)
   291  	s.Nil(err)
   292  	s.NotNil(m)
   293  	s.Equal(expected, m)
   294  }
   295  
   296  type GenericHandlerTestSuite struct {
   297  	suite.Suite
   298  }
   299  
   300  func TestRunGenericHandlerTestSuite(t *testing.T) {
   301  	suite.Run(t, new(GenericHandlerTestSuite))
   302  }
   303  
   304  func (s *GenericHandlerTestSuite) SetupSuite()    {}
   305  func (s *GenericHandlerTestSuite) TearDownSuite() {}
   306  func (s *GenericHandlerTestSuite) SetupTest()     {}
   307  func (s *GenericHandlerTestSuite) TearDownTest()  {}
   308  
   309  func (s *GenericHandlerTestSuite) TestGenericHandleEventIncorrectDataLen() {
   310  	metadata := []byte("0xdeadbeef")
   311  
   312  	var calldata []byte
   313  	calldata = append(calldata, math.PaddedBigBytes(big.NewInt(int64(len(metadata))), 16)...)
   314  	calldata = append(calldata, metadata...)
   315  
   316  	depositLog := &events.Deposit{
   317  		DestinationDomainID: 0,
   318  		ResourceID:          [32]byte{0},
   319  		DepositNonce:        1,
   320  		SenderAddress:       common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"),
   321  		Data:                calldata,
   322  		HandlerResponse:     []byte{},
   323  	}
   324  
   325  	sourceID := uint8(1)
   326  	message, err := listener.GenericDepositHandler(
   327  		sourceID,
   328  		depositLog.DestinationDomainID,
   329  		depositLog.DepositNonce,
   330  		depositLog.ResourceID,
   331  		depositLog.Data,
   332  		depositLog.HandlerResponse,
   333  	)
   334  
   335  	s.Nil(message)
   336  	s.EqualError(err, "invalid calldata length: less than 32 bytes")
   337  }
   338  
   339  func (s *GenericHandlerTestSuite) TestGenericHandleEventEmptyMetadata() {
   340  	metadata := []byte("")
   341  	calldata := deposit.ConstructGenericDepositData(metadata)
   342  
   343  	depositLog := &events.Deposit{
   344  		DestinationDomainID: 0,
   345  		ResourceID:          [32]byte{0},
   346  		DepositNonce:        1,
   347  		SenderAddress:       common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"),
   348  		Data:                calldata,
   349  		HandlerResponse:     []byte{},
   350  	}
   351  
   352  	sourceID := uint8(1)
   353  	expected := &message.Message{
   354  		Source:       sourceID,
   355  		Destination:  depositLog.DestinationDomainID,
   356  		DepositNonce: depositLog.DepositNonce,
   357  		ResourceId:   depositLog.ResourceID,
   358  		Type:         message.GenericTransfer,
   359  		Payload: []interface{}{
   360  			metadata,
   361  		},
   362  	}
   363  
   364  	message, err := listener.GenericDepositHandler(
   365  		sourceID,
   366  		depositLog.DestinationDomainID,
   367  		depositLog.DepositNonce,
   368  		depositLog.ResourceID,
   369  		depositLog.Data,
   370  		depositLog.HandlerResponse,
   371  	)
   372  
   373  	s.Nil(err)
   374  	s.NotNil(message)
   375  	s.Equal(message, expected)
   376  }
   377  
   378  func (s *GenericHandlerTestSuite) TestGenericHandleEvent() {
   379  	metadata := []byte("0xdeadbeef")
   380  	calldata := deposit.ConstructGenericDepositData(metadata)
   381  
   382  	depositLog := &events.Deposit{
   383  		DestinationDomainID: 0,
   384  		ResourceID:          [32]byte{0},
   385  		DepositNonce:        1,
   386  		SenderAddress:       common.HexToAddress("0x4CEEf6139f00F9F4535Ad19640Ff7A0137708485"),
   387  		Data:                calldata,
   388  		HandlerResponse:     []byte{},
   389  	}
   390  
   391  	sourceID := uint8(1)
   392  	expected := &message.Message{
   393  		Source:       sourceID,
   394  		Destination:  depositLog.DestinationDomainID,
   395  		DepositNonce: depositLog.DepositNonce,
   396  		ResourceId:   depositLog.ResourceID,
   397  		Type:         message.GenericTransfer,
   398  		Payload: []interface{}{
   399  			metadata,
   400  		},
   401  	}
   402  
   403  	message, err := listener.GenericDepositHandler(
   404  		sourceID,
   405  		depositLog.DestinationDomainID,
   406  		depositLog.DepositNonce,
   407  		depositLog.ResourceID,
   408  		depositLog.Data,
   409  		depositLog.HandlerResponse,
   410  	)
   411  
   412  	s.Nil(err)
   413  	s.NotNil(message)
   414  	s.Equal(message, expected)
   415  }