Get 0 span

cmd/rpcdaemon/rpcservices/eth_backend.go

@@ -271,8 +271,8 @@ func (back *RemoteBackend) EventLookup(ctx context.Context, tx kv.Getter, txnHas
 func (back *RemoteBackend) EventsByBlock(ctx context.Context, tx kv.Tx, hash common.Hash, blockNum uint64) ([]rlp.RawValue, error) {
 	return back.blockReader.EventsByBlock(ctx, tx, hash, blockNum)
 }
-func (back *RemoteBackend) Span(ctx context.Context, spanId uint64) ([]byte, error) {
-	return back.blockReader.Span(ctx, spanId)
+func (back *RemoteBackend) Span(ctx context.Context, tx kv.Getter, spanId uint64) ([]byte, error) {
+	return back.blockReader.Span(ctx, tx, spanId)
 }
 
 func (back *RemoteBackend) NodeInfo(ctx context.Context, limit uint32) ([]p2p.NodeInfo, error) {

consensus/bor/bor.go

@@ -653,19 +653,6 @@ func (c *Bor) verifyCascadingFields(chain consensus.ChainHeaderReader, header *t
 			}
 		}
 	}
-	/*
-		snap, err := c.snapshot(chain, number-1, header.ParentHash, parents)
-		if err != nil {
-			return err
-		}
-		// len(header.Extra) >= extraVanity+extraSeal has already been validated in ValidateHeaderExtraField, so this won't result in a panic
-		if !bytes.Equal(parentValidatorBytes, validatorsBytes) {
-			return &MismatchingValidatorsError{number - 1, validatorsBytes, parentValidatorBytes}
-		}
-
-		// All basic checks passed, verify the seal and return
-		return c.verifySeal(chain, header, parents, snap)
-	*/
 	return nil
 }
 
