querier.go

package executor

import (
	"strconv"

	"github.com/gofiber/fiber/v2"
	"github.com/initia-labs/opinit-bots/types"
	"github.com/pkg/errors"
	"go.uber.org/zap"
)

func (ex *Executor) RegisterQuerier(ctx types.Context) {
	ex.server.RegisterQuerier("/withdrawal/:sequence", func(c *fiber.Ctx) error {
		sequenceStr := c.Params("sequence")
		if sequenceStr == "" {
			return errors.New("sequence is required")
		}
		sequence, err := strconv.ParseUint(sequenceStr, 10, 64)
		if err != nil {
			return errors.Wrap(err, "failed to parse sequence")
		}
		res, err := ex.child.QueryWithdrawal(sequence)
		if err != nil {
			ctx.Logger().Error("failed to query withdrawal", zap.Error(err))
			return errors.New("failed to query withdrawal")
		}
		return c.JSON(res)
	})

	ex.server.RegisterQuerier("/withdrawals/:address", func(c *fiber.Ctx) error {
		address := c.Params("address")
		if address == "" {
			return errors.New("address is required")
		}

		offset := c.QueryInt("offset", 0)
		uoffset, err := types.SafeInt64ToUint64(int64(offset))
		if err != nil {
			return errors.Wrap(err, "failed to convert offset")
		}

		limit := c.QueryInt("limit", 10)
		if limit > 100 {
			limit = 100
		}

		ulimit, err := types.SafeInt64ToUint64(int64(limit))
		if err != nil {
			return errors.Wrap(err, "failed to convert limit")
		}

		descOrder := true
		orderStr := c.Query("order", "desc")
		if orderStr == "asc" {
			descOrder = false
		}
		res, err := ex.child.QueryWithdrawals(address, uoffset, ulimit, descOrder)
		if err != nil {
			ctx.Logger().Error("failed to query withdrawals", zap.Error(err))
			return errors.New("failed to query withdrawals")
		}
		return c.JSON(res)
	})

	ex.server.RegisterQuerier("/status", func(c *fiber.Ctx) error {
		status, err := ex.GetStatus()
		if err != nil {
			ctx.Logger().Error("failed to query status", zap.Error(err))
			return errors.New("failed to query status")
		}
		return c.JSON(status)
	})
	ex.server.RegisterQuerier("/syncing", func(c *fiber.Ctx) error {
		status, err := ex.GetStatus()
		if err != nil {
			ctx.Logger().Error("failed to query status", zap.Error(err))
			return errors.New("failed to query status")
		}
		hostSync := status.Host.Node.Syncing != nil && *status.Host.Node.Syncing
		childSync := status.Child.Node.Syncing != nil && *status.Child.Node.Syncing
		batchSync := status.BatchSubmitter.Node.Syncing != nil && *status.BatchSubmitter.Node.Syncing
		return c.JSON(hostSync || childSync || batchSync)
	})
}