events: Add event parsing test script, provide more details in error …

…messages

events/parser.go

@@ -32,26 +32,26 @@ func ParseEvents(meta *types.Metadata, sd *types.StorageDataRaw) ([]*Event, erro
 		var phase types.Phase
 
 		if err := decoder.Decode(&phase); err != nil {
-			return nil, fmt.Errorf("unable to decode Phase for event #%v: %v", i, err)
+			return nil, fmt.Errorf("couldn't decode Phase for event #%v: %w", i, err)
 		}
 
 		// decode EventID
 		var eventID types.EventID
 
 		if err := decoder.Decode(&eventID); err != nil {
-			return nil, fmt.Errorf("unable to decode EventID for event #%v: %v", i, err)
+			return nil, fmt.Errorf("couldn't decode EventID for event #%v: %w", i, err)
 		}
 
 		// ask metadata for method & event name for event
 		event, err := parseEvent(meta, decoder, eventID)
 		if err != nil {
-			return nil, fmt.Errorf("unable to find event with EventID %v in metadata for event #%v: %s", eventID, i, err)
+			return nil, fmt.Errorf("couldn't parse event #%v with EventID %v: %w", i, eventID, err)
 		}
 
 		var topics []types.Hash
 
 		if err := decoder.Decode(&topics); err != nil {
-			return nil, fmt.Errorf("unable to decode topics for event #%v: %v", i, err)
+			return nil, fmt.Errorf("unable to decode topics for event #%v: %w", i, err)
 		}
 
 		event.Phase = &phase
@@ -94,16 +94,14 @@ func parseEvent(meta *types.Metadata, decoder *scale.Decoder, eventID types.Even
 
 			eventName := fmt.Sprintf("%s.%s", mod.Name, variant.Name)
 
-			fmt.Println("Parsing event", eventName)
-
 			if len(variant.Fields) == 0 {
 				return &Event{eventName, nil, nil, nil}, nil
 			}
 
 			eventFields, err := parseFields(meta, decoder, variant.Fields)
 
 			if err != nil {
-				return nil, fmt.Errorf("couldn't parse event fields: %w", err)
+				return nil, fmt.Errorf("couldn't parse fields for event '%s': %w", eventName, err)
 			}
 
 			return &Event{eventName, eventFields, nil, nil}, nil

events/test/event_parsing.go

@@ -0,0 +1,94 @@
+// go:build ignore
+
+package main
+
+import (
+	"log"
+	"sync"
+
+	gsrpc "github.com/centrifuge/go-substrate-rpc-client/v4"
+	"github.com/centrifuge/go-substrate-rpc-client/v4/events"
+	"github.com/centrifuge/go-substrate-rpc-client/v4/types"
+)
+
+var (
+	testURLs = []string{
+		"wss://fullnode.parachain.centrifuge.io",
+		"wss://rpc.polkadot.io",
+		"wss://statemint-rpc.polkadot.io",
+		"wss://acala-rpc-0.aca-api.network",
+		"wss://wss.api.moonbeam.network",
+	}
+)
+
+func main() {
+	var wg sync.WaitGroup
+
+	for _, testURL := range testURLs {
+		testURL := testURL
+
+		wg.Add(1)
+
+		go func() {
+			defer wg.Done()
+
+			api, err := gsrpc.NewSubstrateAPI(testURL)
+
+			if err != nil {
+				log.Printf("Couldn't connect to '%s': %s\n", testURL, err)
+				return
+			}
+
+			meta, err := api.RPC.State.GetMetadataLatest()
+
+			if err != nil {
+				log.Printf("Couldn't retrieve metadata for '%s': %s\n", testURL, err)
+				return
+			}
+
+			blockHash, err := api.RPC.Chain.GetBlockHashLatest()
+
+			if err != nil {
+				log.Printf("Couldn't get latest block hash for '%s': %s\n", testURL, err)
+				return
+			}
+
+			for {
+				block, err := api.RPC.Chain.GetBlock(blockHash)
+
+				if err != nil {
+					log.Printf("Couldn't get block for '%s': %s\n", testURL, err)
+					return
+				}
+
+				if _, err = parseEvents(api, meta, &blockHash); err != nil {
+					log.Printf("Couldn't parse events for '%s', block number %d: %s\n", testURL, block.Block.Header.Number, err)
+				}
+
+				blockHash = block.Block.Header.ParentHash
+			}
+		}()
+	}
+
+	wg.Wait()
+}
+
+func parseEvents(
+	api *gsrpc.SubstrateAPI,
+	meta *types.Metadata,
+	blockHash *types.Hash,
+) ([]*events.Event, error) {
+	key, err := types.CreateStorageKey(meta, "System", "Events", nil)
+
+	if err != nil {
+		return nil, err
+	}
+
+	sd, err := api.RPC.State.GetStorageRaw(key, *blockHash)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return events.ParseEvents(meta, sd)
+}