@@ -1053,16 +1040,9 @@ func (c *Bor) FinalizeAndAssemble(chainConfig *chain.Config, header *types.Heade
 	if isSprintStart(headerNumber, c.config.CalculateSprint(headerNumber)) {
 		cx := statefull.ChainContext{Chain: chain, Bor: c}
 
-		// check and commit span
-		err := c.checkAndCommitSpan(state, header, cx, syscall)
-		if err != nil {
-			c.logger.Error("Error while committing span", "err", err)
-			return nil, nil, types.Receipts{}, err
-		}
-
 		if c.HeimdallClient != nil {
 			// commit states
-			if err = c.CommitStates(state, header, cx, syscall); err != nil {
+			if err := c.CommitStates(state, header, cx, syscall); err != nil {
 				c.logger.Error("Error while committing states", "err", err)
 				return nil, nil, types.Receipts{}, err
 			}
@@ -1304,47 +1284,6 @@ func (c *Bor) Close() error {
 	return nil
 }
 
-func (c *Bor) checkAndCommitSpan(
-	state *state.IntraBlockState,
-	header *types.Header,
-	chain statefull.ChainContext,
-	syscall consensus.SystemCall,
-) error {
-	headerNumber := header.Number.Uint64()
-
-	span, err := c.spanner.GetCurrentSpan(syscall)
-	if err != nil {
-		return err
-	}
-
-	if c.needToCommitSpan(span, headerNumber) {
-		err := c.fetchAndCommitSpan(span.ID+1, state, header, chain, syscall)
-		return err
-	}
-
-	return nil
-}
-
-func (c *Bor) needToCommitSpan(currentSpan *span.Span, headerNumber uint64) bool {
-	// if span is nil
-	if currentSpan == nil {
-		return false
-	}
-
-	// check span is not set initially
-	if currentSpan.EndBlock == 0 {
-		return true
-	}
-	sprintLength := c.config.CalculateSprint(headerNumber)
-
-	// if current block is first block of last sprint in current span
-	if currentSpan.EndBlock > sprintLength && currentSpan.EndBlock-sprintLength+1 == headerNumber {
-		return true
-	}
-
-	return false
-}
-
 func (c *Bor) getSpanForBlock(blockNum uint64) (*span.HeimdallSpan, error) {
 	c.logger.Debug("Getting span", "for block", blockNum)
 	var borSpan *span.HeimdallSpan

consensus/bor/snapshot.go

@@ -127,11 +127,13 @@ func (s *Snapshot) Apply(parent *types.Header, headers []*types.Header, logger l
 	// Sanity check that the headers can be applied
 	for i := 0; i < len(headers)-1; i++ {
 		if headers[i+1].Number.Uint64() != headers[i].Number.Uint64()+1 {
+			logger.Error("out of range", "header", headers[0].Number.Uint64(), "parent", headers[i].Number.Uint64())
 			return nil, errOutOfRangeChain
 		}
 	}
 
 	if headers[0].Number.Uint64() != s.Number+1 {
+		logger.Error("out of range", "header", headers[0].Number.Uint64(), "snapshot", s.Number)
 		return nil, errOutOfRangeChain
 	}
 	// Iterate through the headers and create a new snapshot
@@ -161,7 +163,7 @@ func (s *Snapshot) Apply(parent *types.Header, headers []*types.Header, logger l
 			return snap, &UnauthorizedSignerError{header.Hash(), number, signer.Bytes()}
 		}
 		if succession, err = snap.GetSignerSuccessionNumber(signer); err != nil {
-			return nil, err
+			return snap, err
 		}
 
 		// add recents
@@ -170,13 +172,13 @@ func (s *Snapshot) Apply(parent *types.Header, headers []*types.Header, logger l
 		validSigner = true
 
 		if parent != nil && header.Time < parent.Time+CalcProducerDelay(number, succession, s.config) {
-			return nil, &BlockTooSoonError{number, succession}
+			return snap, &BlockTooSoonError{number, succession}
 		}
 
 		// change validator set and change proposer
 		if number > 0 && (number+1)%sprintLen == 0 {
 			if err := ValidateHeaderExtraField(header.Extra); err != nil {
-				return nil, err
+				return snap, err
 			}
 			validatorBytes := header.Extra[extraVanity : len(header.Extra)-extraSeal]
 
@@ -188,7 +190,7 @@ func (s *Snapshot) Apply(parent *types.Header, headers []*types.Header, logger l
 		}
 
 		if number > 64 && !validSigner {
-			return nil, &UnauthorizedSignerError{header.Hash(), number, signer.Bytes()}
+			return snap, &UnauthorizedSignerError{header.Hash(), number, signer.Bytes()}
 		}
 		parent = header
 	}

eth/stagedsync/stage_bor_heimdall.go

@@ -19,7 +19,6 @@ import (
 	"github.com/ledgerwatch/erigon/consensus/bor/contract"
 	"github.com/ledgerwatch/erigon/consensus/bor/heimdall"
 	"github.com/ledgerwatch/erigon/consensus/bor/heimdall/span"
-	"github.com/ledgerwatch/erigon/consensus/bor/valset"
 	"github.com/ledgerwatch/erigon/core/types"
 	"github.com/ledgerwatch/erigon/dataflow"
 	"github.com/ledgerwatch/erigon/eth/borfinality/generics"
@@ -248,7 +247,7 @@ func BorHeimdallForward(
 				return err
 			}
 		}
-		if err = persistValidatorSets(u, ctx, cfg.blockReader, cfg.chainConfig.Bor, chain, blockNum, header.Hash(), recents, signatures, cfg.snapDb, logger); err != nil {
+		if err = persistValidatorSets(u, ctx, tx, cfg.blockReader, cfg.chainConfig.Bor, chain, blockNum, header.Hash(), recents, signatures, cfg.snapDb, logger); err != nil {
 			return fmt.Errorf("persistValidatorSets: %w", err)
 		}
 	}
@@ -406,6 +405,7 @@ func fetchAndWriteSpans(
 func persistValidatorSets(
 	u Unwinder,
 	ctx context.Context,
+	tx kv.Tx,
 	blockReader services.FullBlockReader,
 	config *chain.BorConfig,
 	chain consensus.ChainHeaderReader,
@@ -486,22 +486,17 @@ func persistValidatorSets(
 			hash := zeroHeader.Hash()
 
 			// get validators and current span
-			zeroSpanBytes, err := blockReader.Span(ctx, 0)
+			zeroSpanBytes, err := blockReader.Span(ctx, tx, 0)
 			if err != nil {
 				return err
 			}
-			var zeroSpan *span.HeimdallSpan
-			if err = json.Unmarshal(zeroSpanBytes, zeroSpan); err != nil {
+			var zeroSpan span.HeimdallSpan
+			if err = json.Unmarshal(zeroSpanBytes, &zeroSpan); err != nil {
 				return err
 			}
 
-			validators := make([]*valset.Validator, len(zeroSpan.SelectedProducers))
-			for i := range zeroSpan.SelectedProducers {
-				validators[i] = &zeroSpan.SelectedProducers[i]
-			}
-
 			// new snap shot
-			snap = bor.NewSnapshot(config, signatures, 0, hash, validators, logger)
+			snap = bor.NewSnapshot(config, signatures, 0, hash, zeroSpan.ValidatorSet.Validators, logger)
 			if err := snap.Store(snapDb); err != nil {
 				return fmt.Errorf("snap.Store (0): %w", err)
 			}
@@ -513,8 +508,10 @@ func persistValidatorSets(
 				initialHeaders = append(initialHeaders, header)
 				if len(initialHeaders) == cap(initialHeaders) {
 					if snap, err = snap.Apply(parentHeader, initialHeaders, logger); err != nil {
-						if signErr, ok := err.(*bor.UnauthorizedSignerError); ok {
-							u.UnwindTo(signErr.Number-1, signErr.Hash)
+						if snap != nil {
+							// Error is not critical and means that the header is invalid
+							//u.UnwindTo(signErr.Number-1, signErr.Hash)
+							return fmt.Errorf("snap.Apply (inside loop): %w", err)
 						} else {
 							return fmt.Errorf("snap.Apply (inside loop): %w", err)
 						}

turbo/services/interfaces.go

@@ -39,7 +39,7 @@ type BorEventReader interface {
 }
 
 type BorSpanReader interface {
-	Span(ctx context.Context, spanNum uint64) ([]byte, error)
+	Span(ctx context.Context, tx kv.Getter, spanNum uint64) ([]byte, error)
 }
 
 type CanonicalReader interface {

turbo/snapshotsync/freezeblocks/block_reader.go

@@ -235,7 +235,7 @@ func (r *RemoteBlockReader) EventsByBlock(ctx context.Context, tx kv.Tx, hash co
 	return result, nil
 }
 
-func (r *RemoteBlockReader) Span(ctx context.Context, spanId uint64) ([]byte, error) {
+func (r *RemoteBlockReader) Span(ctx context.Context, tx kv.Getter, spanId uint64) ([]byte, error) {
 	return nil, nil
 }
 
@@ -1082,6 +1082,43 @@ func (r *BlockReader) LastFrozenEventID() uint64 {
 	return lastEventID
 }
 
-func (r *BlockReader) Span(ctx context.Context, spanId uint64) ([]byte, error) {
-	return nil, nil
+func (r *BlockReader) Span(ctx context.Context, tx kv.Getter, spanId uint64) ([]byte, error) {
+	// Compute starting block of the span
+	var startBlock uint64
+	if spanId > 0 {
+		startBlock = (spanId-1)*spanLength + zerothSpanEnd + 1
+	}
+	var buf [8]byte
+	binary.BigEndian.PutUint64(buf[:], spanId)
+	if startBlock >= r.FrozenBorBlocks() {
+		v, err := tx.GetOne(kv.BorSpans, buf[:])
+		if err != nil {
+			return nil, err
+		}
+		if v == nil {
+			return nil, fmt.Errorf("span %d not found", spanId)
+		}
+		return common.Copy(v), nil
+	}
+	view := r.borSn.View()
+	defer view.Close()
+	segments := view.Spans()
+	for i := len(segments) - 1; i >= 0; i-- {
+		sn := segments[i]
+		if sn.ranges.from > startBlock {
+			continue
+		}
+		if sn.ranges.to <= startBlock {
+			continue
+		}
+		if sn.idx.KeyCount() == 0 {
+			continue
+		}
+		offset := sn.idx.OrdinalLookup(spanId)
+		gg := sn.seg.MakeGetter()
+		gg.Reset(offset)
+		result, _ := gg.Next(nil)
+		return common.Copy(result), nil
+	}
+	return nil, fmt.Errorf("span %d not found", spanId)
 }