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 }