WIP3

api/api_test.go

@@ -180,7 +180,7 @@ type testCommon struct {
 	auctionVars      common.AuctionVariables
 	rollupVars       common.RollupVariables
 	wdelayerVars     common.WDelayerVariables
-	nextForgers      []historydb.NextForger
+	nextForgers      []historydb.NextForgerAPI
 }
 
 var tc testCommon
@@ -455,14 +455,14 @@ func TestMain(m *testing.M) {
 	if err = api.h.AddBids(bids); err != nil {
 		panic(err)
 	}
-	bootForger := historydb.NextForger{
+	bootForger := historydb.NextForgerAPI{
 		Coordinator: historydb.CoordinatorAPI{
 			Forger: auctionVars.BootCoordinator,
 			URL:    auctionVars.BootCoordinatorURL,
 		},
 	}
 	// Set next forgers: set all as boot coordinator then replace the non boot coordinators
-	nextForgers := []historydb.NextForger{}
+	nextForgers := []historydb.NextForgerAPI{}
 	var initBlock int64 = 140
 	var deltaBlocks int64 = 40
 	for i := 1; i < int(auctionVars.ClosedAuctionSlots)+2; i++ {

api/state.go

@@ -1,16 +1,123 @@
 package api
 
 import (
+	"database/sql"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/hermeznetwork/hermez-node/common"
+	"github.com/hermeznetwork/hermez-node/db/historydb"
+	"github.com/hermeznetwork/tracerr"
 )
 
 func (a *API) getState(c *gin.Context) {
-	ni, err := a.h.GetNodeInfoAPI()
+	stateAPI, err := a.h.GetStateAPI()
 	if err != nil {
 		retBadReq(err, c)
 		return
 	}
-	c.JSON(http.StatusOK, ni.APIState)
+	c.JSON(http.StatusOK, stateAPI)
+}
+
+type APIStateUpdater struct {
+	hdb    *historydb.HistoryDB
+	state  historydb.StateAPI
+	config historydb.NodeConfig
+	vars   common.SCVariablesPtr
+	consts historydb.Constants
+}
+
+func NewAPIStateUpdater(hdb *historydb.HistoryDB, config *historydb.NodeConfig, vars *common.SCVariables,
+	consts *historydb.Constants) *APIStateUpdater {
+	u := APIStateUpdater{
+		hdb:    hdb,
+		config: *config,
+		consts: *consts,
+	}
+	u.SetSCVars(&common.SCVariablesPtr{&vars.Rollup, &vars.Auction, &vars.WDelayer})
+	return &u
+}
+
+func (u *APIStateUpdater) Store() error {
+	return tracerr.Wrap(u.hdb.SetAPIState(&u.state))
+}
+
+func (u *APIStateUpdater) SetSCVars(vars *common.SCVariablesPtr) {
+	if vars.Rollup != nil {
+		u.vars.Rollup = vars.Rollup
+		rollupVars := historydb.NewRollupVariablesAPI(u.vars.Rollup)
+		u.state.Rollup = *rollupVars
+	}
+	if vars.Auction != nil {
+		u.vars.Auction = vars.Auction
+		auctionVars := historydb.NewAuctionVariablesAPI(u.vars.Auction)
+		u.state.Auction = *auctionVars
+	}
+	if vars.WDelayer != nil {
+		u.vars.WDelayer = vars.WDelayer
+		u.state.WithdrawalDelayer = *u.vars.WDelayer
+	}
+}
+
+func (u *APIStateUpdater) UpdateMetrics() error {
+	if u.state.Network.LastBatch == nil {
+		return nil
+	}
+	lastBatchNum := u.state.Network.LastBatch.BatchNum
+	metrics, err := u.hdb.GetMetricsInternalAPI(lastBatchNum)
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
+	u.state.Metrics = *metrics
+	return nil
+}
+
+func (u *APIStateUpdater) UpdateNetworkInfoBlock(lastEthBlock, lastSyncBlock common.Block) {
+	u.state.Network.LastSyncBlock = lastSyncBlock.Num
+	u.state.Network.LastEthBlock = lastEthBlock.Num
+}
+
+func (u *APIStateUpdater) UpdateNetworkInfo(
+	lastEthBlock, lastSyncBlock common.Block,
+	lastBatchNum common.BatchNum, currentSlot int64,
+) error {
+	// Get last batch in API format
+	lastBatch, err := u.hdb.GetBatchInternalAPI(lastBatchNum)
+	if tracerr.Unwrap(err) == sql.ErrNoRows {
+		lastBatch = nil
+	} else if err != nil {
+		return tracerr.Wrap(err)
+	}
+	// Get next forgers
+	lastClosedSlot := currentSlot + int64(u.state.Auction.ClosedAuctionSlots)
+	nextForgers, err := u.hdb.GetNextForgersInternalAPI(u.vars.Auction, &u.consts.Auction,
+		lastSyncBlock, currentSlot, lastClosedSlot)
+	if tracerr.Unwrap(err) == sql.ErrNoRows {
+		nextForgers = nil
+	} else if err != nil {
+		return tracerr.Wrap(err)
+	}
+
+	bucketUpdates, err := u.hdb.GetBucketUpdatesInternalAPI()
+	if err == sql.ErrNoRows {
+		bucketUpdates = nil
+	} else if err != nil {
+		return tracerr.Wrap(err)
+	}
+	// Update NodeInfo struct
+	for i, bucketParams := range u.state.Rollup.Buckets {
+		for _, bucketUpdate := range bucketUpdates {
+			if bucketUpdate.NumBucket == i {
+				bucketParams.Withdrawals = bucketUpdate.Withdrawals
+				u.state.Rollup.Buckets[i] = bucketParams
+				break
+			}
+		}
+	}
+	u.state.Network.LastSyncBlock = lastSyncBlock.Num
+	u.state.Network.LastEthBlock = lastEthBlock.Num
+	u.state.Network.LastBatch = lastBatch
+	u.state.Network.CurrentSlot = currentSlot
+	u.state.Network.NextForgers = nextForgers
+	return nil
 }

api/state_test.go

@@ -13,7 +13,7 @@ import (
 
 type testStatus struct {
 	Network           testNetwork                   `json:"network"`
-	Metrics           historydb.Metrics             `json:"metrics"`
+	Metrics           historydb.MetricsAPI          `json:"metrics"`
 	Rollup            historydb.RollupVariablesAPI  `json:"rollup"`
 	Auction           historydb.AuctionVariablesAPI `json:"auction"`
 	WithdrawalDelayer common.WDelayerVariables      `json:"withdrawalDelayer"`
@@ -21,11 +21,11 @@ type testStatus struct {
 }
 
 type testNetwork struct {
-	LastEthBlock  int64                  `json:"lastEthereumBlock"`
-	LastSyncBlock int64                  `json:"lastSynchedBlock"`
-	LastBatch     testBatch              `json:"lastBatch"`
-	CurrentSlot   int64                  `json:"currentSlot"`
-	NextForgers   []historydb.NextForger `json:"nextForgers"`
+	LastEthBlock  int64                     `json:"lastEthereumBlock"`
+	LastSyncBlock int64                     `json:"lastSynchedBlock"`
+	LastBatch     testBatch                 `json:"lastBatch"`
+	CurrentSlot   int64                     `json:"currentSlot"`
+	NextForgers   []historydb.NextForgerAPI `json:"nextForgers"`
 }
 
 func TestSetRollupVariables(t *testing.T) {
@@ -211,7 +211,7 @@ func TestGetState(t *testing.T) {
 	// 	status.RecommendedFee.ExistingAccount*createAccountInternalExtraFeePercentage)
 }
 
-func assertNextForgers(t *testing.T, expected, actual []historydb.NextForger) {
+func assertNextForgers(t *testing.T, expected, actual []historydb.NextForgerAPI) {
 	assert.Equal(t, len(expected), len(actual))
 	for i := range expected {
 		// ignore timestamps and other metadata