feat: use GetMissingHeights() in enqueueMissingBlocks() & in `par…

…se blocks` cmd (#89)

## Description


following the request from @maiquanghiep : https://forbole.atlassian.net/browse/BDU-489?focusedCommentId=17477

## Checklist
- [x] Targeted PR against correct branch.
- [x] Linked to Github issue with discussion and accepted design OR link to spec that describes this work.
- [ ] Wrote unit tests.  
- [x] Re-reviewed `Files changed` in the Github PR explorer.

CHANGELOG.md

@@ -1,3 +1,7 @@
+## Unreleased
+### Changes
+- ([\#74](https://github.com/forbole/juno/pull/74)) Applied `GetMissingHeights()` in `enqueueMissingBlocks()` & in `parse blocks missing` cmd
+
 ## v4.0.0
 ### Changes
 - Updated cosmos/cosmos-sdk to `v0.45.8`

cmd/parse/blocks/blocks.go

@@ -24,7 +24,7 @@ const (
 func newAllCmd(parseConfig *parsecmdtypes.Config) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "all",
-		Short: "Fix missing blocks and transactions in database",
+		Short: "Reparse blocks and transactions ranged from the given start height to the given end height",
 		Long: fmt.Sprintf(`Refetch all the blocks in the specified range and stores them inside the database. 
 You can specify a custom blocks range by using the %s and %s flags. 
 By default, all the blocks fetched from the node will not be stored inside the database if they are already present. 

cmd/parse/blocks/cmd.go

@@ -15,6 +15,7 @@ func NewBlocksCmd(parseConfig *parsecmdtypes.Config) *cobra.Command {
 
 	cmd.AddCommand(
 		newAllCmd(parseConfig),
+		newMissingCmd(parseConfig),
 	)
 
 	return cmd

cmd/parse/blocks/missing.go

@@ -0,0 +1,52 @@
+package blocks
+
+import (
+	"fmt"
+	"strconv"
+
+	parsecmdtypes "github.com/forbole/juno/v4/cmd/parse/types"
+
+	"github.com/spf13/cobra"
+
+	"github.com/forbole/juno/v4/parser"
+	"github.com/forbole/juno/v4/types/config"
+)
+
+// newMissingCmd returns a Cobra command that allows to fix missing blocks in database
+func newMissingCmd(parseConfig *parsecmdtypes.Config) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "missing [start height]",
+		Short: "Refetch all the missing heights in the database starting from the given start height",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			startHeight, err := strconv.ParseInt(args[0], 10, 64)
+			if err != nil {
+				return fmt.Errorf("make sure the given start height is a positive integer")
+			}
+
+			parseCtx, err := parsecmdtypes.GetParserContext(config.Cfg, parseConfig)
+			if err != nil {
+				return err
+			}
+
+			workerCtx := parser.NewContext(parseCtx.EncodingConfig, parseCtx.Node, parseCtx.Database, parseCtx.Logger, parseCtx.Modules)
+			worker := parser.NewWorker(workerCtx, nil, 0)
+
+			dbLastHeight, err := parseCtx.Database.GetLastBlockHeight()
+			if err != nil {
+				return fmt.Errorf("error while getting DB last block height: %s", err)
+			}
+
+			for _, k := range parseCtx.Database.GetMissingHeights(startHeight, dbLastHeight) {
+				err = worker.Process(k)
+				if err != nil {
+					return fmt.Errorf("error while re-fetching block %d: %s", k, err)
+				}
+			}
+
+			return nil
+		},
+	}
+
+	return cmd
+}

cmd/start/cmd.go

@@ -157,7 +157,7 @@ func enqueueMissingBlocks(exportQueue types.HeightQueue, ctx *parser.Context) {
 		}
 	} else {
 		ctx.Logger.Info("syncing missing blocks...", "latest_block_height", latestBlockHeight)
-		for i := startHeight; i <= latestBlockHeight; i++ {
+		for _, i := range ctx.Database.GetMissingHeights(startHeight, latestBlockHeight) {
 			ctx.Logger.Debug("enqueueing missing block", "height", i)
 			exportQueue <- i
 		}

database/database.go

@@ -20,6 +20,9 @@ type Database interface {
 	// An error is returned if the operation fails.
 	GetLastBlockHeight() (int64, error)
 
+	// GetMissingHeights returns a slice of missing block heights between startHeight and endHeight
+	GetMissingHeights(startHeight, endHeight int64) []int64
+
 	// SaveBlock will be called when a new block is parsed, passing the block itself
 	// and the transactions contained inside that block.
 	// An error is returned if the operation fails.

database/postgresql/postgresql.go

@@ -96,6 +96,22 @@ func (db *Database) GetLastBlockHeight() (int64, error) {
 	return height, nil
 }
 
+// GetMissingHeights returns a slice of missing block heights between startHeight and endHeight
+func (db *Database) GetMissingHeights(startHeight, endHeight int64) []int64 {
+	var result []int64
+	stmt := `SELECT generate_series($1::int,$2::int) EXCEPT SELECT height FROM block ORDER BY 1;`
+	err := db.SQL.Select(&result, stmt, startHeight, endHeight)
+	if err != nil {
+		return nil
+	}
+
+	if len(result) == 0 {
+		return nil
+	}
+
+	return result
+}
+
 // SaveBlock implements database.Database
 func (db *Database) SaveBlock(block *types.Block) error {
 	sqlStatement := `