cherry-pick 9907be8 polygon: Implement VeBlop consensus changes (#16803)

Cherry-pick
9907be8
from release/3.0 to main.

---------

Co-authored-by: antonis19 <[email protected]>

Author: antonis19

core/genesis_write.go

@@ -52,6 +52,7 @@ import (
 	"github.com/erigontech/erigon/execution/chain/params"
 	chainspec "github.com/erigontech/erigon/execution/chain/spec"
 	"github.com/erigontech/erigon/execution/types"
+	polygonchain "github.com/erigontech/erigon/polygon/chain"
 )
 
 // GenesisMismatchError is raised when trying to overwrite an existing
@@ -507,6 +508,14 @@ func GenesisWithoutStateToBlock(g *types.Genesis) (head *types.Header, withdrawa
 		}
 	}
 
+	// these fields need to be overriden for Bor running in a kurtosis devnet
+	if g.Config != nil && g.Config.Bor != nil && g.Config.ChainID.Uint64() == polygonchain.BorKurtosisDevnetChainId {
+		withdrawals = []*types.Withdrawal{}
+		head.BlobGasUsed = new(uint64)
+		head.ExcessBlobGas = new(uint64)
+		emptyHash := common.HexToHash("0x0")
+		head.ParentBeaconBlockRoot = &emptyHash
+	}
 	return
 }
 

execution/consensus/misc/eip2935.go

