chore: bump packages

chains/substrate/config.go

@@ -31,7 +31,7 @@ type SubstrateConfig struct {
 	StartBlock         *big.Int
 	BlockInterval      *big.Int
 	BlockRetryInterval time.Duration
-	SubstrateNetwork   uint8
+	SubstrateNetwork   uint16
 	Tip                uint64
 }
 
@@ -90,7 +90,7 @@ func NewSubstrateConfig(chainConfig map[string]interface{}) (*SubstrateConfig, e
 		BlockRetryInterval: time.Duration(c.BlockRetryInterval) * time.Second,
 		StartBlock:         big.NewInt(c.StartBlock),
 		BlockInterval:      big.NewInt(c.BlockInterval),
-		SubstrateNetwork:   uint8(c.SubstrateNetwork),
+		SubstrateNetwork:   uint16(c.SubstrateNetwork),
 		Tip:                uint64(c.Tip),
 	}
 

chains/substrate/config_test.go

@@ -59,7 +59,7 @@ func (s *NewSubstrateConfigTestSuite) Test_ValidConfig() {
 		},
 		StartBlock:         big.NewInt(0),
 		ChainID:            big.NewInt(5),
-		SubstrateNetwork:   uint8(0),
+		SubstrateNetwork:   uint16(0),
 		BlockInterval:      big.NewInt(5),
 		BlockRetryInterval: time.Duration(5) * time.Second,
 	})
@@ -89,7 +89,7 @@ func (s *NewSubstrateConfigTestSuite) Test_ValidConfigWithCustomParams() {
 			Id:       id,
 		},
 		ChainID:            big.NewInt(5),
-		SubstrateNetwork:   uint8(0),
+		SubstrateNetwork:   uint16(0),
 		StartBlock:         big.NewInt(1000),
 		BlockInterval:      big.NewInt(2),
 		BlockRetryInterval: time.Duration(10) * time.Second,

chains/substrate/connection/connection.go

@@ -74,8 +74,8 @@ func (c *Connection) UpdateMetatdata() error {
 }
 
 func (c *Connection) GetBlockEvents(hash types.Hash) ([]*parser.Event, error) {
-	provider := state.NewProvider(c.State)
-	eventRetriever, err := retriever.NewDefaultEventRetriever(provider)
+	provider := state.NewEventProvider(c.State)
+	eventRetriever, err := retriever.NewDefaultEventRetriever(provider, c.State)
 	if err != nil {
 		return nil, err
 	}

chains/substrate/listener/event-handlers.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/ChainSafe/chainbridge-core/relayer/message"
 	"github.com/ChainSafe/sygma-relayer/chains/substrate/events"
+	"github.com/centrifuge/go-substrate-rpc-client/v4/registry"
 	"github.com/centrifuge/go-substrate-rpc-client/v4/registry/parser"
 	"github.com/centrifuge/go-substrate-rpc-client/v4/types"
 	"github.com/mitchellh/mapstructure"
@@ -41,6 +42,67 @@ func (eh *SystemUpdateEventHandler) HandleEvents(evts []*parser.Event, msgChan c
 	return nil
 }
 
+func DecodeEventToDeposit(evtFields registry.DecodedFields) (events.Deposit, error) {
+	var d events.Deposit
+
+	for _, evtField := range evtFields {
+		switch evtField.Name {
+		case "dest_domain_id":
+			err := mapstructure.Decode(evtField.Value, &d.DestDomainID)
+			if err != nil {
+				return events.Deposit{}, err
+			}
+		case "resource_id":
+			err := mapstructure.Decode(evtField.Value, &d.ResourceID)
+			if err != nil {
+				return events.Deposit{}, err
+			}
+		case "deposit_nonce":
+			err := mapstructure.Decode(evtField.Value, &d.DepositNonce)
+			if err != nil {
+				return events.Deposit{}, err
+			}
+		case "sygma_traits_TransferType":
+			err := mapstructure.Decode(evtField.Value, &d.TransferType)
+			if err != nil {
+				return events.Deposit{}, err
+			}
+		case "deposit_data":
+			err := mapstructure.Decode(evtField.Value, &d.CallData)
+			if err != nil {
+				return events.Deposit{}, err
+			}
+		case "handler_response":
+			err := mapstructure.Decode(evtField.Value, &d.Handler)
+			if err != nil {
+				return events.Deposit{}, err
+			}
+		}
+	}
+	return d, nil
+}
+
+func DecodeEventToRetry(evtFields registry.DecodedFields) (events.Retry, error) {
+	var er events.Retry
+
+	for _, evtField := range evtFields {
+		switch evtField.Name {
+		case "deposit_on_block_height":
+			err := mapstructure.Decode(evtField.Value, &er.DepositOnBlockHeight)
+			if err != nil {
+				return events.Retry{}, err
+			}
+		case "dest_domain_id":
+			err := mapstructure.Decode(evtField.Value, &er.DestDomainID)
+			if err != nil {
+				return events.Retry{}, err
+			}
+		}
+	}
+
+	return er, nil
+}
+
 type DepositHandler interface {
 	HandleDeposit(sourceID uint8, destID types.U8, nonce types.U64, resourceID types.Bytes32, calldata []byte, transferType types.U8) (*message.Message, error)
 }
@@ -70,9 +132,7 @@ func (eh *FungibleTransferEventHandler) HandleEvents(evts []*parser.Event, msgCh
 						log.Error().Msgf("panic occured while handling deposit %+v", evt)
 					}
 				}()
-
-				var d events.Deposit
-				err := mapstructure.Decode(evt.Fields, &d)
+				d, err := DecodeEventToDeposit(evt.Fields)
 				if err != nil {
 					log.Error().Err(err).Msgf("%v", err)
 					return
@@ -135,8 +195,7 @@ func (rh *RetryEventHandler) HandleEvents(evts []*parser.Event, msgChan chan []*
 						log.Error().Msgf("panic occured while handling retry event %+v because %s", evt, r)
 					}
 				}()
-				var er events.Retry
-				err = mapstructure.Decode(evt.Fields, &er)
+				er, err := DecodeEventToRetry(evt.Fields)
 				if err != nil {
 					return err
 				}
@@ -158,8 +217,7 @@ func (rh *RetryEventHandler) HandleEvents(evts []*parser.Event, msgChan chan []*
 
 				for _, event := range bEvts {
 					if event.Name == events.DepositEvent {
-						var d events.Deposit
-						err = mapstructure.Decode(event.Fields, &d)
+						d, err := DecodeEventToDeposit(event.Fields)
 						if err != nil {
 							return err
 						}