polygon: Use BorSpansIndex to calculate span id at block number

cmd/rpcdaemon/cli/config.go

@@ -575,8 +575,6 @@ func RemoteServices(ctx context.Context, cfg *httpcfg.HttpCfg, logger log.Logger
 				return nil, nil, nil, nil, nil, nil, nil, ff, nil, nil, err
 			}
 
-			// NOTE: bor_* RPCs are not fully supported when using polygon.sync (https://github.com/erigontech/erigon/issues/11171)
-			// Skip the compatibility check, until we have a schema in erigon-lib
 			engine = bor.NewRo(cc, blockReader, logger)
 		} else if cc != nil && cc.Aura != nil {
 			consensusDB, err := kv2.New(kv.ConsensusDB, logger).Path(filepath.Join(cfg.DataDir, "aura")).Accede(true).Open(ctx)

db/kv/tables.go

@@ -132,19 +132,21 @@ const (
 	PendingEpoch = "DevPendingEpoch" // block_num_u64+block_hash->transition_proof
 
 	// BOR
-	BorTxLookup             = "BlockBorTransactionLookup" // transaction_hash -> block_num_u64
-	BorEvents               = "BorEvents"                 // event_id -> event_payload
-	BorEventNums            = "BorEventNums"              // block_num -> event_id (last event_id in that block)
-	BorEventProcessedBlocks = "BorEventProcessedBlocks"   // block_num -> block_time, tracks processed blocks in the bridge, used for unwinds and restarts, gets pruned
-	BorEventTimes           = "BorEventTimes"             // timestamp -> event_id
-	BorSpans                = "BorSpans"                  // span_id -> span (in JSON encoding)
-	BorMilestones           = "BorMilestones"             // milestone_id -> milestone (in JSON encoding)
-	BorMilestoneEnds        = "BorMilestoneEnds"          // start block_num -> milestone_id (first block of milestone)
-	BorCheckpoints          = "BorCheckpoints"            // checkpoint_id -> checkpoint (in JSON encoding)
-	BorCheckpointEnds       = "BorCheckpointEnds"         // start block_num -> checkpoint_id (first block of checkpoint)
-	BorProducerSelections   = "BorProducerSelections"     // span_id -> span selection with accumulated proposer priorities (in JSON encoding)
-	BorWitnesses            = "BorWitnesses"              // block_num_u64 + block_hash -> witness
-	BorWitnessSizes         = "BorWitnessSizes"           // block_num_u64 + block_hash -> witness size (uint64)
+	BorTxLookup                = "BlockBorTransactionLookup"  // transaction_hash -> block_num_u64
+	BorEvents                  = "BorEvents"                  // event_id -> event_payload
+	BorEventNums               = "BorEventNums"               // block_num -> event_id (last event_id in that block)
+	BorEventProcessedBlocks    = "BorEventProcessedBlocks"    // block_num -> block_time, tracks processed blocks in the bridge, used for unwinds and restarts, gets pruned
+	BorEventTimes              = "BorEventTimes"              // timestamp -> event_id
+	BorSpans                   = "BorSpans"                   // span_id -> span (in JSON encoding)
+	BorSpansIndex              = "BorSpansIndex"              // span.StartBlockNumber -> span.Id
+	BorMilestones              = "BorMilestones"              // milestone_id -> milestone (in JSON encoding)
+	BorMilestoneEnds           = "BorMilestoneEnds"           // start block_num -> milestone_id (first block of milestone)
+	BorCheckpoints             = "BorCheckpoints"             // checkpoint_id -> checkpoint (in JSON encoding)
+	BorCheckpointEnds          = "BorCheckpointEnds"          // start block_num -> checkpoint_id (first block of checkpoint)
+	BorProducerSelections      = "BorProducerSelections"      // span_id -> span selection with accumulated proposer priorities (in JSON encoding)
+	BorProducerSelectionsIndex = "BorProducerSelectionsIndex" // span.StartBlockNumber -> span.Id
+	BorWitnesses               = "BorWitnesses"               // block_num_u64 + block_hash -> witness
+	BorWitnessSizes            = "BorWitnessSizes"            // block_num_u64 + block_hash -> witness size (uint64)
 
 	// Downloader
 	BittorrentCompletion = "BittorrentCompletion"
@@ -349,11 +351,13 @@ var ChaindataTables = []string{
 	BorEventProcessedBlocks,
 	BorEventTimes,
 	BorSpans,
+	BorSpansIndex,
 	BorMilestones,
 	BorMilestoneEnds,
 	BorCheckpoints,
 	BorCheckpointEnds,
 	BorProducerSelections,
+	BorProducerSelectionsIndex,
 	BorWitnesses,
 	BorWitnessSizes,
 	TblAccountVals,
@@ -586,19 +590,21 @@ var AuRaTablesCfg = TableCfg{
 }
 
 var BorTablesCfg = TableCfg{
-	BorTxLookup:             {Flags: DupSort},
-	BorEvents:               {Flags: DupSort},
-	BorEventNums:            {Flags: DupSort},
-	BorEventProcessedBlocks: {Flags: DupSort},
-	BorEventTimes:           {Flags: DupSort},
-	BorSpans:                {Flags: DupSort},
-	BorCheckpoints:          {Flags: DupSort},
-	BorCheckpointEnds:       {Flags: DupSort},
-	BorMilestones:           {Flags: DupSort},
-	BorMilestoneEnds:        {Flags: DupSort},
-	BorProducerSelections:   {Flags: DupSort},
-	BorWitnesses:            {Flags: DupSort},
-	BorWitnessSizes:         {Flags: DupSort},
+	BorTxLookup:                {Flags: DupSort},
+	BorEvents:                  {Flags: DupSort},
+	BorEventNums:               {Flags: DupSort},
+	BorEventProcessedBlocks:    {Flags: DupSort},
+	BorEventTimes:              {Flags: DupSort},
+	BorSpans:                   {Flags: DupSort},
+	BorSpansIndex:              {Flags: DupSort},
+	BorProducerSelectionsIndex: {Flags: DupSort},
+	BorCheckpoints:             {Flags: DupSort},
+	BorCheckpointEnds:          {Flags: DupSort},
+	BorMilestones:              {Flags: DupSort},
+	BorMilestoneEnds:           {Flags: DupSort},
+	BorProducerSelections:      {Flags: DupSort},
+	BorWitnesses:               {Flags: DupSort},
+	BorWitnessSizes:            {Flags: DupSort},
 }
 
 var TxpoolTablesCfg = TableCfg{}

polygon/heimdall/client_idle.go

@@ -34,6 +34,8 @@ func NewIdleClient(cfg buildercfg.MiningConfig) Client {
 
 func (c *IdleClient) FetchLatestSpan(ctx context.Context) (*Span, error) {
 	return &Span{
+		StartBlock: 0,
+		EndBlock:   255,
 		ValidatorSet: ValidatorSet{
 			Validators: []*Validator{
 				{
@@ -55,7 +57,9 @@ func (c *IdleClient) FetchLatestSpan(ctx context.Context) (*Span, error) {
 
 func (c *IdleClient) FetchSpan(ctx context.Context, spanID uint64) (*Span, error) {
 	return &Span{
-		Id: SpanId(spanID),
+		Id:         SpanId(spanID),
+		StartBlock: 0,
+		EndBlock:   255,
 		ValidatorSet: ValidatorSet{
 			Validators: []*Validator{
 				{

polygon/heimdall/entity_store.go

@@ -32,12 +32,14 @@ import (
 )
 
 var databaseTablesCfg = kv.TableCfg{
-	kv.BorCheckpoints:        {},
-	kv.BorCheckpointEnds:     {},
-	kv.BorMilestones:         {},
-	kv.BorMilestoneEnds:      {},
-	kv.BorSpans:              {},
-	kv.BorProducerSelections: {},
+	kv.BorCheckpoints:             {},
+	kv.BorCheckpointEnds:          {},
+	kv.BorMilestones:              {},
+	kv.BorMilestoneEnds:           {},
+	kv.BorSpans:                   {},
+	kv.BorSpansIndex:              {},
+	kv.BorProducerSelections:      {},
+	kv.BorProducerSelectionsIndex: {},
 }
 
 //go:generate mockgen -typed=true -source=./entity_store.go -destination=./entity_store_mock.go -package=heimdall
@@ -46,7 +48,6 @@ type EntityStore[TEntity Entity] interface {
 	Close()
 
 	LastEntityId(ctx context.Context) (uint64, bool, error)
-	LastFrozenEntityId() uint64
 	LastEntity(ctx context.Context) (TEntity, bool, error)
 	Entity(ctx context.Context, id uint64) (TEntity, bool, error)
 	PutEntity(ctx context.Context, id uint64, entity TEntity) error
@@ -56,6 +57,8 @@ type EntityStore[TEntity Entity] interface {
 	DeleteToBlockNum(ctx context.Context, unwindPoint uint64, limit int) (int, error)
 	DeleteFromBlockNum(ctx context.Context, unwindPoint uint64) (int, error)
 
+	RangeIndex() RangeIndex
+
 	SnapType() snaptype.Type
 }
 
@@ -72,7 +75,7 @@ func (NoopEntityStore[TEntity]) Close() {}
 func (NoopEntityStore[TEntity]) LastEntityId(ctx context.Context) (uint64, bool, error) {
 	return 0, false, errors.New("noop")
 }
-func (NoopEntityStore[TEntity]) LastFrozenEntityId() uint64 { return 0 }
+func (NoopEntityStore[TEntity]) LastFrozenEntityId() (uint64, bool, error) { return 0, false, nil }
 func (NoopEntityStore[TEntity]) LastEntity(ctx context.Context) (TEntity, bool, error) {
 	var res TEntity
 	return res, false, errors.New("noop")
@@ -142,6 +145,10 @@ func (s *mdbxEntityStore[TEntity]) WithTx(tx kv.Tx) EntityStore[TEntity] {
 	return txEntityStore[TEntity]{s, tx}
 }
 
+func (s *mdbxEntityStore[TEntity]) RangeIndex() RangeIndex {
+	return s.blockNumToIdIndex
+}
+
 func (s *mdbxEntityStore[TEntity]) Close() {
 }
 
@@ -222,7 +229,7 @@ func (s *mdbxEntityStore[TEntity]) PutEntity(ctx context.Context, id uint64, ent
 	defer tx.Rollback()
 
 	if err = (txEntityStore[TEntity]{s, tx}).PutEntity(ctx, id, entity); err != nil {
-		return nil
+		return err
 	}
 
 	return tx.Commit()

polygon/heimdall/range_index.go

@@ -27,6 +27,7 @@ import (
 
 type RangeIndex interface {
 	Lookup(ctx context.Context, blockNum uint64) (uint64, bool, error)
+	Last(ctx context.Context) (uint64, bool, error)
 }
 
 type TransactionalRangeIndexer interface {
@@ -128,6 +129,18 @@ func (i *dbRangeIndex) Lookup(ctx context.Context, blockNum uint64) (uint64, boo
 	return id, ok, err
 }
 
+func (i *dbRangeIndex) Last(ctx context.Context) (uint64, bool, error) {
+	var lastKey uint64
+	var ok bool
+
+	err := i.db.View(ctx, func(tx kv.Tx) error {
+		var err error
+		lastKey, ok, err = i.WithTx(tx).Last(ctx)
+		return err
+	})
+	return lastKey, ok, err
+}
+
 func (i *txRangeIndex) Lookup(ctx context.Context, blockNum uint64) (uint64, bool, error) {
 	cursor, err := i.tx.Cursor(i.table)
 	if err != nil {
@@ -149,6 +162,26 @@ func (i *txRangeIndex) Lookup(ctx context.Context, blockNum uint64) (uint64, boo
 	return id, true, err
 }
 
+// last key in the index
+func (i *txRangeIndex) Last(ctx context.Context) (uint64, bool, error) {
+	cursor, err := i.tx.Cursor(i.table)
+	if err != nil {
+		return 0, false, err
+	}
+	defer cursor.Close()
+	key, value, err := cursor.Last()
+	if err != nil {
+		return 0, false, err
+	}
+
+	if value == nil || key == nil {
+		return 0, false, nil
+	}
+
+	lastKey := rangeIndexKeyParse(key)
+	return lastKey, true, nil
+}
+
 // Lookup ids for the given range [blockFrom, blockTo). Return boolean which checks if the result is reliable to use, because
 // heimdall data can be not published yet for [blockFrom, blockTo), in that case boolean OK will be false
 func (i *dbRangeIndex) GetIDsBetween(ctx context.Context, blockFrom, blockTo uint64) ([]uint64, bool, error) {

polygon/heimdall/service.go

@@ -324,7 +324,7 @@ func (s *Service) Run(ctx context.Context) error {
 	}
 
 	s.RegisterSpanObserver(func(span *Span) {
-		s.spanBlockProducersTracker.ObserveSpanAsync(span)
+		s.spanBlockProducersTracker.ObserveSpanAsync(ctx, span)
 	})
 
 	milestoneObserver := s.RegisterMilestoneObserver(func(milestone *Milestone) {

polygon/heimdall/service_store.go

@@ -41,10 +41,8 @@ func NewMdbxStore(logger log.Logger, dataDir string, accede bool, roTxLimit int6
 }
 
 func newMdbxStore(db *polygoncommon.Database) *MdbxStore {
-	spanIndex := RangeIndexFunc(
-		func(ctx context.Context, blockNum uint64) (uint64, bool, error) {
-			return uint64(SpanIdAt(blockNum)), true, nil
-		})
+	spanIndex := NewSpanRangeIndex(db, kv.BorSpansIndex)
+	producerSelectionIndex := NewSpanRangeIndex(db, kv.BorProducerSelectionsIndex)
 
 	return &MdbxStore{
 		db: db,
@@ -57,7 +55,7 @@ func newMdbxStore(db *polygoncommon.Database) *MdbxStore {
 		spans: newMdbxEntityStore(
 			db, kv.BorSpans, Spans, generics.New[Span], spanIndex),
 		spanBlockProducerSelections: newMdbxEntityStore(
-			db, kv.BorProducerSelections, nil, generics.New[SpanBlockProducerSelection], spanIndex),
+			db, kv.BorProducerSelections, nil, generics.New[SpanBlockProducerSelection], producerSelectionIndex),
 	}
 }
 

polygon/heimdall/service_test.go

@@ -193,7 +193,10 @@ func (suite *ServiceTestSuite) SetupSuite() {
 	})
 
 	suite.eg.Go(func() error {
-		return suite.service.Run(suite.ctx)
+		defer suite.cancel()
+		err := suite.service.Run(suite.ctx)
+		require.ErrorIs(suite.T(), err, context.Canceled)
+		return err
 	})
 
 	lastMilestone, ok, err := suite.service.SynchronizeMilestones(suite.ctx)