feat: allow 'latest' search for slots, blocks & epochs

Author: LuccaBitfly

backend/pkg/api/data_access/header.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"fmt"
 
+	"github.com/doug-martin/goqu/v9"
 	t "github.com/gobitfly/beaconchain/pkg/api/types"
 	"github.com/gobitfly/beaconchain/pkg/commons/cache"
 	"github.com/gobitfly/beaconchain/pkg/commons/log"
@@ -23,8 +24,19 @@ func (d *DataAccessService) GetLatestFinalizedEpoch(ctx context.Context) (uint64
 }
 
 func (d *DataAccessService) GetLatestBlock(ctx context.Context) (uint64, error) {
-	// @DATA-ACCESS implement
-	return d.dummy.GetLatestBlock(ctx)
+	ds := goqu.Dialect("postgres").
+		From(goqu.T("blocks")).
+		Select(goqu.MAX(goqu.C("exec_block_number")))
+
+	res, err := runQuery[uint64](ctx, d.readerDb, ds)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			log.Warnf("no EL block found%d")
+			return 0, nil
+		}
+		return 0, fmt.Errorf("failed to get latest existing block height: %w", err)
+	}
+	return res, nil
 }
 
 func (d *DataAccessService) GetBlockHeightAt(ctx context.Context, slot uint64) (uint64, error) {

backend/pkg/api/handlers/search.go

@@ -127,12 +127,12 @@ func init() {
 			handlerFunc:  handleSearchTransaction,
 		},
 		blockKey: {
-			regex:        types.ReInteger,
+			regex:        types.ReIntegerOrLatest,
 			responseType: string(blockKey),
 			handlerFunc:  handleSearchBlock,
 		},
 		slotKey: {
-			regex:        types.ReInteger,
+			regex:        types.ReIntegerOrLatest,
 			responseType: "slot",
 			handlerFunc:  handleSearchSlot,
 		},
@@ -147,7 +147,7 @@ func init() {
 			handlerFunc:  handleSearchSlotByStateRoot,
 		},
 		epochKey: {
-			regex:        types.ReInteger,
+			regex:        types.ReIntegerOrLatest,
 			responseType: string(epochKey),
 			handlerFunc:  handleSearchEpoch,
 		},
@@ -376,6 +376,13 @@ func handleSearchTransaction(ctx context.Context, h *HandlerService, input strin
 }
 
 func handleSearchBlock(ctx context.Context, h *HandlerService, input string, chainId uint64) (*types.SearchResult, error) {
+	if input == "latest" {
+		result, err := h.daService.GetLatestBlock(ctx)
+		if err != nil {
+			return nil, err
+		}
+		return asSearchResult(blockKey, chainId, &types.SearchBlock{BlockNumber: result}, nil)
+	}
 	blockNumber, err := strconv.ParseUint(input, 10, 64)
 	if err != nil {
 		return nil, err
@@ -385,6 +392,13 @@ func handleSearchBlock(ctx context.Context, h *HandlerService, input string, cha
 }
 
 func handleSearchSlot(ctx context.Context, h *HandlerService, input string, chainId uint64) (*types.SearchResult, error) {
+	if input == "latest" {
+		result, err := h.daService.GetLatestSlot(ctx)
+		if err != nil {
+			return nil, err
+		}
+		return asSearchResult(slotKey, chainId, &types.SearchSlot{Slot: result}, nil)
+	}
 	slot, err := strconv.ParseUint(input, 10, 64)
 	if err != nil {
 		return nil, err
@@ -412,6 +426,14 @@ func handleSearchSlotByStateRoot(ctx context.Context, h *HandlerService, input s
 }
 
 func handleSearchEpoch(ctx context.Context, h *HandlerService, input string, chainId uint64) (*types.SearchResult, error) {
+	if input == "latest" {
+		result, err := h.daService.GetLatestSlot(ctx)
+		if err != nil {
+			return nil, err
+		}
+		epoch := result / h.cfg.ClConfig.SlotsPerEpoch
+		return asSearchResult(epochKey, chainId, &types.SearchEpoch{Epoch: epoch}, nil)
+	}
 	epoch, err := strconv.ParseUint(input, 10, 64)
 	if err != nil {
 		return nil, err

backend/pkg/api/types/regexes.go

@@ -5,6 +5,7 @@ import "regexp"
 var (
 	ReName                         = regexp.MustCompile(`^[a-zA-Z0-9_\-.\ ]*$`)
 	ReInteger                      = regexp.MustCompile(`^[0-9]+$`)
+	ReIntegerOrLatest              = regexp.MustCompile(`^(latest|[0-9]+)$`)
 	ReValidatorDashboardPublicId   = regexp.MustCompile(`^v-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`)
 	ReValidatorPublicKeyWithPrefix = regexp.MustCompile(`^0x[0-9a-fA-F]{96}$`)
 	ReValidatorPublicKey           = regexp.MustCompile(`^(0x)?[0-9a-fA-F]{96}$`)