@@ -20,7 +20,6 @@ import (
 	"github.com/holiman/uint256"
 
 	"github.com/erigontech/erigon-lib/common"
-	"github.com/erigontech/erigon-lib/log/v3"
 	"github.com/erigontech/erigon/core/state"
 	"github.com/erigontech/erigon/execution/chain"
 	"github.com/erigontech/erigon/execution/chain/params"
@@ -34,7 +33,7 @@ func StoreBlockHashesEip2935(header *types.Header, state *state.IntraBlockState,
 		return err
 	}
 	if codeSize == 0 {
-		log.Debug("[EIP-2935] No code deployed to HistoryStorageAddress before call to store EIP-2935 history")
+		// log.Debug("[EIP-2935] No code deployed to HistoryStorageAddress before call to store EIP-2935 history")
 		return nil
 	}
 	headerNum := header.Number.Uint64()

go.mod

@@ -80,6 +80,7 @@ require (
 	github.com/huin/goupnp v1.3.0
 	github.com/jackpal/go-nat-pmp v1.0.2
 	github.com/jedib0t/go-pretty/v6 v6.5.9
+	github.com/jellydator/ttlcache/v3 v3.4.0
 	github.com/jinzhu/copier v0.4.0
 	github.com/json-iterator/go v1.1.12
 	github.com/klauspost/compress v1.18.0

go.sum

@@ -551,6 +551,8 @@ github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0
 github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8=
 github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg=
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/jellydator/ttlcache/v3 v3.4.0 h1:YS4P125qQS0tNhtL6aeYkheEaB/m8HCqdMMP4mnWdTY=
+github.com/jellydator/ttlcache/v3 v3.4.0/go.mod h1:Hw9EgjymziQD3yGsQdf1FqFdpp7YjFMd4Srg5EJlgD4=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=

polygon/bor/bor.go

@@ -182,6 +182,10 @@ func CalcProducerDelay(number uint64, succession int, c *borcfg.BorConfig) uint6
 	// When the block is the first block of the sprint, it is expected to be delayed by `producerDelay`.
 	// That is to allow time for block propagation in the last sprint
 	delay := c.CalculatePeriod(number)
+	// Since there is only one producer in veblop, we don't need to add producer delay and backup multiplier
+	if c.IsVeBlop(number) {
+		return delay
+	}
 	if c.IsSprintStart(number) {
 		delay = c.CalculateProducerDelay(number)
 	}
@@ -807,11 +811,14 @@ func (c *Bor) Finalize(config *chain.Config, header *types.Header, state *state.
 		cx := statefull.ChainContext{Chain: chain, Bor: c}
 
 		if c.blockReader != nil {
-			// check and commit span
-			if err := c.checkAndCommitSpan(header, syscall); err != nil {
-				err := fmt.Errorf("Finalize.checkAndCommitSpan: %w", err)
-				c.logger.Error("[bor] committing span", "err", err)
-				return nil, err
+			// post VeBlop spans won't be committed to smart contract
+			if !c.config.IsVeBlop(header.Number.Uint64()) {
+				// check and commit span
+				if err := c.checkAndCommitSpan(header, syscall); err != nil {
+					err := fmt.Errorf("Finalize.checkAndCommitSpan: %w", err)
+					c.logger.Error("[bor] committing span", "err", err)
+					return nil, err
+				}
 			}
 
 			// commit states
@@ -869,11 +876,14 @@ func (c *Bor) FinalizeAndAssemble(chainConfig *chain.Config, header *types.Heade
 		cx := statefull.ChainContext{Chain: chain, Bor: c}
 
 		if c.blockReader != nil {
-			// check and commit span
-			if err := c.checkAndCommitSpan(header, syscall); err != nil {
-				err := fmt.Errorf("FinalizeAndAssemble.checkAndCommitSpan: %w", err)
-				c.logger.Error("[bor] committing span", "err", err)
-				return nil, nil, err
+			// Post VeBlop spans won't be commited to smart contract
+			if !c.config.IsVeBlop(header.Number.Uint64()) {
+				// check and commit span
+				if err := c.checkAndCommitSpan(header, syscall); err != nil {
+					err := fmt.Errorf("FinalizeAndAssemble.checkAndCommitSpan: %w", err)
+					c.logger.Error("[bor] committing span", "err", err)
+					return nil, nil, err
+				}
 			}
 			// commit states
 			if err := c.CommitStates(header, cx, syscall, true); err != nil {

polygon/chain/config.go

@@ -53,6 +53,10 @@ var (
 	BorDevnetChainConfig  = readChainSpec("chainspecs/bor-devnet.json")
 )
 
+var (
+	BorKurtosisDevnetChainId uint64 = 4927
+)
+
 func init() {
 	chainspec.RegisterChain(networkname.Amoy, AmoyChainConfig, AmoyGenesisBlock(), AmoyGenesisHash, AmoyBootnodes,
 		"enrtree://AKUEZKN7PSKVNR65FZDHECMKOJQSGPARGTPPBI7WS2VUL4EGR6XPC@amoy.polygon-peers.io")

polygon/heimdall/service.go

@@ -178,6 +178,11 @@ func (s *Service) SynchronizeMilestones(ctx context.Context) (*Milestone, bool,
 	return s.milestoneScraper.Synchronize(ctx)
 }
 
+func (s *Service) AnticipateNewSpanWithTimeout(ctx context.Context, timeout time.Duration) (bool, error) {
+	s.logger.Info(heimdallLogPrefix(fmt.Sprintf("anticipating new span update within %.0f seconds", timeout.Seconds())))
+	return s.spanBlockProducersTracker.AnticipateNewSpanWithTimeout(ctx, timeout)
+}
+
 func (s *Service) SynchronizeSpans(ctx context.Context, blockNum uint64) error {
 	s.logger.Debug(heimdallLogPrefix("synchronizing spans..."), "blockNum", blockNum)
 

polygon/heimdall/span_block_producers_tracker.go

@@ -40,29 +40,32 @@ func newSpanBlockProducersTracker(
 	}
 
 	return &spanBlockProducersTracker{
-		logger:           logger,
-		borConfig:        borConfig,
-		store:            store,
-		recentSelections: recentSelectionsLru,
-		newSpans:         make(chan *Span),
-		idleSignal:       make(chan struct{}),
+		logger:              logger,
+		borConfig:           borConfig,
+		store:               store,
+		recentSelections:    recentSelectionsLru,
+		newSpans:            make(chan *Span),
+		idleSignal:          make(chan struct{}),
+		spanProcessedSignal: make(chan struct{}),
 	}
 }
 
 type spanBlockProducersTracker struct {
-	logger           log.Logger
-	borConfig        *borcfg.BorConfig
-	store            EntityStore[*SpanBlockProducerSelection]
-	recentSelections *lru.Cache[uint64, SpanBlockProducerSelection] // sprint number -> SpanBlockProducerSelection
-	newSpans         chan *Span
-	queued           atomic.Int32
-	idleSignal       chan struct{}
+	logger              log.Logger
+	borConfig           *borcfg.BorConfig
+	store               EntityStore[*SpanBlockProducerSelection]
+	recentSelections    *lru.Cache[uint64, SpanBlockProducerSelection] // sprint number -> SpanBlockProducerSelection
+	newSpans            chan *Span
+	queued              atomic.Int32
+	idleSignal          chan struct{}
+	spanProcessedSignal chan struct{} // signal that a new span was fully processed
 }
 
 func (t *spanBlockProducersTracker) Run(ctx context.Context) error {
 	t.logger.Info(heimdallLogPrefix("running span block producers tracker component"))
 
 	defer close(t.idleSignal)
+	defer close(t.spanProcessedSignal)
 	for {
 		select {
 		case <-ctx.Done():
@@ -73,6 +76,12 @@ func (t *spanBlockProducersTracker) Run(ctx context.Context) error {
 				return err
 			}
 
+			// signal that the span was observed (non-blocking)
+			select {
+			case t.spanProcessedSignal <- struct{}{}:
+			default:
+			}
+
 			t.queued.Add(-1)
 			if t.queued.Load() == 0 {
 				select {
@@ -84,6 +93,23 @@ func (t *spanBlockProducersTracker) Run(ctx context.Context) error {
 	}
 }
 
+// Anticipates a new span to be observe and fully processed withing the given timeout period.
+// Returns true if a new span was processed, false if no new span was processed
+func (t *spanBlockProducersTracker) AnticipateNewSpanWithTimeout(ctx context.Context, timeout time.Duration) (bool, error) {
+	select {
+	case <-ctx.Done():
+		return false, ctx.Err()
+	case _, ok := <-t.spanProcessedSignal:
+		if !ok {
+			return false, errors.New("spanProcessed channel was closed")
+		}
+		return true, nil
+
+	case <-time.After(timeout): // timeout
+	}
+	return false, nil
+}
+
 func (t *spanBlockProducersTracker) Synchronize(ctx context.Context) error {
 	if t.queued.Load() == 0 {
 		return nil
@@ -111,7 +137,7 @@ func (t *spanBlockProducersTracker) ObserveSpanAsync(ctx context.Context, span *
 }
 
 func (t *spanBlockProducersTracker) ObserveSpan(ctx context.Context, newSpan *Span) error {
-	t.logger.Debug(heimdallLogPrefix("block producers tracker observing span"), "id", newSpan.Id)
+	t.logger.Debug(heimdallLogPrefix("block producers tracker observing span"), "newSpan", newSpan)
 
 	lastProducerSelection, ok, err := t.store.LastEntity(ctx)
 	if err != nil {
@@ -204,11 +230,6 @@ func (t *spanBlockProducersTracker) Producers(ctx context.Context, blockNum uint
 func (t *spanBlockProducersTracker) producers(ctx context.Context, blockNum uint64) (*ValidatorSet, int, error) {
 	currentSprintNum := t.borConfig.CalculateSprintNumber(blockNum)
 
-	// have we previously calculated the producers for the same sprint num (chain tip optimisation)
-	if selection, ok := t.recentSelections.Get(currentSprintNum); ok {
-		return selection.Producers.Copy(), 0, nil
-	}
-
 	// have we previously calculated the producers for the previous sprint num of the same span (chain tip optimisation)
 	spanId, ok, err := t.store.EntityIdFromBlockNum(ctx, blockNum)
 	if err != nil {
@@ -217,20 +238,7 @@ func (t *spanBlockProducersTracker) producers(ctx context.Context, blockNum uint
 	if !ok {
 		return nil, 0, fmt.Errorf("could not get spanId from blockNum=%d", blockNum)
 	}
-	var prevSprintNum uint64
-	if currentSprintNum > 0 {
-		prevSprintNum = currentSprintNum - 1
-	}
-	if selection, ok := t.recentSelections.Get(prevSprintNum); ok && SpanId(spanId) == selection.SpanId {
-		producersCopy := selection.Producers.Copy()
-		producersCopy.IncrementProposerPriority(1)
-		selectionCopy := selection
-		selectionCopy.Producers = producersCopy
-		t.recentSelections.Add(currentSprintNum, selectionCopy)
-		return producersCopy, 1, nil
-	}
 
-	// no recent selection that we can easily use, re-calculate from DB
 	producerSelection, ok, err := t.store.Entity(ctx, spanId)
 	if err != nil {
 		return nil, 0, err
@@ -252,7 +260,5 @@ func (t *spanBlockProducersTracker) producers(ctx context.Context, blockNum uint
 		producers = GetUpdatedValidatorSet(producers, producers.Validators, t.logger)
 		producers.IncrementProposerPriority(1)
 	}
-
-	t.recentSelections.Add(currentSprintNum, *producerSelection)
 	return producers, increments, nil
 }

polygon/heimdall/validator_set.go

@@ -239,6 +239,14 @@ func NewValidatorSet(valz []*Validator) *ValidatorSet {
 	return vals
 }
 
+func (vals *ValidatorSet) ValidatorAddresses() []common.Address {
+	addresses := make([]common.Address, len(vals.Validators))
+	for i, val := range vals.Validators {
+		addresses[i] = val.Address
+	}
+	return addresses
+}
+
 // Nil or empty validator sets are invalid.
 func (vals *ValidatorSet) IsNilOrEmpty() bool {
 	return vals == nil || len(vals.Validators) == 0

polygon/sync/block_producers_reader.go

@@ -18,10 +18,16 @@ package sync
 
 import (
 	"context"
+	"time"
 
 	"github.com/erigontech/erigon/polygon/heimdall"
 )
 
 type blockProducersReader interface {
 	Producers(ctx context.Context, blockNum uint64) (*heimdall.ValidatorSet, error)
 }
+
+type blockProducersTracker interface {
+	blockProducersReader
+	AnticipateNewSpanWithTimeout(ctx context.Context, timeout time.Duration) (bool, error)
+}