Remove whitespaces and merge version number

Author: ranchalp

core/types/block.go

@@ -421,6 +421,7 @@ func CalcUncleHash(uncles []*Header) common.Hash {
 // the sealed one.
 func (b *Block) WithSeal(header *Header) *Block {
 	cpy := *header
+
 	return &Block{
 		header:       &cpy,
 		transactions: b.transactions,

eth/backend.go

@@ -153,7 +153,6 @@ func New(stack *node.Node, config *ethconfig.Config, l1Client l1.Client) (*Ether
 	if err := pruner.RecoverPruning(stack.ResolvePath(""), chainDb, stack.ResolvePath(config.TrieCleanCacheJournal)); err != nil {
 		log.Error("Failed to recover state", "error", err)
 	}
-
 	eth := &Ethereum{
 		config:            config,
 		chainDb:           chainDb,
@@ -279,7 +278,7 @@ func New(stack *node.Node, config *ethconfig.Config, l1Client l1.Client) (*Ether
 	}); err != nil {
 		return nil, err
 	}
-  
+
 	config.Miner.SigningDisabled = config.DA.ProduceBlocks
 	eth.miner = miner.New(eth, &config.Miner, eth.blockchain.Config(), eth.EventMux(), eth.engine, eth.isLocalBlock, config.EnableDASyncing && !config.DA.ProduceBlocks)
   // Some of the extraData is used with Clique consensus (before EuclidV2). After EuclidV2 we use SystemContract consensus where this is overridden when creating a block.

eth/downloader/queue.go

@@ -477,9 +477,9 @@ func (q *queue) ReserveReceipts(p *peerConnection, count int) (*fetchRequest, bo
 // to access the queue, so they already need a lock anyway.
 //
 // Returns:
-//	item     - the fetchRequest
-//	progress - whether any progress was made
-//	throttle - if the caller should throttle for a while
+//   item     - the fetchRequest
+//   progress - whether any progress was made
+//   throttle - if the caller should throttle for a while
 func (q *queue) reserveHeaders(p *peerConnection, count int, taskPool map[common.Hash]*types.Header, taskQueue *prque.Prque,
 	pendPool map[string]*fetchRequest, kind uint) (*fetchRequest, bool, bool) {
 	// Short circuit if the pool has been depleted, or if the peer's already

eth/protocols/eth/handlers.go

@@ -19,6 +19,7 @@ package eth
 import (
 	"encoding/json"
 	"fmt"
+
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/log"

les/downloader/downloader.go

@@ -705,11 +705,9 @@ func (d *Downloader) fetchHead(p *peerConnection) (head *types.Header, pivot *ty
 // calculateRequestSpan calculates what headers to request from a peer when trying to determine the
 // common ancestor.
 // It returns parameters to be used for peer.RequestHeadersByNumber:
-//
-//	from - starting block number
-//	count - number of headers to request
-//	skip - number of headers to skip
-//
+//  from - starting block number
+//  count - number of headers to request
+//  skip - number of headers to skip
 // and also returns 'max', the last block which is expected to be returned by the remote peers,
 // given the (from,count,skip)
 func calculateRequestSpan(remoteHeight, localHeight uint64) (int64, int, int, uint64) {
@@ -1324,22 +1322,22 @@ func (d *Downloader) fetchReceipts(from uint64) error {
 // various callbacks to handle the slight differences between processing them.
 //
 // The instrumentation parameters:
-//   - errCancel:   error type to return if the fetch operation is cancelled (mostly makes logging nicer)
-//   - deliveryCh:  channel from which to retrieve downloaded data packets (merged from all concurrent peers)
-//   - deliver:     processing callback to deliver data packets into type specific download queues (usually within `queue`)
-//   - wakeCh:      notification channel for waking the fetcher when new tasks are available (or sync completed)
-//   - expire:      task callback method to abort requests that took too long and return the faulty peers (traffic shaping)
-//   - pending:     task callback for the number of requests still needing download (detect completion/non-completability)
-//   - inFlight:    task callback for the number of in-progress requests (wait for all active downloads to finish)
-//   - throttle:    task callback to check if the processing queue is full and activate throttling (bound memory use)
-//   - reserve:     task callback to reserve new download tasks to a particular peer (also signals partial completions)
-//   - fetchHook:   tester callback to notify of new tasks being initiated (allows testing the scheduling logic)
-//   - fetch:       network callback to actually send a particular download request to a physical remote peer
-//   - cancel:      task callback to abort an in-flight download request and allow rescheduling it (in case of lost peer)
-//   - capacity:    network callback to retrieve the estimated type-specific bandwidth capacity of a peer (traffic shaping)
-//   - idle:        network callback to retrieve the currently (type specific) idle peers that can be assigned tasks
-//   - setIdle:     network callback to set a peer back to idle and update its estimated capacity (traffic shaping)
-//   - kind:        textual label of the type being downloaded to display in log messages
+//  - errCancel:   error type to return if the fetch operation is cancelled (mostly makes logging nicer)
+//  - deliveryCh:  channel from which to retrieve downloaded data packets (merged from all concurrent peers)
+//  - deliver:     processing callback to deliver data packets into type specific download queues (usually within `queue`)
+//  - wakeCh:      notification channel for waking the fetcher when new tasks are available (or sync completed)
+//  - expire:      task callback method to abort requests that took too long and return the faulty peers (traffic shaping)
+//  - pending:     task callback for the number of requests still needing download (detect completion/non-completability)
+//  - inFlight:    task callback for the number of in-progress requests (wait for all active downloads to finish)
+//  - throttle:    task callback to check if the processing queue is full and activate throttling (bound memory use)
+//  - reserve:     task callback to reserve new download tasks to a particular peer (also signals partial completions)
+//  - fetchHook:   tester callback to notify of new tasks being initiated (allows testing the scheduling logic)
+//  - fetch:       network callback to actually send a particular download request to a physical remote peer
+//  - cancel:      task callback to abort an in-flight download request and allow rescheduling it (in case of lost peer)
+//  - capacity:    network callback to retrieve the estimated type-specific bandwidth capacity of a peer (traffic shaping)
+//  - idle:        network callback to retrieve the currently (type specific) idle peers that can be assigned tasks
+//  - setIdle:     network callback to set a peer back to idle and update its estimated capacity (traffic shaping)
+//  - kind:        textual label of the type being downloaded to display in log messages
 func (d *Downloader) fetchParts(deliveryCh chan dataPack, deliver func(dataPack) (int, error), wakeCh chan bool,
 	expire func() map[string]int, pending func() int, inFlight func() bool, reserve func(*peerConnection, int) (*fetchRequest, bool, bool),
 	fetchHook func([]*types.Header), fetch func(*peerConnection, *fetchRequest) error, cancel func(*fetchRequest), capacity func(*peerConnection) int,

les/downloader/queue.go

@@ -477,10 +477,9 @@ func (q *queue) ReserveReceipts(p *peerConnection, count int) (*fetchRequest, bo
 // to access the queue, so they already need a lock anyway.
 //
 // Returns:
-//
-//	item     - the fetchRequest
-//	progress - whether any progress was made
-//	throttle - if the caller should throttle for a while
+//   item     - the fetchRequest
+//   progress - whether any progress was made
+//   throttle - if the caller should throttle for a while
 func (q *queue) reserveHeaders(p *peerConnection, count int, taskPool map[common.Hash]*types.Header, taskQueue *prque.Prque,
 	pendPool map[string]*fetchRequest, kind uint) (*fetchRequest, bool, bool) {
 	// Short circuit if the pool has been depleted, or if the peer's already

les/downloader/resultstore.go

@@ -71,11 +71,10 @@ func (r *resultStore) SetThrottleThreshold(threshold uint64) uint64 {
 // wants to reserve headers for fetching.
 //
 // It returns the following:
-//
-//	stale     - if true, this item is already passed, and should not be requested again
-//	throttled - if true, the store is at capacity, this particular header is not prio now
-//	item      - the result to store data into
-//	err       - any error that occurred
+//   stale     - if true, this item is already passed, and should not be requested again
+//   throttled - if true, the store is at capacity, this particular header is not prio now
+//   item      - the result to store data into
+//   err       - any error that occurred
 func (r *resultStore) AddFetch(header *types.Header, fastSync bool) (stale, throttled bool, item *fetchResult, err error) {
 	r.lock.Lock()
 	defer r.lock.Unlock()

miner/scroll_worker.go

@@ -371,6 +371,7 @@ func (w *worker) mainLoop() {
 			log.Error("failed to mine block", "err", err)
 			w.current = nil
 		}
+
 		idleStart := time.Now()
 		select {
 		case <-w.startCh:
@@ -560,7 +561,6 @@ func (w *worker) newWork(now time.Time, parentHash common.Hash, reorging bool, r
 // tryCommitNewWork
 func (w *worker) tryCommitNewWork(now time.Time, parent common.Hash, reorging bool, reorgReason error) (common.Hash, error) {
 	err := w.newWork(now, parent, reorging, reorgReason)
-
 	if err != nil {
 		return common.Hash{}, fmt.Errorf("failed creating new work: %w", err)
 	}

params/version.go

@@ -24,7 +24,7 @@ import (
 const (
 	VersionMajor = 5         // Major version component of the current release
 	VersionMinor = 8         // Minor version component of the current release
-	VersionPatch = 14        // Patch version component of the current release
+	VersionPatch = 13        // Patch version component of the current release
 	VersionMeta  = "mainnet" // Version metadata to append to the version string
 )