Merge branch 'feat/supernova-async-exec' into cross-shard-execution-analysis

Author: mradian1

api/gin/webServer.go

@@ -12,19 +12,21 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/multiversx/mx-chain-core-go/core/check"
 	"github.com/multiversx/mx-chain-core-go/marshal"
+	logger "github.com/multiversx/mx-chain-logger-go"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+
 	"github.com/multiversx/mx-chain-go/api/errors"
 	"github.com/multiversx/mx-chain-go/api/groups"
 	"github.com/multiversx/mx-chain-go/api/middleware"
 	"github.com/multiversx/mx-chain-go/api/shared"
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/facade"
-	logger "github.com/multiversx/mx-chain-logger-go"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
 var log = logger.GetOrCreate("api/gin")
 
 const prometheusMetricsRoute = "/debug/metrics/prometheus"
+const readHeaderTimeout = 10 * time.Second
 
 // ArgsNewWebServer holds the arguments needed to create a new instance of webServer
 type ArgsNewWebServer struct {
@@ -126,7 +128,11 @@ func (ws *webServer) StartHttpServer() error {
 
 	ws.registerRoutes(engine)
 
-	server := &http.Server{Addr: ws.facade.RestApiInterface(), Handler: engine}
+	server := &http.Server{
+		Addr:              ws.facade.RestApiInterface(),
+		Handler:           engine,
+		ReadHeaderTimeout: readHeaderTimeout,
+	}
 	log.Debug("creating gin web sever", "interface", ws.facade.RestApiInterface())
 	ws.httpServer, err = NewHttpServer(server)
 	if err != nil {

api/groups/networkGroup.go

@@ -23,6 +23,7 @@ const (
 	economicsPath          = "/economics"
 	enableEpochsPath       = "/enable-epochs"
 	enableEpochsV2Path     = "/enable-epochs-v2"
+	enableRoundsPath       = "/enable-rounds"
 	getESDTsPath           = "/esdts"
 	getFFTsPath            = "/esdt/fungible-tokens"
 	getSFTsPath            = "/esdt/semi-fungible-tokens"
@@ -105,6 +106,11 @@ func NewNetworkGroup(facade networkFacadeHandler) (*networkGroup, error) {
 			Method:  http.MethodGet,
 			Handler: ng.getEnableEpochsV2,
 		},
+		{
+			Path:    enableRoundsPath,
+			Method:  http.MethodGet,
+			Handler: ng.getEnableRounds,
+		},
 		{
 			Path:    getESDTsPath,
 			Method:  http.MethodGet,
@@ -230,6 +236,20 @@ func (ng *networkGroup) getEnableEpochsV2(c *gin.Context) {
 	)
 }
 
+// getEnableRounds returns metrics related to the activation rounds of the network
+func (ng *networkGroup) getEnableRounds(c *gin.Context) {
+	enableRoundsMetrics := ng.getFacade().StatusMetrics().EnableRoundsMetrics()
+
+	c.JSON(
+		http.StatusOK,
+		shared.GenericAPIResponse{
+			Data:  gin.H{"enableRounds": enableRoundsMetrics},
+			Error: "",
+			Code:  shared.ReturnCodeSuccess,
+		},
+	)
+}
+
 // getNetworkStatus returns metrics related to the network status (shard specific)
 func (ng *networkGroup) getNetworkStatus(c *gin.Context) {
 	networkMetrics, err := ng.getFacade().StatusMetrics().NetworkMetrics()

api/groups/networkGroup_test.go

@@ -35,7 +35,7 @@ type testStatusMetricsHandler interface {
 }
 
 func createNetworkStatusMetrics() testStatusMetricsHandler {
-	sm, _ := statusHandler.NewStatusMetrics(&enableEpochsHandlerMock.EnableEpochsHandlerStub{})
+	sm, _ := statusHandler.NewStatusMetrics(&enableEpochsHandlerMock.EnableEpochsHandlerStub{}, &testscommon.EnableRoundsHandlerStub{})
 	return sm
 }
 
@@ -654,7 +654,7 @@ func TestGetEnableEpochsV2_ShouldWork(t *testing.T) {
 		GetAllEnableEpochsCalled: func() map[string]uint32 {
 			return allEpochsMap
 		},
-	})
+	}, &testscommon.EnableRoundsHandlerStub{})
 
 	facade := mock.FacadeStub{}
 	facade.StatusMetricsHandler = func() external.StatusMetricsHandler {
@@ -679,6 +679,43 @@ func TestGetEnableEpochsV2_ShouldWork(t *testing.T) {
 	assert.True(t, keyAndValueFoundInResponse)
 }
 
+func TestGetEnableRounds_ShouldWork(t *testing.T) {
+	t.Parallel()
+
+	expectedRounds := map[string]uint64{
+		"round1": 100,
+		"round2": 200,
+	}
+
+	facade := mock.FacadeStub{
+		StatusMetricsHandler: func() external.StatusMetricsHandler {
+			return &testscommon.StatusMetricsStub{
+				EnableRoundsMetricsCalled: func() map[string]uint64 {
+					return expectedRounds
+				},
+			}
+		},
+	}
+
+	networkGroup, err := groups.NewNetworkGroup(&facade)
+	require.NoError(t, err)
+
+	ws := startWebServer(networkGroup, "network", getNetworkRoutesConfig())
+
+	req, _ := http.NewRequest("GET", "/network/enable-rounds", nil)
+	resp := httptest.NewRecorder()
+	ws.ServeHTTP(resp, req)
+
+	respBytes, _ := io.ReadAll(resp.Body)
+	respStr := string(respBytes)
+	assert.Equal(t, http.StatusOK, resp.Code)
+
+	keyAndValueFoundInResponse := strings.Contains(respStr, "round1") && strings.Contains(respStr, "100") &&
+		strings.Contains(respStr, "round2") && strings.Contains(respStr, "200")
+	assert.True(t, keyAndValueFoundInResponse)
+	assert.True(t, strings.Contains(respStr, "enableRounds"))
+}
+
 func TestGetESDTTotalSupply_InternalError(t *testing.T) {
 	t.Parallel()
 
@@ -1108,6 +1145,7 @@ func getNetworkRoutesConfig() config.ApiRoutesConfig {
 					{Name: "/genesis-balances", Open: true},
 					{Name: "/ratings", Open: true},
 					{Name: "/gas-configs", Open: true},
+					{Name: "/enable-rounds", Open: true},
 				},
 			},
 		},

api/groups/nodeGroup_test.go

@@ -36,7 +36,7 @@ type testNodeStatusMetricsHandler interface {
 }
 
 func createNodeStatusMetrics() testNodeStatusMetricsHandler {
-	sm, _ := statusHandler.NewStatusMetrics(&enableEpochsHandlerMock.EnableEpochsHandlerStub{})
+	sm, _ := statusHandler.NewStatusMetrics(&enableEpochsHandlerMock.EnableEpochsHandlerStub{}, &testscommon.EnableRoundsHandlerStub{})
 	return sm
 }
 

cmd/node/config/api.toml

@@ -134,6 +134,9 @@
         # /network/enable-epochs-v2 will return metrics related to activation epochs in the same format as in toml
         { Name = "/enable-epochs-v2", Open = true },
 
+        # /network/enable-rounds will return metrics related to activation rounds
+        { Name = "/enable-rounds", Open = true },
+
         # /network/esdts will return all the issued esdts on the protocol
         { Name = "/esdts", Open = true },
 

cmd/node/config/config.toml

@@ -38,6 +38,9 @@
     # Make sure that this is greater than the unbonding period!
     SetGuardianEpochsDelay = 2 # TODO: for mainnet should be 20, 2 is just for testing
 
+    # MaxProposalNonceGap defines the maximum gap allowed between the highest finalized nonce and lowest proposed nonce
+    MaxProposalNonceGap = 50
+
     # ChainParametersByEpoch defines chain operation configurable values that can be modified based on epochs
     ChainParametersByEpoch = [
         { EnableEpoch = 0, RoundDuration = 6000, RoundsPerEpoch = 200, MinRoundsBetweenEpochs = 20, ShardConsensusGroupSize = 7, ShardMinNumNodes = 10, MetachainConsensusGroupSize = 10, MetachainMinNumNodes = 10, Hysteresis = 0.2, Adaptivity = false, Offset = 0 },
@@ -514,6 +517,12 @@
     SelectionGasBandwidthIncreaseScheduledPercent = 260
     SelectionGasRequested = 10_000_000_000
 
+[AOTSelection]
+    # Ahead-of-Time transaction selection - pre-selects transactions before consensus round
+    Enabled = true
+    CacheSize = 10                                          # Number of pre-selection results to cache
+    SelectionTimeoutMs = 150                                # Max time for AOT selection in milliseconds
+
 [TrieNodesChunksDataPool]
     Name = "TrieNodesDataPool"
     Capacity = 400
@@ -889,6 +898,7 @@
 [BlockSizeThrottleConfig]
     MinSizeInBytes = 104857 # 104857 is 10% from 1MB
     MaxSizeInBytes = 943718 # 943718 is 90% from 1MB
+    MaxExecResSizeInBytes = 104857 # 104857 is 10% from 1MB
 
 [VirtualMachine]
     [VirtualMachine.Execution]
@@ -1176,6 +1186,10 @@
     CacheSpanInSec = 30
     CacheExpiryInSec = 30
 
+[DirectSentTransactions]
+    CacheSpanInSec = 30
+    CacheExpiryInSec = 30
+
 [ExecutionResultInclusionEstimator]
     # Safety margin = 110 -> 110% -> 10% buffer
     SafetyMargin = 110

common/consensus/common.go

@@ -0,0 +1,24 @@
+package consensus
+
+import (
+	"github.com/multiversx/mx-chain-core-go/core/check"
+	"github.com/multiversx/mx-chain-go/consensus"
+	logger "github.com/multiversx/mx-chain-logger-go"
+)
+
+var log = logger.GetOrCreate("common/consensus")
+
+// ShouldConsiderSelfKeyInConsensus returns true if current machine is the main one, or it is a backup machine but the main
+// machine failed
+func ShouldConsiderSelfKeyInConsensus(redundancyHandler consensus.NodeRedundancyHandler) bool {
+	if check.IfNil(redundancyHandler) {
+		log.Warn("redundancy handler is nil")
+		return false
+	}
+
+	isMainMachine := !redundancyHandler.IsRedundancyNode()
+	if isMainMachine {
+		return true
+	}
+	return !redundancyHandler.IsMainMachineActive()
+}

common/consensus/common_test.go

@@ -0,0 +1,39 @@
+package consensus_test
+
+import (
+	"testing"
+
+	"github.com/multiversx/mx-chain-go/common/consensus"
+	consensusMock "github.com/multiversx/mx-chain-go/consensus/mock"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_ShouldConsiderSelfKeyInConsensus(t *testing.T) {
+	t.Parallel()
+
+	// nil handler
+	assert.False(t, consensus.ShouldConsiderSelfKeyInConsensus(nil))
+
+	// main machine
+	assert.True(t, consensus.ShouldConsiderSelfKeyInConsensus(
+		&consensusMock.NodeRedundancyHandlerStub{
+			IsRedundancyNodeCalled: func() bool { return false },
+		},
+	))
+
+	// backup with active main
+	assert.False(t, consensus.ShouldConsiderSelfKeyInConsensus(
+		&consensusMock.NodeRedundancyHandlerStub{
+			IsRedundancyNodeCalled:    func() bool { return true },
+			IsMainMachineActiveCalled: func() bool { return true },
+		},
+	))
+
+	// backup with inactive main
+	assert.True(t, consensus.ShouldConsiderSelfKeyInConsensus(
+		&consensusMock.NodeRedundancyHandlerStub{
+			IsRedundancyNodeCalled:    func() bool { return true },
+			IsMainMachineActiveCalled: func() bool { return false },
+		},
+	))
+}

common/dtos.go

@@ -110,3 +110,9 @@ type AuctionListValidatorAPIResponse struct {
 	QualifiedTopUp string         `json:"qualifiedTopUp"`
 	Nodes          []*AuctionNode `json:"nodes"`
 }
+
+// LastExecutionResultForInclusion is a lightweight summary of the last notarized execution result EIE requires.
+type LastExecutionResultForInclusion struct {
+	NotarizedInRound uint64
+	ProposedInRound  uint64
+}

common/enablers/enableRoundsHandler.go

@@ -170,6 +170,16 @@ func (handler *enableRoundsHandler) GetActivationRound(flag common.EnableRoundFl
 	return fh.activationRound
 }
 
+// GetAllEnableRounds returns a map of all enable round flags with their activation rounds
+func (handler *enableRoundsHandler) GetAllEnableRounds() map[string]uint64 {
+	result := make(map[string]uint64, len(handler.allFlagsDefined))
+	for flag, flagHandler := range handler.allFlagsDefined {
+		result[string(flag)] = flagHandler.activationRound
+	}
+
+	return result
+}
+
 // IsInterfaceNil returns true if there is no value under the interface
 func (handler *enableRoundsHandler) IsInterfaceNil() bool {
 	return handler == nil