github.com/diadata-org/diadata@v1.4.593/pkg/dia/helpers/substrate-helper/gsrpc/registry/REGISTRY.md (about)

     1  # GSRPC Registry
     2  The GSRPC Registry can parse target metadata information into an in-memory registry of complex structures. 
     3  
     4  By leveraging the on-chain metadata, GSRPC is more robust to changes on types, allowing clients to only keep updated the types that are relevant to their business operation.
     5  
     6  This registry can be used afterwards to decode data read from live chains (events & extrinsics).
     7  
     8  ## How to parse events and their fields
     9  First we instantiate the API with the client node and open a connection: 
    10  ```go
    11  testURL := "wss://fullnode.parachain.centrifuge.io" // Your endpoint
    12  api, err := gsrpc.NewSubstrateAPI(testURL)
    13  
    14  if err != nil {
    15      log.Printf("Couldn't connect to '%s': %s\n", testURL, err)
    16      return
    17  }
    18  ```
    19  Then we instantiate the Event Retriever logic which internally creates a new EventRegistry reading from the target metadata of the connected chain. We pass as well the state RPC so the storage API is available: 
    20  ```go
    21  retriever, err := NewDefaultEventRetriever(state.NewEventProvider(api.RPC.State), api.RPC.State)
    22  
    23  if err != nil {
    24      log.Printf("Couldn't create event retriever: %s", err)
    25      return
    26  }
    27  ```
    28  At this point what we need is a block hash to read the events within. In this example we get the latest block header and the correspondent block hash out of the block number:
    29  ```go
    30  header, err := api.RPC.Chain.GetHeaderLatest()
    31  
    32  if err != nil {
    33      log.Printf("Couldn't get latest header for '%s': %s\n", testURL, err)
    34      return
    35  }
    36  
    37  blockHash, err := api.RPC.Chain.GetBlockHash(uint64(header.Number))
    38  
    39  if err != nil {
    40      log.Printf("Couldn't retrieve blockHash for '%s', block number %d: %s\n", testURL, header.Number, err)
    41      return
    42  }
    43  ```
    44  Finally, we just use the retriever function to read all the events in that block based on the chain metadata loaded in the event registry: 
    45  ```go
    46  events, err := retriever.GetEvents(blockHash)
    47  
    48  if err != nil {
    49      log.Printf("Couldn't retrieve events for '%s', block number %d: %s\n", testURL, header.Number, err)
    50      return
    51  }
    52  
    53  log.Printf("Found %d events for '%s', at block number %d.\n", len(events), testURL, header.Number)
    54  
    55  // Example of the events returned structure
    56  for _, event := range events {
    57      log.Printf("Event ID: %x \n", event.EventID)
    58      log.Printf("Event Name: %s \n", event.Name)
    59      log.Printf("Event Fields Count: %d \n", len(event.Fields))
    60      for k, v := range event.Fields {
    61          log.Printf("Field Name: %s \n", k)
    62          log.Printf("Field Type: %v \n", reflect.TypeOf(v))
    63          log.Printf("Field Value: %v \n", v)
    64      }
    65  }
    66  
    67  ```
    68  
    69  ## Extended Usage
    70  Since docs get outdated fairly quick, here are links to tests that will always be up-to-date.
    71  ### Populate Call, Error & Events Registries, Extrinsic Decoder
    72  [Factory tests](factory_test.go)
    73  [Decoder tests](decoder_test.go)
    74  
    75  ### Event retriever
    76  [TestLive_EventRetriever_GetEvents](retriever/event_retriever_live_test.go)
    77  
    78  ### Extrinsic retriever
    79  [TestLive_ExtrinsicRetriever_GetExtrinsics](retriever/extrinsic_retriever_live_test.go)