feat: refactor

.golangci.yml

@@ -5,7 +5,7 @@ linters:
     - dogsled
     - dupl
     - errcheck
-    - exportloopref
+    - copyloopvar
     - goconst
     - gofmt
     - goimports
@@ -23,12 +23,12 @@ linters:
     - typecheck
     - unconvert
     - unused
-
 issues:
   exclude-rules:
     - path: _test\.go
       linters:
         - gosec
+        - unused
     - linters:
         - stylecheck
       text: "ST1003:"

bot/bot.go

@@ -3,18 +3,16 @@ package bot
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"io"
 	"os"
 
-	"go.uber.org/zap"
-
 	bottypes "github.com/initia-labs/opinit-bots/bot/types"
 	"github.com/initia-labs/opinit-bots/challenger"
 	challengertypes "github.com/initia-labs/opinit-bots/challenger/types"
-	"github.com/initia-labs/opinit-bots/db"
 	"github.com/initia-labs/opinit-bots/executor"
 	executortypes "github.com/initia-labs/opinit-bots/executor/types"
+	"github.com/initia-labs/opinit-bots/server"
+	"github.com/initia-labs/opinit-bots/types"
 )
 
 func LoadJsonConfig(path string, config bottypes.Config) error {
@@ -35,36 +33,29 @@ func LoadJsonConfig(path string, config bottypes.Config) error {
 	return nil
 }
 
-func NewBot(botType bottypes.BotType, logger *zap.Logger, homePath string, configPath string) (bottypes.Bot, error) {
+func NewBot(botType bottypes.BotType, db types.DB, configPath string) (bottypes.Bot, error) {
 	err := botType.Validate()
 	if err != nil {
 		return nil, err
 	}
 
-	db, err := db.NewDB(GetDBPath(homePath, botType))
-	if err != nil {
-		return nil, err
-	}
-
 	switch botType {
 	case bottypes.BotTypeExecutor:
 		cfg := &executortypes.Config{}
 		err := LoadJsonConfig(configPath, cfg)
 		if err != nil {
 			return nil, err
 		}
-		return executor.NewExecutor(cfg, db, logger.Named("executor"), homePath), nil
+		server := server.NewServer(cfg.Server)
+		return executor.NewExecutor(cfg, db, server), nil
 	case bottypes.BotTypeChallenger:
 		cfg := &challengertypes.Config{}
 		err := LoadJsonConfig(configPath, cfg)
 		if err != nil {
 			return nil, err
 		}
-		return challenger.NewChallenger(cfg, db, logger.Named("challenger"), homePath), nil
+		server := server.NewServer(cfg.Server)
+		return challenger.NewChallenger(cfg, db, server), nil
 	}
 	return nil, errors.New("not providing bot name")
 }
-
-func GetDBPath(homePath string, botName bottypes.BotType) string {
-	return fmt.Sprintf(homePath+"/%s.db", botName)
-}

bot/types/bot.go

@@ -1,11 +1,10 @@
 package types
 
 import (
-	"context"
+	"github.com/initia-labs/opinit-bots/types"
 )
 
 type Bot interface {
-	Initialize(context.Context) error
-	Start(context.Context) error
-	Close()
+	Initialize(types.Context) error
+	Start(types.Context) error
 }

challenger/challenger.go

@@ -1,15 +1,14 @@
 package challenger
 
 import (
-	"context"
-	"strconv"
 	"sync"
 	"time"
 
 	"github.com/pkg/errors"
 
 	"github.com/gofiber/fiber/v2"
 	"github.com/initia-labs/opinit-bots/challenger/child"
+	challengerdb "github.com/initia-labs/opinit-bots/challenger/db"
 	"github.com/initia-labs/opinit-bots/challenger/host"
 	"github.com/initia-labs/opinit-bots/server"
 
@@ -32,9 +31,6 @@ type Challenger struct {
 	cfg    *challengertypes.Config
 	db     types.DB
 	server *server.Server
-	logger *zap.Logger
-
-	homePath string
 
 	challengeCh        chan challengertypes.Challenge
 	challengeChStopped chan struct{}
@@ -44,9 +40,11 @@ type Challenger struct {
 	// status info
 	latestChallengesMu *sync.Mutex
 	latestChallenges   []challengertypes.Challenge
+
+	stage types.CommitDB
 }
 
-func NewChallenger(cfg *challengertypes.Config, db types.DB, logger *zap.Logger, homePath string) *Challenger {
+func NewChallenger(cfg *challengertypes.Config, db types.DB, sv *server.Server) *Challenger {
 	err := cfg.Validate()
 	if err != nil {
 		panic(err)
@@ -55,22 +53,17 @@ func NewChallenger(cfg *challengertypes.Config, db types.DB, logger *zap.Logger,
 	challengeCh := make(chan challengertypes.Challenge)
 	return &Challenger{
 		host: host.NewHostV1(
-			cfg.L1NodeConfig(homePath),
+			cfg.L1NodeConfig(),
 			db.WithPrefix([]byte(types.HostName)),
-			logger.Named(types.HostName),
 		),
 		child: child.NewChildV1(
-			cfg.L2NodeConfig(homePath),
+			cfg.L2NodeConfig(),
 			db.WithPrefix([]byte(types.ChildName)),
-			logger.Named(types.ChildName),
 		),
 
 		cfg:    cfg,
 		db:     db,
-		server: server.NewServer(cfg.Server),
-		logger: logger,
-
-		homePath: homePath,
+		server: sv,
 
 		challengeCh:        challengeCh,
 		challengeChStopped: make(chan struct{}),
@@ -79,10 +72,12 @@ func NewChallenger(cfg *challengertypes.Config, db types.DB, logger *zap.Logger,
 
 		latestChallengesMu: &sync.Mutex{},
 		latestChallenges:   make([]challengertypes.Challenge, 0),
+
+		stage: db.NewStage(),
 	}
 }
 
-func (c *Challenger) Initialize(ctx context.Context) error {
+func (c *Challenger) Initialize(ctx types.Context) error {
 	childBridgeInfo, err := c.child.QueryBridgeInfo(ctx)
 	if err != nil {
 		return err
@@ -96,7 +91,7 @@ func (c *Challenger) Initialize(ctx context.Context) error {
 		return err
 	}
 
-	c.logger.Info(
+	ctx.Logger().Info(
 		"bridge info",
 		zap.Uint64("id", bridgeInfo.BridgeId),
 		zap.Duration("submission_interval", bridgeInfo.BridgeConfig.SubmissionInterval),
@@ -128,64 +123,57 @@ func (c *Challenger) Initialize(ctx context.Context) error {
 	if !initialBlockTime.IsZero() {
 		// The db state is reset to a specific height, so we also
 		// need to delete future challenges which are not applicable anymore.
-		err := c.DeleteFutureChallenges(initialBlockTime)
+		err := challengerdb.DeleteFutureChallenges(c.db, initialBlockTime)
 		if err != nil {
 			return err
 		}
 	}
 
 	c.RegisterQuerier()
 
-	c.pendingChallenges, err = c.loadPendingChallenges()
+	c.pendingChallenges, err = challengerdb.LoadPendingChallenges(c.db)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to load pending challenges")
 	}
 
-	c.latestChallenges, err = c.loadChallenges()
+	c.latestChallenges, err = challengerdb.LoadChallenges(c.db)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to load challenges")
 	}
 
 	return nil
 }
 
-func (c *Challenger) Start(ctx context.Context) error {
-	defer c.Close()
-
-	errGrp := types.ErrGrp(ctx)
-	errGrp.Go(func() (err error) {
+func (c *Challenger) Start(ctx types.Context) error {
+	ctx.ErrGrp().Go(func() (err error) {
 		<-ctx.Done()
 		return c.server.Shutdown()
 	})
 
-	errGrp.Go(func() (err error) {
+	ctx.ErrGrp().Go(func() (err error) {
 		defer func() {
-			c.logger.Info("api server stopped")
+			ctx.Logger().Info("api server stopped")
 		}()
 		return c.server.Start()
 	})
 
-	errGrp.Go(func() error {
+	ctx.ErrGrp().Go(func() error {
 		for _, ch := range c.pendingChallenges {
 			c.challengeCh <- ch
 		}
 		return nil
 	})
 
-	errGrp.Go(func() (err error) {
+	ctx.ErrGrp().Go(func() (err error) {
 		defer func() {
-			c.logger.Info("challenge handler stopped")
+			ctx.Logger().Info("challenge handler stopped")
 		}()
 		return c.challengeHandler(ctx)
 	})
 
 	c.host.Start(ctx)
 	c.child.Start(ctx)
-	return errGrp.Wait()
-}
-
-func (c *Challenger) Close() {
-	c.db.Close()
+	return ctx.ErrGrp().Wait()
 }
 
 func (c *Challenger) RegisterQuerier() {
@@ -197,16 +185,25 @@ func (c *Challenger) RegisterQuerier() {
 
 		return ctx.JSON(status)
 	})
-	c.server.RegisterQuerier("/challenges/:page", func(ctx *fiber.Ctx) error {
-		pageStr := ctx.Params("page")
-		if pageStr == "" {
-			pageStr = "1"
+	c.server.RegisterQuerier("/challenges", func(ctx *fiber.Ctx) error {
+		next := ctx.Query("next", "")
+		limit := ctx.QueryInt("limit", 10)
+		if limit > 100 {
+			limit = 100
 		}
-		page, err := strconv.ParseUint(pageStr, 10, 64)
+
+		ulimit, err := types.SafeInt64ToUint64(int64(limit))
 		if err != nil {
-			return err
+			return errors.Wrap(err, "failed to convert limit")
 		}
-		res, err := c.QueryChallenges(page)
+
+		descOrder := true
+		orderStr := ctx.Query("order", "desc")
+		if orderStr == "asc" {
+			descOrder = false
+		}
+
+		res, err := c.QueryChallenges(next, ulimit, descOrder)
 		if err != nil {
 			return err
 		}
@@ -230,7 +227,11 @@ func (c *Challenger) RegisterQuerier() {
 	})
 }
 
-func (c *Challenger) getProcessedHeights(ctx context.Context, bridgeId uint64) (l1ProcessedHeight int64, l2ProcessedHeight int64, processedOutputIndex uint64, err error) {
+func (c *Challenger) getProcessedHeights(ctx types.Context, bridgeId uint64) (l1ProcessedHeight int64, l2ProcessedHeight int64, processedOutputIndex uint64, err error) {
+	if c.host.Node().GetSyncedHeight() != 0 && c.child.Node().GetSyncedHeight() != 0 {
+		return 0, 0, 0, nil
+	}
+
 	var outputL1BlockNumber int64
 	// get the last submitted output height before the start height from the host
 	if c.cfg.L2StartHeight != 0 {
@@ -284,3 +285,7 @@ func (c *Challenger) getProcessedHeights(ctx context.Context, bridgeId uint64) (
 
 	return l1ProcessedHeight, l2ProcessedHeight, processedOutputIndex, err
 }
+
+func (c Challenger) DB() types.DB {
+	return c.db
+}