feat: index genesis transactions

client/http.go

@@ -53,6 +53,15 @@ func (c *Client) GetBlock(blockNum uint64) (*core_types.ResultBlock, error) {
 	return block, nil
 }
 
+func (c *Client) GetGenesis() (*core_types.ResultGenesis, error) {
+	genesis, err := c.client.Genesis()
+	if err != nil {
+		return nil, fmt.Errorf("unable to get genesis block, %w", err)
+	}
+
+	return genesis, nil
+}
+
 func (c *Client) GetBlockResults(blockNum uint64) (*core_types.ResultBlockResults, error) {
 	bn := int64(blockNum)
 

fetch/fetch.go

@@ -11,6 +11,9 @@ import (
 	queue "github.com/madz-lab/insertion-queue"
 	"go.uber.org/zap"
 
+	"github.com/gnolang/gno/gno.land/pkg/gnoland"
+	"github.com/gnolang/gno/tm2/pkg/amino"
+	bft_types "github.com/gnolang/gno/tm2/pkg/bft/types"
 	"github.com/gnolang/tx-indexer/storage"
 	storageErrors "github.com/gnolang/tx-indexer/storage/errors"
 	"github.com/gnolang/tx-indexer/types"
@@ -21,6 +24,8 @@ const (
 	DefaultMaxChunkSize = 100
 )
 
+var errInvalidGenesisState = errors.New("invalid genesis state")
+
 // Fetcher is an instance of the block indexer
 // fetcher
 type Fetcher struct {
@@ -67,9 +72,71 @@ func New(
 	return f
 }
 
+func (f *Fetcher) fetchGenesisData() error {
+	_, err := f.storage.GetLatestHeight()
+	// Possible cases:
+	// - err is ErrNotFound: the storage is empty, we execute the rest of the routine and fetch+write genesis data
+	// - err is nil: the storage has a latest height, this means at least the genesis data has been written,
+	//   or some blocks past it, we do nothing and return nil
+	// - err is something else: there has been a storage error, we do nothing and return this error
+	if !errors.Is(err, storageErrors.ErrNotFound) {
+		return err
+	}
+
+	f.logger.Info("Fetching genesis")
+
+	block, err := getGenesisBlock(f.client)
+	if err != nil {
+		return fmt.Errorf("failed to fetch genesis block: %w", err)
+	}
+
+	results, err := f.client.GetBlockResults(0)
+	if err != nil {
+		return fmt.Errorf("failed to fetch genesis results: %w", err)
+	}
+
+	if results.Results == nil {
+		return errors.New("nil results")
+	}
+
+	txResults := make([]*bft_types.TxResult, len(block.Txs))
+
+	for txIndex, tx := range block.Txs {
+		result := &bft_types.TxResult{
+			Height:   0,
+			Index:    uint32(txIndex),
+			Tx:       tx,
+			Response: results.Results.DeliverTxs[txIndex],
+		}
+
+		txResults[txIndex] = result
+	}
+
+	s := &slot{
+		chunk: &chunk{
+			blocks:  []*bft_types.Block{block},
+			results: [][]*bft_types.TxResult{txResults},
+		},
+		chunkRange: chunkRange{
+			from: 0,
+			to:   0,
+		},
+	}
+
+	return f.writeSlot(s)
+}
+
 // FetchChainData starts the fetching process that indexes
 // blockchain data
 func (f *Fetcher) FetchChainData(ctx context.Context) error {
+	// Attempt to fetch the genesis data
+	if err := f.fetchGenesisData(); err != nil {
+		// We treat this error as soft, to ease migration, since
+		// some versions of gno networks don't support this.
+		// In the future, we should hard fail if genesis is not fetch-able
+		f.logger.Error("unable to fetch genesis data", zap.Error(err))
+	}
+
 	collectorCh := make(chan *workerResponse, DefaultMaxSlots)
 
 	// attemptRangeFetch compares local and remote state
@@ -178,68 +245,114 @@ func (f *Fetcher) FetchChainData(ctx context.Context) error {
 				// Pop the next chunk
 				f.chunkBuffer.PopFront()
 
-				wb := f.storage.WriteBatch()
+				if err := f.writeSlot(item); err != nil {
+					return err
+				}
+			}
+		}
+	}
+}
+
+func (f *Fetcher) writeSlot(s *slot) error {
+	wb := f.storage.WriteBatch()
 
-				// Save the fetched data
-				for blockIndex, block := range item.chunk.blocks {
-					if saveErr := wb.SetBlock(block); saveErr != nil {
-						// This is a design choice that really highlights the strain
-						// of keeping legacy testnets running. Current TM2 testnets
-						// have blocks / transactions that are no longer compatible
-						// with latest "master" changes for Amino, so these blocks / txs are ignored,
-						// as opposed to this error being a show-stopper for the fetcher
-						f.logger.Error("unable to save block", zap.String("err", saveErr.Error()))
+	// Save the fetched data
+	for blockIndex, block := range s.chunk.blocks {
+		if saveErr := wb.SetBlock(block); saveErr != nil {
+			// This is a design choice that really highlights the strain
+			// of keeping legacy testnets running. Current TM2 testnets
+			// have blocks / transactions that are no longer compatible
+			// with latest "master" changes for Amino, so these blocks / txs are ignored,
+			// as opposed to this error being a show-stopper for the fetcher
+			f.logger.Error("unable to save block", zap.String("err", saveErr.Error()))
 
-						continue
-					}
+			continue
+		}
 
-					f.logger.Debug("Added block data to batch", zap.Int64("number", block.Height))
+		f.logger.Debug("Added block data to batch", zap.Int64("number", block.Height))
 
-					// Get block results
-					txResults := item.chunk.results[blockIndex]
+		// Get block results
+		txResults := s.chunk.results[blockIndex]
 
-					// Save the fetched transaction results
-					for _, txResult := range txResults {
-						if err := wb.SetTx(txResult); err != nil {
-							f.logger.Error("unable to  save tx", zap.String("err", err.Error()))
+		// Save the fetched transaction results
+		for _, txResult := range txResults {
+			if err := wb.SetTx(txResult); err != nil {
+				f.logger.Error("unable to  save tx", zap.String("err", err.Error()))
 
-							continue
-						}
+				continue
+			}
 
-						f.logger.Debug(
-							"Added tx to batch",
-							zap.String("hash", base64.StdEncoding.EncodeToString(txResult.Tx.Hash())),
-						)
-					}
+			f.logger.Debug(
+				"Added tx to batch",
+				zap.String("hash", base64.StdEncoding.EncodeToString(txResult.Tx.Hash())),
+			)
+		}
 
-					// Alert any listeners of a new saved block
-					event := &types.NewBlock{
-						Block:   block,
-						Results: txResults,
-					}
+		// Alert any listeners of a new saved block
+		event := &types.NewBlock{
+			Block:   block,
+			Results: txResults,
+		}
 
-					f.events.SignalEvent(event)
-				}
+		f.events.SignalEvent(event)
+	}
 
-				f.logger.Info(
-					"Added to batch block and tx data for range",
-					zap.Uint64("from", item.chunkRange.from),
-					zap.Uint64("to", item.chunkRange.to),
-				)
+	f.logger.Info(
+		"Added to batch block and tx data for range",
+		zap.Uint64("from", s.chunkRange.from),
+		zap.Uint64("to", s.chunkRange.to),
+	)
 
-				// Save the latest height data
-				if err := wb.SetLatestHeight(item.chunkRange.to); err != nil {
-					if rErr := wb.Rollback(); rErr != nil {
-						return fmt.Errorf("unable to save latest height info, %w, %w", err, rErr)
-					}
+	// Save the latest height data
+	if err := wb.SetLatestHeight(s.chunkRange.to); err != nil {
+		if rErr := wb.Rollback(); rErr != nil {
+			return fmt.Errorf("unable to save latest height info, %w, %w", err, rErr)
+		}
 
-					return fmt.Errorf("unable to save latest height info, %w", err)
-				}
+		return fmt.Errorf("unable to save latest height info, %w", err)
+	}
 
-				if err := wb.Commit(); err != nil {
-					return fmt.Errorf("error persisting block information into storage, %w", err)
-				}
-			}
+	if err := wb.Commit(); err != nil {
+		return fmt.Errorf("error persisting block information into storage, %w", err)
+	}
+
+	return nil
+}
+
+func getGenesisBlock(client Client) (*bft_types.Block, error) {
+	gblock, err := client.GetGenesis()
+	if err != nil {
+		return nil, fmt.Errorf("unable to get genesis block: %w", err)
+	}
+
+	if gblock.Genesis == nil {
+		return nil, errInvalidGenesisState
+	}
+
+	genesisState, ok := gblock.Genesis.AppState.(gnoland.GnoGenesisState)
+	if !ok {
+		return nil, fmt.Errorf("unknown genesis state kind '%T'", gblock.Genesis.AppState)
+	}
+
+	txs := make([]bft_types.Tx, len(genesisState.Txs))
+	for i, tx := range genesisState.Txs {
+		txs[i], err = amino.MarshalJSON(tx)
+		if err != nil {
+			return nil, fmt.Errorf("unable to marshal genesis tx: %w", err)
 		}
 	}
+
+	block := &bft_types.Block{
+		Header: bft_types.Header{
+			NumTxs:   int64(len(txs)),
+			TotalTxs: int64(len(txs)),
+			Time:     gblock.Genesis.GenesisTime,
+			ChainID:  gblock.Genesis.ChainID,
+		},
+		Data: bft_types.Data{
+			Txs: txs,
+		},
+	}
+
+	return block, nil
 }