Merge branch 'develop' into shivam/upstream-geth-1.13.5

accounts/abi/bind/bind_test.go

@@ -1677,7 +1677,7 @@ var bindTests = []struct {
 			}
 			sim.Commit()
 
-			// This test the existence of the free retreiver call for view and pure functions
+			// This test the existence of the free retriever call for view and pure functions
 			if num, err := pav.PureFunc(nil); err != nil {
 				t.Fatalf("Failed to call anonymous field retriever: %v", err)
 			} else if num.Cmp(big.NewInt(42)) != 0 {

accounts/keystore/watch.go

@@ -133,7 +133,7 @@ func (w *watcher) loop() {
 				return
 			}
 
-			log.Info("Filsystem watcher error", "err", err)
+			log.Info("Filesystem watcher error", "err", err)
 		case <-debounce.C:
 			w.ac.scanAccounts()
 

accounts/scwallet/hub.go

@@ -256,7 +256,7 @@ func (hub *Hub) refreshWallets() {
 
 			continue
 		}
-		// Card connected, start tracking in amongs the wallets
+		// Card connected, start tracking in amongst the wallets
 		hub.wallets[reader] = wallet
 		events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletArrived})
 	}

builder/files/genesis-mainnet-v1.json

@@ -17,7 +17,6 @@
     "bor": {
       "jaipurBlock": 23850000,
       "delhiBlock": 38189056,
-      "parallelUniverseBlock": 0,
       "indoreBlock": 44934656,
       "stateSyncConfirmationDelay": {
         "44934656": 128

builder/files/genesis-testnet-v4.json

@@ -17,7 +17,6 @@
     "bor": {
       "jaipurBlock": 22770000,
       "delhiBlock": 29638656,
-      "parallelUniverseBlock": 0,
       "indoreBlock": 37075456,
       "stateSyncConfirmationDelay": {
         "37075456": 128

cmd/evm/testdata/3/readme.md

@@ -1,6 +1,2 @@
-<<<<<<< HEAD
 These files examplify a transition where a transaction (executed on block 5) requests
-=======
+the blockhash for block `1`.
-These files exemplify a transition where a transaction (executed on block 5) requests
->>>>>>> bed84606583893fdb698cc1b5058cc47b4dbd837
-the blockhash for block `1`. 

cmd/evm/testdata/4/readme.md

@@ -1,7 +1,3 @@
-<<<<<<< HEAD
-These files examplify a transition where a transaction (executed on block 5) requests
-=======
 These files exemplify a transition where a transaction (executed on block 5) requests
->>>>>>> bed84606583893fdb698cc1b5058cc47b4dbd837
+the blockhash for block `4`, but where the hash for that block is missing.
-the blockhash for block `4`, but where the hash for that block is missing. 
 It's expected that executing these should cause `exit` with errorcode `4`.

consensus/bor/bor.go

@@ -353,7 +353,7 @@ func (c *Bor) verifyHeader(chain consensus.ChainHeaderReader, header *types.Head
 	isSprintEnd := IsSprintStart(number+1, c.config.CalculateSprint(number))
 
 	// Ensure that the extra-data contains a signer list on checkpoint, but none otherwise
-	signersBytes := len(header.GetValidatorBytes(c.config))
+	signersBytes := len(header.GetValidatorBytes(c.chainConfig))
 
 	if !isSprintEnd && signersBytes != 0 {
 		return errExtraValidators
@@ -472,7 +472,7 @@ func (c *Bor) verifyCascadingFields(chain consensus.ChainHeaderReader, header *t
 
 		sort.Sort(valset.ValidatorsByAddress(newValidators))
 
-		headerVals, err := valset.ParseValidators(header.GetValidatorBytes(c.config))
+		headerVals, err := valset.ParseValidators(header.GetValidatorBytes(c.chainConfig))
 		if err != nil {
 			return err
 		}
@@ -490,7 +490,7 @@ func (c *Bor) verifyCascadingFields(chain consensus.ChainHeaderReader, header *t
 
 	// verify the validator list in the last sprint block
 	if IsSprintStart(number, c.config.CalculateSprint(number)) {
-		parentValidatorBytes := parent.GetValidatorBytes(c.config)
+		parentValidatorBytes := parent.GetValidatorBytes(c.chainConfig)
 		validatorsBytes := make([]byte, len(snap.ValidatorSet.Validators)*validatorHeaderBytesLength)
 
 		currentValidators := snap.ValidatorSet.Copy().Validators
@@ -521,7 +521,7 @@ func (c *Bor) snapshot(chain consensus.ChainHeaderReader, number uint64, hash co
 		val := valset.NewValidator(signer, 1000)
 		validatorset := valset.NewValidatorSet([]*valset.Validator{val})
 
-		snapshot := newSnapshot(c.config, c.signatures, number, hash, validatorset.Validators)
+		snapshot := newSnapshot(c.chainConfig, c.signatures, number, hash, validatorset.Validators)
 
 		return snapshot, nil
 	}
@@ -541,7 +541,7 @@ func (c *Bor) snapshot(chain consensus.ChainHeaderReader, number uint64, hash co
 
 		// If an on-disk checkpoint snapshot can be found, use that
 		if number%checkpointInterval == 0 {
-			if s, err := loadSnapshot(c.config, c.signatures, c.db, hash); err == nil {
+			if s, err := loadSnapshot(c.chainConfig, c.config, c.signatures, c.db, hash); err == nil {
 				log.Trace("Loaded snapshot from disk", "number", number, "hash", hash)
 
 				snap = s
@@ -570,7 +570,7 @@ func (c *Bor) snapshot(chain consensus.ChainHeaderReader, number uint64, hash co
 				}
 
 				// new snap shot
-				snap = newSnapshot(c.config, c.signatures, number, hash, validators)
+				snap = newSnapshot(c.chainConfig, c.signatures, number, hash, validators)
 				if err := snap.store(c.db); err != nil {
 					return nil, err
 				}
@@ -742,7 +742,7 @@ func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header) e
 		// sort validator by address
 		sort.Sort(valset.ValidatorsByAddress(newValidators))
 
-		if c.config.IsParallelUniverse(header.Number) {
+		if c.chainConfig.IsCancun(header.Number) {
 			var tempValidatorBytes []byte
 
 			for _, validator := range newValidators {
@@ -766,7 +766,7 @@ func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header) e
 				header.Extra = append(header.Extra, validator.HeaderBytes()...)
 			}
 		}
-	} else if c.config.IsParallelUniverse(header.Number) {
+	} else if c.chainConfig.IsCancun(header.Number) {
 		blockExtraData := &types.BlockExtraData{
 			ValidatorBytes: nil,
 			TxDependency:   nil,
@@ -883,10 +883,6 @@ func (c *Bor) changeContractCodeIfNeeded(headerNumber uint64, state *state.State
 			for addr, account := range allocs {
 				log.Info("change contract code", "address", addr)
 				state.SetCode(addr, account.Code)
-
-				if state.GetBalance(addr).Cmp(big.NewInt(0)) == 0 {
-					state.SetBalance(addr, account.Balance)
-				}
 			}
 		}
 	}

consensus/bor/bor_test.go

@@ -41,12 +41,6 @@ func TestGenesisContractChange(t *testing.T) {
 						"balance": "0x1000",
 					},
 				},
-				"6": map[string]interface{}{
-					addr0.Hex(): map[string]interface{}{
-						"code":    hexutil.Bytes{0x1, 0x4},
-						"balance": "0x2000",
-					},
-				},
 			},
 		},
 	}
@@ -93,35 +87,24 @@ func TestGenesisContractChange(t *testing.T) {
 
 	root := genesis.Root()
 
-	// code does not change, balance remains 0
+	// code does not change
 	root, statedb = addBlock(root, 1)
 	require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x1})
-	require.Equal(t, statedb.GetBalance(addr0), big.NewInt(0))
 
-	// code changes 1st time, balance remains 0
+	// code changes 1st time
 	root, statedb = addBlock(root, 2)
 	require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x2})
-	require.Equal(t, statedb.GetBalance(addr0), big.NewInt(0))
 
-	// code same as 1st change, balance remains 0
+	// code same as 1st change
 	root, statedb = addBlock(root, 3)
 	require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x2})
+
+	// code changes 2nd time
+	_, statedb = addBlock(root, 4)
+	require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x3})
+
+	// make sure balance change DOES NOT take effect
 	require.Equal(t, statedb.GetBalance(addr0), big.NewInt(0))
-
-	// code changes 2nd time, balance updates to 4096
-	root, statedb = addBlock(root, 4)
-	require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x3})
-	require.Equal(t, statedb.GetBalance(addr0), big.NewInt(4096))
-
-	// code same as 2nd change, balance remains 4096
-	root, statedb = addBlock(root, 5)
-	require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x3})
-	require.Equal(t, statedb.GetBalance(addr0), big.NewInt(4096))
-
-	// code changes 3rd time, balance remains 4096
-	_, statedb = addBlock(root, 6)
-	require.Equal(t, statedb.GetCode(addr0), []byte{0x1, 0x4})
-	require.Equal(t, statedb.GetBalance(addr0), big.NewInt(4096))
 }
 
 func TestEncodeSigHeaderJaipur(t *testing.T) {

consensus/bor/heimdall/client.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"path"
 	"sort"
 	"time"
 
@@ -420,7 +421,7 @@ func makeURL(urlString, rawPath, rawQuery string) (*url.URL, error) {
 		return nil, err
 	}
 
-	u.Path = rawPath
+	u.Path = path.Join(u.Path, rawPath)
 	u.RawQuery = rawQuery
 
 	return u, err

consensus/bor/heimdall/client_test.go

@@ -256,8 +256,8 @@ func TestFetchShutdown(t *testing.T) {
 
 	// Expect this to fail due to timeout
 	_, err = client.FetchCheckpoint(ctx, -1)
-	require.Equal(t, "context deadline exceeded", err.Error(), "expect the function error to be a context deadline exeeded error")
+	require.Equal(t, "context deadline exceeded", err.Error(), "expect the function error to be a context deadline exceeded error")
-	require.Equal(t, "context deadline exceeded", ctx.Err().Error(), "expect the ctx error to be a context deadline exeeded error")
+	require.Equal(t, "context deadline exceeded", ctx.Err().Error(), "expect the ctx error to be a context deadline exceeded error")
 
 	cancel()
 
@@ -346,7 +346,7 @@ func TestContext(t *testing.T) {
 		select {
 		case <-ctx.Done():
 			// Expect this to never occur, throw explicit error
-			errCh <- errors.New("unexpectecd call to `ctx.Done()`")
+			errCh <- errors.New("unexpected call to `ctx.Done()`")
 		case <-time.After(2 * time.Second):
 			// Case for safely exiting the tests
 			errCh <- nil
@@ -399,7 +399,7 @@ func TestSpanURL(t *testing.T) {
 	const expected = "http://bor0/bor/span/1"
 
 	if url.String() != expected {
-		t.Fatalf("expected URL %q, got %q", url.String(), expected)
+		t.Fatalf("expected URL %q, got %q", expected, url.String())
 	}
 }
 
@@ -414,6 +414,6 @@ func TestStateSyncURL(t *testing.T) {
 	const expected = "http://bor0/clerk/event-record/list?from-id=10&to-time=100&limit=50"
 
 	if url.String() != expected {
-		t.Fatalf("expected URL %q, got %q", url.String(), expected)
+		t.Fatalf("expected URL %q, got %q", expected, url.String())
 	}
 }

consensus/bor/snapshot.go

@@ -15,8 +15,9 @@ import (
 
 // Snapshot is the state of the authorization voting at a given point in time.
 type Snapshot struct {
-	config   *params.BorConfig // Consensus engine parameters to fine tune behavior
+	chainConfig *params.ChainConfig
-	sigcache *lru.ARCCache     // Cache of recent block signatures to speed up ecrecover
+
+	sigcache *lru.ARCCache // Cache of recent block signatures to speed up ecrecover
 
 	Number       uint64                    `json:"number"`       // Block number where the snapshot was created
 	Hash         common.Hash               `json:"hash"`         // Block hash where the snapshot was created
@@ -28,14 +29,14 @@ type Snapshot struct {
 // method does not initialize the set of recent signers, so only ever use if for
 // the genesis block.
 func newSnapshot(
-	config *params.BorConfig,
+	chainConfig *params.ChainConfig,
 	sigcache *lru.ARCCache,
 	number uint64,
 	hash common.Hash,
 	validators []*valset.Validator,
 ) *Snapshot {
 	snap := &Snapshot{
-		config:       config,
+		chainConfig:  chainConfig,
 		sigcache:     sigcache,
 		Number:       number,
 		Hash:         hash,
@@ -47,7 +48,7 @@ func newSnapshot(
 }
 
 // loadSnapshot loads an existing snapshot from the database.
-func loadSnapshot(config *params.BorConfig, sigcache *lru.ARCCache, db ethdb.Database, hash common.Hash) (*Snapshot, error) {
+func loadSnapshot(chainConfig *params.ChainConfig, config *params.BorConfig, sigcache *lru.ARCCache, db ethdb.Database, hash common.Hash) (*Snapshot, error) {
 	blob, err := db.Get(append([]byte("bor-"), hash[:]...))
 	if err != nil {
 		return nil, err
@@ -61,7 +62,7 @@ func loadSnapshot(config *params.BorConfig, sigcache *lru.ARCCache, db ethdb.Dat
 
 	snap.ValidatorSet.UpdateValidatorMap()
 
-	snap.config = config
+	snap.chainConfig = chainConfig
 	snap.sigcache = sigcache
 
 	// update total voting power
@@ -85,7 +86,7 @@ func (s *Snapshot) store(db ethdb.Database) error {
 // copy creates a deep copy of the snapshot, though not the individual votes.
 func (s *Snapshot) copy() *Snapshot {
 	cpy := &Snapshot{
-		config:       s.config,
+		chainConfig:  s.chainConfig,
 		sigcache:     s.sigcache,
 		Number:       s.Number,
 		Hash:         s.Hash,
@@ -122,12 +123,12 @@ func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) {
 		number := header.Number.Uint64()
 
 		// Delete the oldest signer from the recent list to allow it signing again
-		if number >= s.config.CalculateSprint(number) {
+		if number >= s.chainConfig.Bor.CalculateSprint(number) {
-			delete(snap.Recents, number-s.config.CalculateSprint(number))
+			delete(snap.Recents, number-s.chainConfig.Bor.CalculateSprint(number))
 		}
 
 		// Resolve the authorization key and check against signers
-		signer, err := ecrecover(header, s.sigcache, s.config)
+		signer, err := ecrecover(header, s.sigcache, s.chainConfig.Bor)
 		if err != nil {
 			return nil, err
 		}
@@ -145,12 +146,12 @@ func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) {
 		snap.Recents[number] = signer
 
 		// change validator set and change proposer
-		if number > 0 && (number+1)%s.config.CalculateSprint(number) == 0 {
+		if number > 0 && (number+1)%s.chainConfig.Bor.CalculateSprint(number) == 0 {
 			if err := validateHeaderExtraField(header.Extra); err != nil {
 				return nil, err
 			}
 
-			validatorBytes := header.GetValidatorBytes(s.config)
+			validatorBytes := header.GetValidatorBytes(s.chainConfig)
 
 			// get validators from headers and use that for new validator set
 			newVals, _ := valset.ParseValidators(validatorBytes)

core/blockchain.go

@@ -451,7 +451,8 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
 	// The first thing the node will do is reconstruct the verification data for
 	// the head block (ethash cache or clique voting snapshot). Might as well do
 	// it in advance.
-	bc.engine.VerifyHeader(bc, bc.CurrentHeader())
+	// BOR - commented out intentionally
+	// bc.engine.VerifyHeader(bc, bc.CurrentHeader())
 
 	// Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain
 	for hash := range BadHashes {
@@ -2111,7 +2112,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error)
 		// The chain importer is starting and stopping trie prefetchers. If a bad
 		// block or other error is hit however, an early return may not properly
 		// terminate the background threads. This defer ensures that we clean up
-		// and dangling prefetcher, without defering each and holding on live refs.
+		// and dangling prefetcher, without deferring each and holding on live refs.
 		if activeState != nil {
 			activeState.StopPrefetcher()
 		}
@@ -2198,15 +2199,6 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool) (int, error)
 			parent = bc.GetHeader(block.ParentHash(), block.NumberU64()-1)
 		}
 
-		statedb, err := state.New(parent.Root, bc.stateCache, bc.snaps)
-		if err != nil {
-			return it.index, err
-		}
-
-		// Enable prefetching to pull in trie node paths while processing transactions
-		statedb.StartPrefetcher("chain")
-		activeState = statedb
-
 		// If we have a followup block, run that against the current state to pre-cache
 		// transactions and probabilistically some of the account/storage trie nodes.
 		var followupInterrupt atomic.Bool
@@ -2763,6 +2755,12 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Block) error {
 
 		log.Error("Impossible reorg, please file an issue", "oldnum", oldBlock.Number(), "oldhash", oldBlock.Hash(), "oldblocks", len(oldChain), "newnum", newBlock.Number(), "newhash", newBlock.Hash(), "newblocks", len(newChain))
 	}
+	// Reset the tx lookup cache in case to clear stale txlookups.
+	// This is done before writing any new chain data to avoid the
+	// weird scenario that canonical chain is changed while the
+	// stale lookups are still cached.
+	bc.txLookupCache.Purge()
+
 	// Insert the new chain(except the head block(reverse order)),
 	// taking care of the proper incremental order.
 	for i := len(newChain) - 1; i >= 1; i-- {
@@ -2777,11 +2775,13 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Block) error {
 
 	// Delete useless indexes right now which includes the non-canonical
 	// transaction indexes, canonical chain indexes which above the head.
-	indexesBatch := bc.db.NewBatch()
+	var (
-	for _, tx := range types.HashDifference(deletedTxs, addedTxs) {
+		indexesBatch = bc.db.NewBatch()
+		diffs        = types.HashDifference(deletedTxs, addedTxs)
+	)
+	for _, tx := range diffs {
 		rawdb.DeleteTxLookupEntry(indexesBatch, tx)
 	}
-
 	// Delete all hash markers that are not part of the new canonical chain.
 	// Because the reorg function does not handle new chain head, all hash
 	// markers greater than or equal to new chain head should be deleted.

core/blockstm/mvhashmap.go

@@ -121,34 +121,23 @@ func (mv *MVHashMap) Write(k Key, v Version, data interface{}) {
 		return
 	})
 
-	cells.rw.RLock()
+	cells.rw.Lock()
-	ci, ok := cells.tm.Get(v.TxnIndex)
+	if ci, ok := cells.tm.Get(v.TxnIndex); !ok {
-	cells.rw.RUnlock()
+		cells.tm.Put(v.TxnIndex, &WriteCell{
-
+			flag:        FlagDone,
-	if ok {
+			incarnation: v.Incarnation,
+			data:        data,
+		})
+	} else {
 		if ci.(*WriteCell).incarnation > v.Incarnation {
 			panic(fmt.Errorf("existing transaction value does not have lower incarnation: %v, %v",
 				k, v.TxnIndex))
 		}
-
 		ci.(*WriteCell).flag = FlagDone
 		ci.(*WriteCell).incarnation = v.Incarnation
 		ci.(*WriteCell).data = data
-	} else {
-		cells.rw.Lock()
-		if ci, ok = cells.tm.Get(v.TxnIndex); !ok {
-			cells.tm.Put(v.TxnIndex, &WriteCell{
-				flag:        FlagDone,
-				incarnation: v.Incarnation,
-				data:        data,
-			})
-		} else {
-			ci.(*WriteCell).flag = FlagDone
-			ci.(*WriteCell).incarnation = v.Incarnation
-			ci.(*WriteCell).data = data
-		}
-		cells.rw.Unlock()
 	}
+	cells.rw.Unlock()
 }
 
 func (mv *MVHashMap) ReadStorage(k Key, fallBack func() any) any {
@@ -166,13 +155,13 @@ func (mv *MVHashMap) MarkEstimate(k Key, txIdx int) {
 		panic(fmt.Errorf("path must already exist"))
 	})
 
-	cells.rw.RLock()
+	cells.rw.Lock()
 	if ci, ok := cells.tm.Get(txIdx); !ok {
 		panic(fmt.Sprintf("should not happen - cell should be present for path. TxIdx: %v, path, %x, cells keys: %v", txIdx, k, cells.tm.Keys()))
 	} else {
 		ci.(*WriteCell).flag = FlagEstimate
 	}
-	cells.rw.RUnlock()
+	cells.rw.Unlock()
 }
 
 func (mv *MVHashMap) Delete(k Key, txIdx int) {
@@ -233,8 +222,8 @@ func (mv *MVHashMap) Read(k Key, txIdx int) (res MVReadResult) {
 	}
 
 	cells.rw.RLock()
+
 	fk, fv := cells.tm.Floor(txIdx - 1)
-	cells.rw.RUnlock()
 
 	if fk != nil && fv != nil {
 		c := fv.(*WriteCell)
@@ -253,6 +242,8 @@ func (mv *MVHashMap) Read(k Key, txIdx int) (res MVReadResult) {
 		}
 	}
 
+	cells.rw.RUnlock()
+
 	return
 }
 

core/parallel_state_processor.go

@@ -288,6 +288,11 @@ func (p *ParallelStateProcessor) Process(block *types.Block, statedb *state.Stat
 
 	deps := GetDeps(blockTxDependency)
 
+	if !VerifyDeps(deps) || len(blockTxDependency) != len(block.Transactions()) {
+		blockTxDependency = nil
+		deps = make(map[int][]int)
+	}
+
 	if blockTxDependency != nil {
 		metadata = true
 	}
@@ -308,57 +313,30 @@ func (p *ParallelStateProcessor) Process(block *types.Block, statedb *state.Stat
 			shouldDelayFeeCal = false
 		}
 
-		if len(blockTxDependency) != len(block.Transactions()) {
+		task := &ExecutionTask{
-			task := &ExecutionTask{
+			msg:               *msg,
-				msg:               *msg,
+			config:            p.config,
-				config:            p.config,
+			gasLimit:          block.GasLimit(),
-				gasLimit:          block.GasLimit(),
+			blockNumber:       blockNumber,
-				blockNumber:       blockNumber,
+			blockHash:         blockHash,
-				blockHash:         blockHash,
+			tx:                tx,
-				tx:                tx,
+			index:             i,
-				index:             i,
+			cleanStateDB:      cleansdb,
-				cleanStateDB:      cleansdb,
+			finalStateDB:      statedb,
-				finalStateDB:      statedb,
+			blockChain:        p.bc,
-				blockChain:        p.bc,
+			header:            header,
-				header:            header,
+			evmConfig:         cfg,
-				evmConfig:         cfg,
+			shouldDelayFeeCal: &shouldDelayFeeCal,
-				shouldDelayFeeCal: &shouldDelayFeeCal,
+			sender:            msg.From,
-				sender:            msg.From,
+			totalUsedGas:      usedGas,
-				totalUsedGas:      usedGas,
+			receipts:          &receipts,
-				receipts:          &receipts,
+			allLogs:           &allLogs,
-				allLogs:           &allLogs,
+			dependencies:      deps[i],
-				dependencies:      deps[i],
+			coinbase:          coinbase,
-				coinbase:          coinbase,
+			blockContext:      blockContext,
-				blockContext:      blockContext,
-			}
-
-			tasks = append(tasks, task)
-		} else {
-			task := &ExecutionTask{
-				msg:               *msg,
-				config:            p.config,
-				gasLimit:          block.GasLimit(),
-				blockNumber:       blockNumber,
-				blockHash:         blockHash,
-				tx:                tx,
-				index:             i,
-				cleanStateDB:      cleansdb,
-				finalStateDB:      statedb,
-				blockChain:        p.bc,
-				header:            header,
-				evmConfig:         cfg,
-				shouldDelayFeeCal: &shouldDelayFeeCal,
-				sender:            msg.From,
-				totalUsedGas:      usedGas,
-				receipts:          &receipts,
-				allLogs:           &allLogs,
-				dependencies:      nil,
-				coinbase:          coinbase,
-				blockContext:      blockContext,
-			}
-
-			tasks = append(tasks, task)
 		}
+
+		tasks = append(tasks, task)
 	}
 
 	backupStateDB := statedb.Copy()
@@ -427,3 +405,21 @@ func GetDeps(txDependency [][]uint64) map[int][]int {
 
 	return deps
 }
+
+// returns true if dependencies are correct
+func VerifyDeps(deps map[int][]int) bool {
+	// number of transactions in the block
+	n := len(deps)
+
+	// Handle out-of-range and circular dependency problem
+	for i := 0; i <= n-1; i++ {
+		val := deps[i]
+		for _, depTx := range val {
+			if depTx >= n || depTx >= i {
+				return false
+			}
+		}
+	}
+
+	return true
+}

core/parallel_state_processor_test.go

@@ -0,0 +1,30 @@
+package core
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMetadata(t *testing.T) {
+	t.Parallel()
+
+	correctTxDependency := [][]uint64{{}, {0}, {}, {1}, {3}, {}, {0, 2}, {5}, {}, {8}}
+	wrongTxDependency := [][]uint64{{0}}
+	wrongTxDependencyCircular := [][]uint64{{}, {2}, {1}}
+	wrongTxDependencyOutOfRange := [][]uint64{{}, {}, {3}}
+
+	var temp map[int][]int
+
+	temp = GetDeps(correctTxDependency)
+	assert.Equal(t, true, VerifyDeps(temp))
+
+	temp = GetDeps(wrongTxDependency)
+	assert.Equal(t, false, VerifyDeps(temp))
+
+	temp = GetDeps(wrongTxDependencyCircular)
+	assert.Equal(t, false, VerifyDeps(temp))
+
+	temp = GetDeps(wrongTxDependencyOutOfRange)
+	assert.Equal(t, false, VerifyDeps(temp))
+}

core/rawdb/bor_receipt.go

@@ -76,7 +76,7 @@ func ReadRawBorReceipt(db ethdb.Reader, hash common.Hash, number uint64) *types.
 }
 
 // ReadBorReceipt retrieves all the bor block receipts belonging to a block, including
-// its correspoinding metadata fields. If it is unable to populate these metadata
+// its corresponding metadata fields. If it is unable to populate these metadata
 // fields then nil is returned.
 func ReadBorReceipt(db ethdb.Reader, hash common.Hash, number uint64, config *params.ChainConfig) *types.Receipt {
 	if config != nil && config.Bor != nil && config.Bor.Sprint != nil && !config.Bor.IsSprintStart(number) {

core/rawdb/freezer_table_test.go

@@ -917,7 +917,7 @@ func getChunk(size int, b int) []byte {
 }
 
 // TODO (?)
-// - test that if we remove several head-files, aswell as data last data-file,
+// - test that if we remove several head-files, as well as data last data-file,
 //   the index is truncated accordingly
 // Right now, the freezer would fail on these conditions:
 // 1. have data files d0, d1, d2, d3

core/state/pruner/pruner.go

@@ -103,12 +103,10 @@ func NewPruner(db ethdb.Database, config Config) (*Pruner, error) {
 		log.Warn("Sanitizing bloomfilter size", "provided(MB)", config.BloomSize, "updated(MB)", 256)
 		config.BloomSize = 256
 	}
-
 	stateBloom, err := newStateBloomWithSize(config.BloomSize)
 	if err != nil {
 		return nil, err
 	}
-
 	return &Pruner{
 		config:      config,
 		chainHeader: headBlock.Header(),
@@ -123,7 +121,7 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta
 	// the trie nodes(and codes) belong to the active state will be filtered
 	// out. A very small part of stale tries will also be filtered because of
 	// the false-positive rate of bloom filter. But the assumption is held here
-	// that the false-positive is low enough(~0.05%). The probablity of the
+	// that the false-positive is low enough(~0.05%). The probability of the
 	// dangling node is the state root is super low. So the dangling nodes in
 	// theory will never ever be visited again.
 	var (
@@ -134,7 +132,6 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta
 		batch          = maindb.NewBatch()
 		iter           = maindb.NewIterator(nil, nil)
 	)
-
 	for iter.Next() {
 		key := iter.Key()
 
@@ -148,7 +145,6 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta
 			if isCode {
 				checkKey = codeKey
 			}
-
 			if _, exist := middleStateRoots[common.BytesToHash(checkKey)]; exist {
 				log.Debug("Forcibly delete the middle state roots", "hash", common.BytesToHash(checkKey))
 			} else {
@@ -157,26 +153,21 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta
 					continue
 				}
 			}
-
 			count += 1
 			size += common.StorageSize(len(key) + len(iter.Value()))
 			batch.Delete(key)
 
 			var eta time.Duration // Realistically will never remain uninited
-
 			if done := binary.BigEndian.Uint64(key[:8]); done > 0 {
 				var (
 					left  = math.MaxUint64 - binary.BigEndian.Uint64(key[:8])
 					speed = done/uint64(time.Since(pstart)/time.Millisecond+1) + 1 // +1s to avoid division by zero
 				)
-
 				eta = time.Duration(left/speed) * time.Millisecond
 			}
-
 			if time.Since(logged) > 8*time.Second {
 				log.Info("Pruning state data", "nodes", count, "skipped", skipped, "size", size,
 					"elapsed", common.PrettyDuration(time.Since(pstart)), "eta", common.PrettyDuration(eta))
-
 				logged = time.Now()
 			}
 			// Recreate the iterator after every batch commit in order
@@ -190,12 +181,10 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta
 			}
 		}
 	}
-
 	if batch.ValueSize() > 0 {
 		batch.Write()
 		batch.Reset()
 	}
-
 	iter.Release()
 	log.Info("Pruned state data", "nodes", count, "size", size, "elapsed", common.PrettyDuration(time.Since(pstart)))
 
@@ -222,19 +211,15 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta
 	// Note for small pruning, the compaction is skipped.
 	if count >= rangeCompactionThreshold {
 		cstart := time.Now()
-
 		for b := 0x00; b <= 0xf0; b += 0x10 {
 			var (
 				start = []byte{byte(b)}
 				end   = []byte{byte(b + 0x10)}
 			)
-
 			if b == 0xf0 {
 				end = nil
 			}
-
 			log.Info("Compacting database", "range", fmt.Sprintf("%#x-%#x", start, end), "elapsed", common.PrettyDuration(time.Since(cstart)))
-
 			if err := maindb.Compact(start, end); err != nil {
 				log.Error("Database compaction failed", "error", err)
 				return err
@@ -242,16 +227,13 @@ func prune(snaptree *snapshot.Tree, root common.Hash, maindb ethdb.Database, sta
 		}
 		log.Info("Database compaction finished", "elapsed", common.PrettyDuration(time.Since(cstart)))
 	}
-
 	log.Info("State pruning successful", "pruned", size, "elapsed", common.PrettyDuration(time.Since(start)))
-
 	return nil
 }
 
 // Prune deletes all historical state nodes except the nodes belong to the
 // specified state version. If user doesn't specify the state version, use
 // the bottom-most snapshot diff layer as the target.
-// nolint:nestif
 func (p *Pruner) Prune(root common.Hash) error {
 	// If the state bloom filter is already committed previously,
 	// reuse it for pruning instead of generating a new one. It's
@@ -261,7 +243,6 @@ func (p *Pruner) Prune(root common.Hash) error {
 	if err != nil {
 		return err
 	}
-
 	if stateBloomRoot != (common.Hash{}) {
 		return RecoverPruning(p.config.Datadir, p.db)
 	}
@@ -300,23 +281,18 @@ func (p *Pruner) Prune(root common.Hash) error {
 		// state available, but we don't want to use the topmost state
 		// as the pruning target.
 		var found bool
-
 		for i := len(layers) - 2; i >= 2; i-- {
 			if rawdb.HasLegacyTrieNode(p.db, layers[i].Root()) {
 				root = layers[i].Root()
 				found = true
-
 				log.Info("Selecting middle-layer as the pruning target", "root", root, "depth", i)
-
 				break
 			}
 		}
-
 		if !found {
 			if len(layers) > 0 {
 				return errors.New("no snapshot paired state")
 			}
-
 			return fmt.Errorf("associated state[%x] is not present", root)
 		}
 	} else {
@@ -329,18 +305,15 @@ func (p *Pruner) Prune(root common.Hash) error {
 	// All the state roots of the middle layer should be forcibly pruned,
 	// otherwise the dangling state will be left.
 	middleRoots := make(map[common.Hash]struct{})
-
 	for _, layer := range layers {
 		if layer.Root() == root {
 			break
 		}
-
 		middleRoots[layer.Root()] = struct{}{}
 	}
 	// Traverse the target state, re-construct the whole state trie and
 	// commit to the given bloom filter.
 	start := time.Now()
-
 	if err := snapshot.GenerateTrie(p.snaptree, root, p.db, p.stateBloom); err != nil {
 		return err
 	}
@@ -349,17 +322,13 @@ func (p *Pruner) Prune(root common.Hash) error {
 	if err := extractGenesis(p.db, p.stateBloom); err != nil {
 		return err
 	}
-
 	filterName := bloomFilterName(p.config.Datadir, root)
 
 	log.Info("Writing state bloom to disk", "name", filterName)
-
 	if err := p.stateBloom.Commit(filterName, filterName+stateBloomFileTempSuffix); err != nil {
 		return err
 	}
-
 	log.Info("State bloom filter committed", "name", filterName)
-
 	return prune(p.snaptree, root, p.db, p.stateBloom, filterName, middleRoots, start)
 }
 
@@ -375,11 +344,9 @@ func RecoverPruning(datadir string, db ethdb.Database) error {
 	if err != nil {
 		return err
 	}
-
 	if stateBloomPath == "" {
 		return nil // nothing to recover
 	}
-
 	headBlock := rawdb.ReadHeadBlock(db)
 	if headBlock == nil {
 		return errors.New("failed to load head block")
@@ -404,12 +371,10 @@ func RecoverPruning(datadir string, db ethdb.Database) error {
 	if err != nil {
 		return err // The relevant snapshot(s) might not exist
 	}
-
 	stateBloom, err := NewStateBloomFromDisk(stateBloomPath)
 	if err != nil {
 		return err
 	}
-
 	log.Info("Loaded state bloom filter", "path", stateBloomPath)
 
 	// All the state roots of the middle layers should be forcibly pruned,
@@ -419,21 +384,17 @@ func RecoverPruning(datadir string, db ethdb.Database) error {
 		layers      = snaptree.Snapshots(headBlock.Root(), 128, true)
 		middleRoots = make(map[common.Hash]struct{})
 	)
-
 	for _, layer := range layers {
 		if layer.Root() == stateBloomRoot {
 			found = true
 			break
 		}
-
 		middleRoots[layer.Root()] = struct{}{}
 	}
-
 	if !found {
 		log.Error("Pruning target state is not existent")
 		return errors.New("non-existent target state")
 	}
-
 	return prune(snaptree, stateBloomRoot, db, stateBloom, stateBloomPath, middleRoots, time.Now())
 }
 
@@ -444,7 +405,6 @@ func extractGenesis(db ethdb.Database, stateBloom *stateBloom) error {
 	if genesisHash == (common.Hash{}) {
 		return errors.New("missing genesis hash")
 	}
-
 	genesis := rawdb.ReadBlock(db, genesisHash, 0)
 	if genesis == nil {
 		return errors.New("missing genesis block")
@@ -471,7 +431,6 @@ func extractGenesis(db ethdb.Database, stateBloom *stateBloom) error {
 			if err := rlp.DecodeBytes(accIter.LeafBlob(), &acc); err != nil {
 				return err
 			}
-
 			if acc.Root != types.EmptyRootHash {
 				id := trie.StorageTrieID(genesis.Root(), common.BytesToHash(accIter.LeafKey()), acc.Root)
 				storageTrie, err := trie.NewStateTrie(id, trie.NewDatabase(db, trie.HashDefaults))
@@ -488,18 +447,15 @@ func extractGenesis(db ethdb.Database, stateBloom *stateBloom) error {
 						stateBloom.Put(hash.Bytes(), nil)
 					}
 				}
-
 				if storageIter.Error() != nil {
 					return storageIter.Error()
 				}
 			}
-
 			if !bytes.Equal(acc.CodeHash, types.EmptyCodeHash.Bytes()) {
 				stateBloom.Put(acc.CodeHash, nil)
 			}
 		}
 	}
-
 	return accIter.Error()
 }
 
@@ -512,7 +468,6 @@ func isBloomFilter(filename string) (bool, common.Hash) {
 	if strings.HasPrefix(filename, stateBloomFilePrefix) && strings.HasSuffix(filename, stateBloomFileSuffix) {
 		return true, common.HexToHash(filename[len(stateBloomFilePrefix)+1 : len(filename)-len(stateBloomFileSuffix)-1])
 	}
-
 	return false, common.Hash{}
 }
 
@@ -521,7 +476,6 @@ func findBloomFilter(datadir string) (string, common.Hash, error) {
 		stateBloomPath string
 		stateBloomRoot common.Hash
 	)
-
 	if err := filepath.Walk(datadir, func(path string, info os.FileInfo, err error) error {
 		if info != nil && !info.IsDir() {
 			ok, root := isBloomFilter(path)
@@ -534,6 +488,5 @@ func findBloomFilter(datadir string) (string, common.Hash, error) {
 	}); err != nil {
 		return "", common.Hash{}, err
 	}
-
 	return stateBloomPath, stateBloomRoot, nil
 }

core/state/snapshot/difflayer.go

@@ -43,7 +43,7 @@ var (
 	aggregatorMemoryLimit = uint64(4 * 1024 * 1024)
 
 	// aggregatorItemLimit is an approximate number of items that will end up
-	// in the agregator layer before it's flushed out to disk. A plain account
+	// in the aggregator layer before it's flushed out to disk. A plain account
 	// weighs around 14B (+hash), a storage slot 32B (+hash), a deleted slot
 	// 0B (+hash). Slots are mostly set/unset in lockstep, so that average at
 	// 16B (+hash). All in all, the average entry seems to be 15+32=47B. Use a

core/state/snapshot/disklayer_test.go

@@ -141,7 +141,7 @@ func TestDiskMerge(t *testing.T) {
 	// Retrieve all the data through the disk layer and validate it
 	base = snaps.Snapshot(diffRoot)
 	if _, ok := base.(*diskLayer); !ok {
-		t.Fatalf("update not flattend into the disk layer")
+		t.Fatalf("update not flattened into the disk layer")
 	}
 
 	// assertAccount ensures that an account matches the given blob.
@@ -374,7 +374,7 @@ func TestDiskPartialMerge(t *testing.T) {
 		// Retrieve all the data through the disk layer and validate it
 		base = snaps.Snapshot(diffRoot)
 		if _, ok := base.(*diskLayer); !ok {
-			t.Fatalf("test %d: update not flattend into the disk layer", i)
+			t.Fatalf("test %d: update not flattened into the disk layer", i)
 		}
 
 		assertAccount(accNoModNoCache, accNoModNoCache[:])

core/state/sync_test.go

@@ -252,7 +252,7 @@ func testIterativeStateSync(t *testing.T, count int, commit bool, bypath bool, s
 					id := trie.StorageTrieID(srcRoot, common.BytesToHash(node.syncPath[0]), acc.Root)
 					stTrie, err := trie.New(id, ndb)
 					if err != nil {
-						t.Fatalf("failed to retriev storage trie for path %x: %v", node.syncPath[1], err)
+						t.Fatalf("failed to retrieve storage trie for path %x: %v", node.syncPath[1], err)
 					}
 
 					data, _, err := stTrie.GetNode(node.syncPath[1])

core/txpool/blobpool/blobpool.go

@@ -456,7 +456,7 @@ func (p *BlobPool) parseTransaction(id uint64, size uint32, blob []byte) error {
 	tx := new(types.Transaction)
 	if err := rlp.DecodeBytes(blob, tx); err != nil {
 		// This path is impossible unless the disk data representation changes
-		// across restarts. For that ever unprobable case, recover gracefully
+		// across restarts. For that ever improbable case, recover gracefully
 		// by ignoring this data entry.
 		log.Error("Failed to decode blob pool entry", "id", id, "err", err)
 		return err
@@ -471,7 +471,7 @@ func (p *BlobPool) parseTransaction(id uint64, size uint32, blob []byte) error {
 	sender, err := p.signer.Sender(tx)
 	if err != nil {
 		// This path is impossible unless the signature validity changes across
-		// restarts. For that ever unprobable case, recover gracefully by ignoring
+		// restarts. For that ever improbable case, recover gracefully by ignoring
 		// this data entry.
 		log.Error("Failed to recover blob tx sender", "id", id, "hash", tx.Hash(), "err", err)
 		return err
@@ -711,7 +711,7 @@ func (p *BlobPool) recheck(addr common.Address, inclusions map[common.Hash]uint6
 // offload removes a tracked blob transaction from the pool and moves it into the
 // limbo for tracking until finality.
 //
-// The method may log errors for various unexpcted scenarios but will not return
+// The method may log errors for various unexpected scenarios but will not return
 // any of it since there's no clear error case. Some errors may be due to coding
 // issues, others caused by signers mining MEV stuff or swapping transactions. In
 // all cases, the pool needs to continue operating.
@@ -738,7 +738,7 @@ func (p *BlobPool) offload(addr common.Address, nonce uint64, id uint64, inclusi
 }
 
 // Reset implements txpool.SubPool, allowing the blob pool's internal state to be
-// kept in sync with the main transacion pool's internal state.
+// kept in sync with the main transaction pool's internal state.
 func (p *BlobPool) Reset(oldHead, newHead *types.Header) {
 	waitStart := time.Now()
 	p.lock.Lock()
@@ -972,7 +972,7 @@ func (p *BlobPool) reinject(addr common.Address, txhash common.Hash) error {
 }
 
 // SetGasTip implements txpool.SubPool, allowing the blob pool's gas requirements
-// to be kept in sync with the main transacion pool's gas requirements.
+// to be kept in sync with the main transaction pool's gas requirements.
 func (p *BlobPool) SetGasTip(tip *big.Int) {
 	p.lock.Lock()
 	defer p.lock.Unlock()

core/txpool/blobpool/blobpool_test.go

@@ -598,9 +598,9 @@ func TestOpenDrops(t *testing.T) {
 	verifyPoolInternals(t, pool)
 }
 
-// Tests that transactions loaded from disk are indexed corrently.
+// Tests that transactions loaded from disk are indexed correctly.
 //
-//   - 1. Transactions must be groupped by sender, sorted by nonce
+//   - 1. Transactions must be grouped by sender, sorted by nonce
 //   - 2. Eviction thresholds are calculated correctly for the sequences
 //   - 3. Balance usage of an account is totals across all transactions
 func TestOpenIndex(t *testing.T) {
@@ -1213,7 +1213,7 @@ func TestAdd(t *testing.T) {
 			keys[acc], _ = crypto.GenerateKey()
 			addrs[acc] = crypto.PubkeyToAddress(keys[acc].PublicKey)
 
-			// Seed the state database with this acocunt
+			// Seed the state database with this account
 			statedb.AddBalance(addrs[acc], new(big.Int).SetUint64(seed.balance))
 			statedb.SetNonce(addrs[acc], seed.nonce)
 

core/txpool/blobpool/limbo.go

@@ -53,7 +53,7 @@ func newLimbo(datadir string) (*limbo, error) {
 		index:  make(map[common.Hash]uint64),
 		groups: make(map[uint64]map[uint64]common.Hash),
 	}
-	// Index all limboed blobs on disk and delete anything inprocessable
+	// Index all limboed blobs on disk and delete anything unprocessable
 	var fails []uint64
 	index := func(id uint64, size uint32, data []byte) {
 		if l.parseBlob(id, data) != nil {
@@ -89,7 +89,7 @@ func (l *limbo) parseBlob(id uint64, data []byte) error {
 	item := new(limboBlob)
 	if err := rlp.DecodeBytes(data, item); err != nil {
 		// This path is impossible unless the disk data representation changes
-		// across restarts. For that ever unprobable case, recover gracefully
+		// across restarts. For that ever improbable case, recover gracefully
 		// by ignoring this data entry.
 		log.Error("Failed to decode blob limbo entry", "id", id, "err", err)
 		return err
@@ -172,7 +172,7 @@ func (l *limbo) pull(tx common.Hash) (*types.Transaction, error) {
 // update changes the block number under which a blob transaction is tracked. This
 // method should be used when a reorg changes a transaction's inclusion block.
 //
-// The method may log errors for various unexpcted scenarios but will not return
+// The method may log errors for various unexpected scenarios but will not return
 // any of it since there's no clear error case. Some errors may be due to coding
 // issues, others caused by signers mining MEV stuff or swapping transactions. In
 // all cases, the pool needs to continue operating.

core/txpool/blobpool/metrics.go

@@ -65,7 +65,7 @@ var (
 	pooltipGauge = metrics.NewRegisteredGauge("blobpool/pooltip", nil)
 
 	// addwait/time, resetwait/time and getwait/time track the rough health of
-	// the pool and wether or not it's capable of keeping up with the load from
+	// the pool and whether or not it's capable of keeping up with the load from
 	// the network.
 	addwaitHist   = metrics.NewRegisteredHistogram("blobpool/addwait", nil, metrics.NewExpDecaySample(1028, 0.015))
 	addtimeHist   = metrics.NewRegisteredHistogram("blobpool/addtime", nil, metrics.NewExpDecaySample(1028, 0.015))

core/txpool/legacypool/legacypool.go

@@ -155,8 +155,7 @@ var DefaultConfig = Config{
 	AccountQueue: 64,
 	GlobalQueue:  1024,
 
-	Lifetime:            3 * time.Hour,
+	Lifetime: 3 * time.Hour,
-	AllowUnprotectedTxs: false,
 }
 
 // sanitize checks the provided user configurations and changes anything that's
@@ -602,8 +601,7 @@ func (pool *LegacyPool) local() map[common.Address]types.Transactions {
 // and does not require the pool mutex to be held.
 func (pool *LegacyPool) validateTxBasics(tx *types.Transaction, local bool) error {
 	opts := &txpool.ValidationOptions{
-		Config:              pool.chainconfig,
+		Config: pool.chainconfig,
-		AllowUnprotectedTxs: pool.config.AllowUnprotectedTxs,
 		Accept: 0 |
 			1<<types.LegacyTxType |
 			1<<types.AccessListTxType |
@@ -673,11 +671,6 @@ func (pool *LegacyPool) add(tx *types.Transaction, local bool) (replaced bool, e
 		knownTxMeter.Mark(1)
 		return false, txpool.ErrAlreadyKnown
 	}
-
-	if pool.config.AllowUnprotectedTxs {
-		pool.signer = types.NewFakeSigner(tx.ChainId())
-	}
-
 	// Make the local flag. If it's from local source or it's from the network but
 	// the sender is marked as local previously, treat it as the local transaction.
 	isLocal := local || pool.locals.containsTx(tx)
@@ -991,11 +984,6 @@ func (pool *LegacyPool) Add(txs []*types.Transaction, local, sync bool) []error
 			knownTxMeter.Mark(1)
 			continue
 		}
-
-		if pool.config.AllowUnprotectedTxs {
-			pool.signer = types.NewFakeSigner(tx.ChainId())
-		}
-
 		// Exclude transactions with basic errors, e.g invalid signatures and
 		// insufficient intrinsic gas as soon as possible and cache senders
 		// in transactions before obtaining lock

core/txpool/legacypool/legacypool_test.go

@@ -3778,7 +3778,7 @@ func newTxs(pool *LegacyPool) *types.Transaction {
 
 // 			txCount++
 // 		} else {
-// 			// we don't maximize fulfilment of the block. just fill somehow
+// 			// we don't maximize fulfillment of the block. just fill somehow
 // 			return blockGasLimit, txCount
 // 		}
 // 	}

core/txpool/subpool.go

@@ -69,7 +69,7 @@ type AddressReserver func(addr common.Address, reserve bool) error
 // production, this interface defines the common methods that allow the primary
 // transaction pool to manage the subpools.
 type SubPool interface {
-	// Filter is a selector used to decide whether a transaction whould be added
+	// Filter is a selector used to decide whether a transaction would be added
 	// to this particular subpool.
 	Filter(tx *types.Transaction) bool
 

core/txpool/validation.go

@@ -35,8 +35,6 @@ import (
 type ValidationOptions struct {
 	Config *params.ChainConfig // Chain configuration to selectively validate based on current fork rules
 
-	AllowUnprotectedTxs bool // Whether to allow unprotected transactions in the pool
-
 	Accept  uint8    // Bitmap of transaction types that should be accepted for the calling pool
 	MaxSize uint64   // Maximum size of a transaction that the caller can meaningfully handle
 	MinTip  *big.Int // Minimum gas tip needed to allow a transaction into the caller pool
@@ -93,7 +91,7 @@ func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types
 		return core.ErrTipAboveFeeCap
 	}
 	// Make sure the transaction is signed properly
-	if _, err := types.Sender(signer, tx); err != nil && !opts.AllowUnprotectedTxs {
+	if _, err := types.Sender(signer, tx); err != nil {
 		return ErrInvalidSender
 	}
 	// Ensure the transaction has more gas than the bare minimum needed to cover

core/types/block.go

@@ -463,8 +463,8 @@ func (b *Block) GetTxDependency() [][]uint64 {
 	return blockExtraData.TxDependency
 }
 
-func (h *Header) GetValidatorBytes(config *params.BorConfig) []byte {
+func (h *Header) GetValidatorBytes(chainConfig *params.ChainConfig) []byte {
-	if !config.IsParallelUniverse(h.Number) {
+	if !chainConfig.IsCancun(h.Number) {
 		return h.Extra[ExtraVanityLength : len(h.Extra)-ExtraSealLength]
 	}
 

core/types/block_test.go

@@ -74,7 +74,6 @@ func TestBlockEncoding(t *testing.T) {
 }
 
 // This is a replica of `(h *Header) GetValidatorBytes` function
-// This was needed because currently, `IsParallelUniverse` will always return false.
 func GetValidatorBytesTest(h *Header) []byte {
 	if len(h.Extra) < ExtraVanityLength+ExtraSealLength {
 		log.Error("length of extra less is than vanity and seal")

core/types/transaction_signing.go

@@ -582,38 +582,3 @@ func deriveChainId(v *big.Int) *big.Int {
 	v = new(big.Int).Sub(v, big.NewInt(35))
 	return v.Div(v, big.NewInt(2))
 }
-
-// FakeSigner implements the Signer interface and accepts unprotected transactions
-type FakeSigner struct{ londonSigner }
-
-var _ Signer = FakeSigner{}
-
-func NewFakeSigner(chainId *big.Int) Signer {
-	signer := NewLondonSigner(chainId)
-	ls, _ := signer.(londonSigner)
-	return FakeSigner{londonSigner: ls}
-}
-
-func (f FakeSigner) Sender(tx *Transaction) (common.Address, error) {
-	return f.londonSigner.Sender(tx)
-}
-
-func (f FakeSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *big.Int, err error) {
-	return f.londonSigner.SignatureValues(tx, sig)
-}
-
-func (f FakeSigner) ChainID() *big.Int {
-	return f.londonSigner.ChainID()
-}
-
-// Hash returns 'signature hash', i.e. the transaction hash that is signed by the
-// private key. This hash does not uniquely identify the transaction.
-func (f FakeSigner) Hash(tx *Transaction) common.Hash {
-	return f.londonSigner.Hash(tx)
-}
-
-// Equal returns true if the given signer is the same as the receiver.
-func (f FakeSigner) Equal(Signer) bool {
-	// Always return true
-	return true
-}

core/types/transaction_signing_test.go

@@ -43,7 +43,7 @@ func TestEIP155Signing(t *testing.T) {
 	}
 
 	if from != addr {
-		t.Errorf("exected from and address to be equal. Got %x want %x", from, addr)
+		t.Errorf("expected from and address to be equal. Got %x want %x", from, addr)
 	}
 }
 

core/vm/contracts.go

@@ -105,7 +105,6 @@ var PrecompiledContractsCancun = map[common.Address]PrecompiledContract{
 	common.BytesToAddress([]byte{7}):          &bn256ScalarMulIstanbul{},
 	common.BytesToAddress([]byte{8}):          &bn256PairingIstanbul{},
 	common.BytesToAddress([]byte{9}):          &blake2F{},
-	common.BytesToAddress([]byte{0x0a}):       &kzgPointEvaluation{},
 	common.BytesToAddress([]byte{0x01, 0x00}): &p256Verify{},
 }
 

core/vm/contracts_test.go

@@ -233,7 +233,7 @@ func BenchmarkPrecompiledRipeMD(bench *testing.B) {
 	benchmarkPrecompiled("03", t, bench)
 }
 
-// Benchmarks the sample inputs from the identiy precompile.
+// Benchmarks the sample inputs from the identity precompile.
 func BenchmarkPrecompiledIdentity(bench *testing.B) {
 	t := precompiledTest{
 		Input:    "38d18acb67d25c8bb9942764b62f18e17054f66a817bd4295423adf9ed98873e000000000000000000000000000000000000000000000000000000000000001b38d18acb67d25c8bb9942764b62f18e17054f66a817bd4295423adf9ed98873e789d1dd423d25f0772d2748d60f7e4b81bb14d086eba8e8e8efb6dcff8a4ae02",

core/vm/interpreter.go

@@ -242,7 +242,7 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool, i
 		debug   = in.evm.Config.Tracer != nil
 	)
 	// Don't move this deferred function, it's placed before the capturestate-deferred method,
-	// so that it get's executed _after_: the capturestate needs the stacks before
+	// so that it gets executed _after_: the capturestate needs the stacks before
 	// they are returned to the pools
 	defer func() {
 		returnStack(stack)
@@ -411,7 +411,7 @@ func (in *EVMInterpreter) RunWithDelay(contract *Contract, input []byte, readOnl
 		debug   = in.evm.Config.Tracer != nil
 	)
 	// Don't move this deferrred function, it's placed before the capturestate-deferred method,
-	// so that it get's executed _after_: the capturestate needs the stacks before
+	// so that it gets executed _after_: the capturestate needs the stacks before
 	// they are returned to the pools
 	defer func() {
 		returnStack(stack)

core/vm/jump_table_test.go

@@ -22,7 +22,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// TestJumpTableCopy tests that deep copy is necessery to prevent modify shared jump table
+// TestJumpTableCopy tests that deep copy is necessary to prevent modify shared jump table
 func TestJumpTableCopy(t *testing.T) {
 	t.Parallel()
 

core/vm/runtime/runtime_test.go

@@ -703,7 +703,7 @@ func TestColdAccountAccessCost(t *testing.T) {
 				t.Logf("%d: %v %d", ii, op.OpName(), op.GasCost)
 			}
 
-			t.Fatalf("tescase %d, gas report wrong, step %d, have %d want %d", i, tc.step, have, want)
+			t.Fatalf("testcase %d, gas report wrong, step %d, have %d want %d", i, tc.step, have, want)
 		}
 	}
 }

crypto/bls12381/g2.go

@@ -27,7 +27,7 @@ import (
 // If z is equal to one the point is considered as in affine form.
 type PointG2 [3]fe2
 
-// Set copies valeus of one point to another.
+// Set copies values of one point to another.
 func (p *PointG2) Set(p2 *PointG2) *PointG2 {
 	p[0].set(&p2[0])
 	p[1].set(&p2[1])

eth/backend.go

@@ -174,7 +174,8 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 
 	eth.APIBackend = &EthAPIBackend{stack.Config().ExtRPCEnabled(), stack.Config().AllowUnprotectedTxs, eth, nil}
 	if eth.APIBackend.allowUnprotectedTxs {
-		log.Info("------Unprotected transactions allowed-------")
+		log.Debug(" ###########", "Unprotected transactions allowed")
+
 		config.TxPool.AllowUnprotectedTxs = true
 	}
 
@@ -236,6 +237,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 			Preimages:           config.Preimages,
 			StateHistory:        config.StateHistory,
 			StateScheme:         scheme,
+			TriesInMemory:       config.TriesInMemory,
 		}
 	)
 

eth/bor_api_backend.go

@@ -83,6 +83,21 @@ func (b *EthAPIBackend) GetVoteOnHash(ctx context.Context, starBlockNr uint64, e
 		return false, fmt.Errorf("Hash mismatch: localChainHash %s, milestoneHash %s", localEndBlockHash, hash)
 	}
 
+	ethHandler := (*ethHandler)(b.eth.handler)
+
+	bor, ok := ethHandler.chain.Engine().(*bor.Bor)
+
+	if !ok {
+		return false, fmt.Errorf("Bor not available")
+	}
+
+	err = bor.HeimdallClient.FetchMilestoneID(ctx, milestoneId)
+
+	if err != nil {
+		downloader.UnlockMutex(false, "", endBlockNr, common.Hash{})
+		return false, fmt.Errorf("Milestone ID doesn't exist in Heimdall")
+	}
+
 	downloader.UnlockMutex(true, milestoneId, endBlockNr, localEndBlock.Hash())
 
 	return true, nil

eth/downloader/downloader.go

@@ -620,7 +620,7 @@ func (d *Downloader) syncWithPeer(p *peerConnection, hash common.Hash, td, ttd *
 		// For non-merged networks, if there is a checkpoint available, then calculate
 		// the ancientLimit through that. Otherwise calculate the ancient limit through
 		// the advertised height of the remote peer. This most is mostly a fallback for
-		// legacy networks, but should eventually be droppped. TODO(karalabe).
+		// legacy networks, but should eventually be dropped. TODO(karalabe).
 		if beaconMode {
 			// Beacon sync, use the latest finalized block as the ancient limit
 			// or a reasonable height if no finalized block is yet announced.

eth/downloader/resultstore.go

@@ -154,7 +154,7 @@ func (r *resultStore) HasCompletedItems() bool {
 // countCompleted returns the number of items ready for delivery, stopping at
 // the first non-complete item.
 //
-// The mthod assumes (at least) rlock is held.
+// The method assumes (at least) rlock is held.
 func (r *resultStore) countCompleted() int {
 	// We iterate from the already known complete point, and see
 	// if any more has completed since last count

eth/downloader/whitelist/milestone.go

@@ -290,7 +290,7 @@ func (m *milestone) enqueueFutureMilestone(key uint64, hash common.Hash) {
 		return
 	}
 
-	log.Debug("Enqueing new future milestone", "endBlockNumber", key, "futureMilestoneHash", hash)
+	log.Debug("Enqueuing new future milestone", "endBlockNumber", key, "futureMilestoneHash", hash)
 
 	m.FutureMilestoneList[key] = hash
 	m.FutureMilestoneOrder = append(m.FutureMilestoneOrder, key)

eth/downloader/whitelist/service.go

@@ -191,7 +191,7 @@ func isValidChain(currentHeader *types.Header, chain []*types.Header, doExist bo
 	pastChain, _ := splitChain(current, chain)
 
 	// Iterate over the chain and validate against the last milestone
-	// It will handle all cases when the incoming chain has atleast one milestone
+	// It will handle all cases when the incoming chain has at least one milestone
 	for i := len(pastChain) - 1; i >= 0; i-- {
 		if pastChain[i].Number.Uint64() == number {
 			res := pastChain[i].Hash() == hash
@@ -205,7 +205,7 @@ func isValidChain(currentHeader *types.Header, chain []*types.Header, doExist bo
 
 // FIXME: remoteHeader is not used
 func isValidPeer(fetchHeadersByNumber func(number uint64, amount int, skip int, reverse bool) ([]*types.Header, []common.Hash, error), doExist bool, number uint64, hash common.Hash) (bool, error) {
-	// Check for availaibility of the last milestone block.
+	// Check for availability of the last milestone block.
 	// This can be also be empty if our heimdall is not responding
 	// or we're running without it.
 	if !doExist {

eth/downloader/whitelist/service_test.go

@@ -240,13 +240,13 @@ func TestMilestone(t *testing.T) {
 	require.Equal(t, order[0], uint64(16), "expected number to be 16 but got", order[0])
 	require.Equal(t, list[order[0]], common.Hash{16}, "expected value is", common.Hash{16}.String()[2:], "but got", list[order[0]])
 
-	capicity := milestone.MaxCapacity
+	capacity := milestone.MaxCapacity
-	for i := 16; i <= 16*(capicity+1); i = i + 16 {
+	for i := 16; i <= 16*(capacity+1); i = i + 16 {
 		s.ProcessFutureMilestone(uint64(i), common.Hash{16})
 	}
 
-	require.Equal(t, len(milestone.FutureMilestoneOrder), capicity, "expected length is", capicity)
+	require.Equal(t, len(milestone.FutureMilestoneOrder), capacity, "expected length is", capacity)
-	require.Equal(t, milestone.FutureMilestoneOrder[capicity-1], uint64(16*capicity), "expected value is", uint64(16*capicity), "but got", milestone.FutureMilestoneOrder[capicity-1])
+	require.Equal(t, milestone.FutureMilestoneOrder[capacity-1], uint64(16*capacity), "expected value is", uint64(16*capacity), "but got", milestone.FutureMilestoneOrder[capacity-1])
 }
 
 // TestIsValidPeer checks the IsValidPeer function in isolation

eth/protocols/eth/dispatcher.go

@@ -41,7 +41,7 @@ var (
 // Request is a pending request to allow tracking it and delivering a response
 // back to the requester on their chosen channel.
 type Request struct {
-	peer *Peer  // Peer to which this request belogs for untracking
+	peer *Peer  // Peer to which this request belongs for untracking
 	id   uint64 // Request ID to match up replies to
 
 	sink   chan *Response // Channel to deliver the response on
@@ -228,7 +228,7 @@ func (p *Peer) dispatcher() {
 			switch {
 			case res.Req == nil:
 				// Response arrived with an untracked ID. Since even cancelled
-				// requests are tracked until fulfilment, a dangling response
+				// requests are tracked until fulfillment, a dangling response
 				// means the remote peer implements the protocol badly.
 				resOp.fail <- errDanglingResponse
 

eth/protocols/eth/peer.go

@@ -84,7 +84,7 @@ type Peer struct {
 	txBroadcast chan []common.Hash // Channel used to queue transaction propagation requests
 	txAnnounce  chan []common.Hash // Channel used to queue transaction announcement requests
 
-	reqDispatch chan *request  // Dispatch channel to send requests and track then until fulfilment
+	reqDispatch chan *request  // Dispatch channel to send requests and track then until fulfillment
 	reqCancel   chan *cancel   // Dispatch channel to cancel pending requests and untrack them
 	resDispatch chan *response // Dispatch channel to fulfil pending requests and untrack them
 

eth/tracers/api_bor.go

@@ -140,7 +140,7 @@ type TraceBlockRequest struct {
 	Config     *TraceConfig
 }
 
-// If you use context as first parameter this function gets exposed automaticall on rpc endpoint
+// If you use context as first parameter this function gets exposed automatically on rpc endpoint
 func (api *API) TraceBorBlock(req *TraceBlockRequest) (*BlockTraceResult, error) {
 	ctx := context.Background()
 

eth/tracers/js/internal/tracers/call_tracer_legacy.js

@@ -219,7 +219,7 @@
 		return this.finalize(result);
 	},
 
-	// finalize recreates a call object using the final desired field oder for json
+	// finalize recreates a call object using the final desired field order for json
 	// serialization. This is a nicety feature to pass meaningfully ordered results
 	// to users who don't interpret it, just display it.
 	finalize: function(call) {

eth/tracers/tracers_test.go

@@ -135,9 +135,9 @@ func TestMemCopying(t *testing.T) {
 		{0, 100, 0, "", 0},      // No need to pad (0 size)
 		{100, 50, 100, "", 100}, // Should pad 100-150
 		{100, 50, 5, "", 5},     // Wanted range fully within memory
-		{100, -50, 0, "offset or size must not be negative", 0},                        // Errror
+		{100, -50, 0, "offset or size must not be negative", 0},                        // Error
-		{0, 1, 1024*1024 + 1, "reached limit for padding memory slice: 1048578", 0},    // Errror
+		{0, 1, 1024*1024 + 1, "reached limit for padding memory slice: 1048578", 0},    // Error
-		{10, 0, 1024*1024 + 100, "reached limit for padding memory slice: 1048666", 0}, // Errror
+		{10, 0, 1024*1024 + 100, "reached limit for padding memory slice: 1048666", 0}, // Error
 
 	} {
 		mem := vm.NewMemory()

ethclient/gethclient/gethclient_test.go

@@ -497,7 +497,7 @@ func TestOverrideAccountMarshal(t *testing.T) {
 
 	om := map[common.Address]OverrideAccount{
 		{0x11}: {
-			// Zero-valued nonce is not overriddden, but simply dropped by the encoder.
+			// Zero-valued nonce is not overridden, but simply dropped by the encoder.
 			Nonce: 0,
 		},
 		{0xaa}: {

graphql/graphql.go

@@ -1194,7 +1194,7 @@ func (c *CallResult) Status() hexutil.Uint64 {
 func (b *Block) Call(ctx context.Context, args struct {
 	Data ethapi.TransactionArgs
 }) (*CallResult, error) {
-	result, err := ethapi.DoCall(ctx, b.r.backend, args.Data, *b.numberOrHash, nil, nil, b.r.backend.RPCEVMTimeout(), b.r.backend.RPCGasCap())
+	result, err := ethapi.DoCall(ctx, b.r.backend, args.Data, *b.numberOrHash, nil, nil, nil, b.r.backend.RPCEVMTimeout(), b.r.backend.RPCGasCap())
 	if err != nil {
 		return nil, err
 	}
@@ -1257,7 +1257,7 @@ func (p *Pending) Call(ctx context.Context, args struct {
 	Data ethapi.TransactionArgs
 }) (*CallResult, error) {
 	pendingBlockNr := rpc.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber)
-	result, err := ethapi.DoCall(ctx, p.r.backend, args.Data, pendingBlockNr, nil, nil, p.r.backend.RPCEVMTimeout(), p.r.backend.RPCGasCap())
+	result, err := ethapi.DoCall(ctx, p.r.backend, args.Data, pendingBlockNr, nil, nil, nil, p.r.backend.RPCEVMTimeout(), p.r.backend.RPCGasCap())
 	if err != nil {
 		return nil, err
 	}

internal/cli/flagset/flagset.go

@@ -368,7 +368,7 @@ func (i *SliceStringFlag) String() string {
 }
 
 func (i *SliceStringFlag) Set(value string) error {
-	// overwritting insted of appending
+	// overwriting instead of appending
 	*i.Value = SplitAndTrim(value)
 	return nil
 }

internal/cli/server/chains/amoy.go

@@ -28,10 +28,9 @@ var amoyTestnet = &Chain{
 			LondonBlock:         big.NewInt(73100),
 			ShanghaiBlock:       big.NewInt(73100),
 			Bor: &params.BorConfig{
-				JaipurBlock:           big.NewInt(73100),
+				JaipurBlock: big.NewInt(73100),
-				DelhiBlock:            big.NewInt(73100),
+				DelhiBlock:  big.NewInt(73100),
-				ParallelUniverseBlock: nil,
+				IndoreBlock: big.NewInt(73100),
-				IndoreBlock:           big.NewInt(73100),
 				StateSyncConfirmationDelay: map[string]uint64{
 					"0": 128,
 				},

internal/cli/server/chains/mainnet.go

@@ -29,10 +29,9 @@ var mainnetBor = &Chain{
 			LondonBlock:         big.NewInt(23850000),
 			ShanghaiBlock:       big.NewInt(50523000),
 			Bor: &params.BorConfig{
-				JaipurBlock:           big.NewInt(23850000),
+				JaipurBlock: big.NewInt(23850000),
-				DelhiBlock:            big.NewInt(38189056),
+				DelhiBlock:  big.NewInt(38189056),
-				ParallelUniverseBlock: big.NewInt(0),
+				IndoreBlock: big.NewInt(44934656),
-				IndoreBlock:           big.NewInt(44934656),
 				StateSyncConfirmationDelay: map[string]uint64{
 					"44934656": 128,
 				},

internal/cli/server/chains/mumbai.go

@@ -29,10 +29,9 @@ var mumbaiTestnet = &Chain{
 			LondonBlock:         big.NewInt(22640000),
 			ShanghaiBlock:       big.NewInt(41874000),
 			Bor: &params.BorConfig{
-				JaipurBlock:           big.NewInt(22770000),
+				JaipurBlock: big.NewInt(22770000),
-				DelhiBlock:            big.NewInt(29638656),
+				DelhiBlock:  big.NewInt(29638656),
-				ParallelUniverseBlock: big.NewInt(0),
+				IndoreBlock: big.NewInt(37075456),
-				IndoreBlock:           big.NewInt(37075456),
 				StateSyncConfirmationDelay: map[string]uint64{
 					"37075456": 128,
 				},

internal/cli/server/chains/test_files/chain_legacy_test.json

@@ -57,7 +57,6 @@
       },
       "jaipurBlock": 22770000,
       "delhiBlock": 29638656,
-      "parallelUniverseBlock": 0,
       "indoreBlock": 37075456,
       "stateSyncConfirmationDelay": {
         "37075456": 128

internal/cli/server/chains/test_files/chain_test.json

@@ -59,7 +59,6 @@
           },
           "jaipurBlock":22770000,
           "delhiBlock": 29638656,
-          "parallelUniverseBlock": 0,
           "indoreBlock": 37075456,
           "stateSyncConfirmationDelay": {
             "37075456": 128

internal/cli/server/command.go

@@ -94,7 +94,7 @@ func (c *Command) extractFlags(args []string) error {
 
 		log.Warn("Config set via config file will be overridden by cli flags")
 
-		// Initialse a flagset based on the config created above
+		// Initialise a flagset based on the config created above
 		flags := c.Flags(cfg)
 
 		// Check for explicit cli args

internal/cli/server/config_legacy_test.go

@@ -42,22 +42,3 @@ func TestConfigLegacy(t *testing.T) {
 		readFile("./testdata/test.toml")
 	})
 }
-
-func TestDefaultConfigLegacy(t *testing.T) {
-	readFile := func(path string) {
-		expectedConfig, err := readLegacyConfig(path)
-		assert.NoError(t, err)
-
-		testConfig := DefaultConfig()
-
-		testConfig.Identity = "Polygon-Devs"
-		testConfig.DataDir = "/var/lib/bor"
-
-		assert.Equal(t, expectedConfig, testConfig)
-	}
-
-	// read file in hcl format
-	t.Run("toml", func(t *testing.T) {
-		readFile("./testdata/default.toml")
-	})
-}

internal/cli/server/testdata/default.toml

@@ -1,193 +0,0 @@
-chain = "mainnet"
-identity = "Polygon-Devs"
-verbosity = 3
-log-level = ""
-vmdebug = false
-datadir = "/var/lib/bor"
-ancient = ""
-"db.engine" = "leveldb"
-keystore = ""
-"rpc.batchlimit" = 100
-"rpc.returndatalimit" = 100000
-syncmode = "full"
-gcmode = "full"
-snapshot = true
-"bor.logs" = false
-ethstats = ""
-devfakeauthor = false
-
-["eth.requiredblocks"]
-
-[log]
-  vmodule = ""
-  json = false
-  backtrace = ""
-  debug = false
-
-[p2p]
-  maxpeers = 50
-  maxpendpeers = 50
-  bind = "0.0.0.0"
-  port = 30303
-  nodiscover = false
-  nat = "any"
-  netrestrict = ""
-  nodekey = ""
-  nodekeyhex = ""
-  txarrivalwait = "500ms"
-  [p2p.discovery]
-    v4disc = true
-    v5disc = false
-    bootnodes = []
-    bootnodesv4 = []
-    bootnodesv5 = []
-    static-nodes = []
-    trusted-nodes = []
-    dns = []
-
-[heimdall]
-  url = "http://localhost:1317"
-  "bor.without" = false
-  grpc-address = ""
-  "bor.runheimdall" = false
-  "bor.runheimdallargs" = ""
-  "bor.useheimdallapp" = false
-
-[txpool]
-  locals = []
-  nolocals = false
-  journal = "transactions.rlp"
-  rejournal = "1h0m0s"
-  pricelimit = 1
-  pricebump = 10
-  accountslots = 16
-  globalslots = 32768
-  accountqueue = 16
-  globalqueue = 32768
-  lifetime = "3h0m0s"
-
-[miner]
-  mine = false
-  etherbase = ""
-  extradata = ""
-  gaslimit = 30000000
-  gasprice = "1000000000"
-  recommit = "2m5s"
-  commitinterrupt = true
-
-[jsonrpc]
-  ipcdisable = false
-  ipcpath = ""
-  gascap = 50000000
-  evmtimeout = "5s"
-  txfeecap = 1.0
-  allow-unprotected-txs = false
-  enabledeprecatedpersonal = false
-  [jsonrpc.http]
-    enabled = false
-    port = 8545
-    prefix = ""
-    host = "localhost"
-    api = ["eth", "net", "web3", "txpool", "bor"]
-    vhosts = ["localhost"]
-    corsdomain = ["localhost"]
-    ep-size = 40
-    ep-requesttimeout = "0s"
-  [jsonrpc.ws]
-    enabled = false
-    port = 8546
-    prefix = ""
-    host = "localhost"
-    api = ["net", "web3"]
-    origins = ["localhost"]
-    ep-size = 40
-    ep-requesttimeout = "0s"
-  [jsonrpc.graphql]
-    enabled = false
-    port = 0
-    prefix = ""
-    host = ""
-    vhosts = ["localhost"]
-    corsdomain = ["localhost"]
-    ep-size = 0
-    ep-requesttimeout = ""
-  [jsonrpc.auth]
-    jwtsecret = ""
-    addr = "localhost"
-    port = 8551
-    vhosts = ["localhost"]
-  [jsonrpc.timeouts]
-    read = "10s"
-    write = "30s"
-    idle = "2m0s"
-
-[gpo]
-  blocks = 20
-  percentile = 60
-  maxheaderhistory = 1024
-  maxblockhistory = 1024
-  maxprice = "500000000000"
-  ignoreprice = "2"
-
-[telemetry]
-  metrics = false
-  expensive = false
-  prometheus-addr = "127.0.0.1:7071"
-  opencollector-endpoint = ""
-  [telemetry.influx]
-    influxdb = false
-    endpoint = ""
-    database = ""
-    username = ""
-    password = ""
-    influxdbv2 = false
-    token = ""
-    bucket = ""
-    organization = ""
-    [telemetry.influx.tags]
-
-[cache]
-  cache = 1024
-  gc = 25
-  snapshot = 10
-  database = 50
-  trie = 15
-  noprefetch = false
-  preimages = false
-  txlookuplimit = 2350000
-  triesinmemory = 128
-  blocklogs = 32
-  timeout = "1h0m0s"
-  fdlimit = 0
-
-[leveldb]
-  compactiontablesize = 2
-  compactiontablesizemultiplier = 1.0
-  compactiontotalsize = 10
-  compactiontotalsizemultiplier = 10.0
-
-[accounts]
-  unlock = []
-  password = ""
-  allow-insecure-unlock = false
-  lightkdf = false
-  disable-bor-wallet = true
-
-[grpc]
-  addr = ":3131"
-
-[developer]
-  dev = false
-  period = 0
-  gaslimit = 11500000
-
-[parallelevm]
-  enable = true
-  procs = 8
-
-[pprof]
-  pprof = false
-  port = 6060
-  addr = "127.0.0.1"
-  memprofilerate = 524288
-  blockprofilerate = 0

internal/ethapi/api.go

@@ -703,8 +703,12 @@ func (s *BlockChainAPI) GetTransactionReceiptsByBlock(ctx context.Context, block
 	for idx, receipt := range receipts {
 		tx := txs[idx]
 
-		// Derive the sender.
+		var signer types.Signer = types.FrontierSigner{}
-		signer := types.MakeSigner(s.b.ChainConfig(), block.Number(), block.Time())
+
+		if tx.Protected() {
+			signer = types.NewEIP155Signer(tx.ChainId())
+		}
+
 		from, _ := types.Sender(signer, tx)
 
 		fields := map[string]interface{}{
@@ -720,11 +724,6 @@ func (s *BlockChainAPI) GetTransactionReceiptsByBlock(ctx context.Context, block
 			"logs":              receipt.Logs,
 			"logsBloom":         receipt.Bloom,
 			"type":              hexutil.Uint(tx.Type()),
-			"effectiveGasPrice": (*hexutil.Big)(receipt.EffectiveGasPrice),
-		}
-
-		if receipt.EffectiveGasPrice == nil {
-			fields["effectiveGasPrice"] = new(hexutil.Big)
 		}
 
 		// Assign receipt status or post state.
@@ -735,7 +734,7 @@ func (s *BlockChainAPI) GetTransactionReceiptsByBlock(ctx context.Context, block
 		}
 
 		if receipt.Logs == nil {
-			fields["logs"] = []*types.Log{}
+			fields["logs"] = [][]*types.Log{}
 		}
 
 		if borReceipt != nil && idx == len(receipts)-1 {
@@ -1299,12 +1298,31 @@ func doCallWithState(ctx context.Context, b Backend, args TransactionArgs, heade
 	return result, nil
 }
 
-func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64) (*core.ExecutionResult, error) {
+func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64) (*core.ExecutionResult, error) {
 	defer func(start time.Time) { log.Debug("Executing EVM call finished", "runtime", time.Since(start)) }(time.Now())
 
-	state, header, err := b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
+	var (
-	if state == nil || err != nil {
+		header *types.Header
-		return nil, err
+		err    error
+	)
+
+	// BOR: This is used by bor consensus to fetch data from genesis contracts for state-sync
+	// Fetch the state and header from blockNumberOrHash if it's coming from normal eth_call path.
+	if state == nil {
+		state, header, err = b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
+		if state == nil || err != nil {
+			return nil, err
+		}
+	} else {
+		// Fetch the header from the given blockNumberOrHash. Note that this path is only taken
+		// when we're doing a call from bor consensus to fetch data from genesis contracts. It's
+		// necessary to fetch header using header hash as we might be experiencing a reorg and there
+		// can be multiple headers with same number.
+		header, err = b.HeaderByHash(ctx, *blockNrOrHash.BlockHash)
+		if header == nil || err != nil {
+			log.Warn("Error fetching header on CallWithState", "err", err)
+			return nil, err
+		}
 	}
 
 	return doCall(ctx, b, args, state, header, overrides, blockOverrides, timeout, globalGasCap)

internal/flags/helpers.go

@@ -122,7 +122,7 @@ func doMigrateFlags(ctx *cli.Context) {
 		for _, parent := range ctx.Lineage()[1:] {
 			if parent.IsSet(name) {
 				// When iterating across the lineage, we will be served both
-				// the 'canon' and alias formats of all commmands. In most cases,
+				// the 'canon' and alias formats of all commands. In most cases,
 				// it's fine to set it in the ctx multiple times (one for each
 				// name), however, the Slice-flags are not fine.
 				// The slice-flags accumulate, so if we set it once as

internal/jsre/deps/web3.js

@@ -2031,7 +2031,7 @@ var fromAscii = function(str) {
  *
  * @method transformToFullName
  * @param {Object} json-abi
- * @return {String} full fnction/event name
+ * @return {String} full function/event name
  */
 var transformToFullName = function (json) {
     if (json.name.indexOf('(') !== -1) {
@@ -2089,7 +2089,7 @@ var fromDecimal = function (value) {
 /**
  * Auto converts any given value into it's hex representation.
  *
- * And even stringifys objects before.
+ * And even stringifies objects before.
  *
  * @method toHex
  * @param {String|Number|BigNumber|Object}
@@ -2361,7 +2361,7 @@ var isFunction = function (object) {
 };
 
 /**
- * Returns true if object is Objet, otherwise false
+ * Returns true if object is Object, otherwise false
  *
  * @method isObject
  * @param {Object}
@@ -2757,7 +2757,7 @@ var Batch = function (web3) {
  * Should be called to add create new request to batch request
  *
  * @method add
- * @param {Object} jsonrpc requet object
+ * @param {Object} jsonrpc request object
  */
 Batch.prototype.add = function (request) {
     this.requests.push(request);
@@ -4557,7 +4557,7 @@ Iban.createIndirect = function (options) {
 };
 
 /**
- * Thos method should be used to check if given string is valid iban object
+ * This method should be used to check if given string is valid iban object
  *
  * @method isValid
  * @param {String} iban string
@@ -6721,7 +6721,7 @@ var exchangeAbi = require('../contracts/SmartExchange.json');
  * @method transfer
  * @param {String} from
  * @param {String} to iban
- * @param {Value} value to be tranfered
+ * @param {Value} value to be transferred
  * @param {Function} callback, callback
  */
 var transfer = function (eth, from, to, value, callback) {
@@ -6751,7 +6751,7 @@ var transfer = function (eth, from, to, value, callback) {
  * @method transferToAddress
  * @param {String} from
  * @param {String} to
- * @param {Value} value to be tranfered
+ * @param {Value} value to be transferred
  * @param {Function} callback, callback
  */
 var transferToAddress = function (eth, from, to, value, callback) {
@@ -7105,7 +7105,7 @@ module.exports = transfer;
 	        /**
 	         * Initializes a newly created cipher.
 	         *
-	         * @param {number} xformMode Either the encryption or decryption transormation mode constant.
+	         * @param {number} xformMode Either the encryption or decryption transformation mode constant.
 	         * @param {WordArray} key The key.
 	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
 	         *
@@ -9459,7 +9459,7 @@ module.exports = transfer;
 	            var M_offset_14 = M[offset + 14];
 	            var M_offset_15 = M[offset + 15];
 
-	            // Working varialbes
+	            // Working variables
 	            var a = H[0];
 	            var b = H[1];
 	            var c = H[2];

les/utils/timeutils_test.go

@@ -42,6 +42,6 @@ func TestUpdateTimer(t *testing.T) {
 	}
 	timer = NewUpdateTimer(sim, 0)
 	if updated := timer.Update(func(diff time.Duration) bool { return true }); !updated {
-		t.Fatalf("Doesn't update the clock without threshold limitaion")
+		t.Fatalf("Doesn't update the clock without threshold limitation")
 	}
 }

log/doc.go

@@ -195,7 +195,7 @@ on log level.
 
 # Error Handling
 
-Becasuse log15 allows you to step around the type system, there are a few ways you can specify
+Because log15 allows you to step around the type system, there are a few ways you can specify
 invalid arguments to the logging functions. You could, for example, wrap something that is not
 a zero-argument function with log.Lazy or pass a context key that is not a string. Since logging libraries
 are typically the mechanism by which errors are reported, it would be onerous for the logging functions

log/format.go

@@ -55,7 +55,7 @@ var stackEnabled atomic.Bool
 // should append the log locations too when printing entries.
 var locationEnabled atomic.Bool
 
-// locationLength is the maxmimum path length encountered, which all logs are
+// locationLength is the maximum path length encountered, which all logs are
 // padded to to aid in alignment.
 var locationLength atomic.Uint32
 

miner/payload_building_test.go

@@ -55,23 +55,23 @@ func TestBuildPayload(t *testing.T) {
 	verify := func(outer *engine.ExecutionPayloadEnvelope, txs int) {
 		payload := outer.ExecutionPayload
 		if payload.ParentHash != b.chain.CurrentBlock().Hash() {
-			t.Fatal("Unexpect parent hash")
+			t.Fatal("Unexpected parent hash")
 		}
 
 		if payload.Random != (common.Hash{}) {
-			t.Fatal("Unexpect random value")
+			t.Fatal("Unexpected random value")
 		}
 
 		if payload.Timestamp != timestamp {
-			t.Fatal("Unexpect timestamp")
+			t.Fatal("Unexpected timestamp")
 		}
 
 		if payload.FeeRecipient != recipient {
-			t.Fatal("Unexpect fee recipient")
+			t.Fatal("Unexpected fee recipient")
 		}
 
 		if len(payload.Transactions) != txs {
-			t.Fatal("Unexpect transaction set")
+			t.Fatal("Unexpected transaction set")
 		}
 	}
 	empty := payload.ResolveEmpty()

miner/worker.go

@@ -111,17 +111,22 @@ type environment struct {
 	receipts []*types.Receipt
 	sidecars []*types.BlobTxSidecar
 	blobs    int
+
+	depsMVFullWriteList [][]blockstm.WriteDescriptor
+	mvReadMapList       []map[blockstm.Key]blockstm.ReadDescriptor
 }
 
 // copy creates a deep copy of environment.
 func (env *environment) copy() *environment {
 	cpy := &environment{
-		signer:   env.signer,
+		signer:              env.signer,
-		state:    env.state.Copy(),
+		state:               env.state.Copy(),
-		tcount:   env.tcount,
+		tcount:              env.tcount,
-		coinbase: env.coinbase,
+		coinbase:            env.coinbase,
-		header:   types.CopyHeader(env.header),
+		header:              types.CopyHeader(env.header),
-		receipts: copyReceipts(env.receipts),
+		receipts:            copyReceipts(env.receipts),
+		depsMVFullWriteList: env.depsMVFullWriteList,
+		mvReadMapList:       env.mvReadMapList,
 	}
 
 	if env.gasPool != nil {
@@ -859,6 +864,9 @@ func (w *worker) makeEnv(parent *types.Header, header *types.Header, coinbase co
 	// Keep track of transactions which return errors so they can be removed
 	env.tcount = 0
 
+	env.depsMVFullWriteList = [][]blockstm.WriteDescriptor{}
+	env.mvReadMapList = []map[blockstm.Key]blockstm.ReadDescriptor{}
+
 	return env, nil
 }
 
@@ -908,36 +916,20 @@ func (w *worker) commitTransactions(env *environment, txs *transactionsByPriceAn
 
 	var coalescedLogs []*types.Log
 
-	var depsMVReadList [][]blockstm.ReadDescriptor
-
-	var depsMVFullWriteList [][]blockstm.WriteDescriptor
-
-	var mvReadMapList []map[blockstm.Key]blockstm.ReadDescriptor
-
 	var deps map[int]map[int]bool
 
 	chDeps := make(chan blockstm.TxDep)
 
-	var count int
-
 	var depsWg sync.WaitGroup
 
-	EnableMVHashMap := w.chainConfig.Bor.IsParallelUniverse(env.header.Number)
+	EnableMVHashMap := w.chainConfig.IsCancun(env.header.Number)
 
 	// create and add empty mvHashMap in statedb
 	if EnableMVHashMap {
-		depsMVReadList = [][]blockstm.ReadDescriptor{}
-
-		depsMVFullWriteList = [][]blockstm.WriteDescriptor{}
-
-		mvReadMapList = []map[blockstm.Key]blockstm.ReadDescriptor{}
-
 		deps = map[int]map[int]bool{}
 
 		chDeps = make(chan blockstm.TxDep)
 
-		count = 0
-
 		depsWg.Add(1)
 
 		go func(chDeps chan blockstm.TxDep) {
@@ -1079,18 +1071,20 @@ mainloop:
 			env.tcount++
 
 			if EnableMVHashMap {
-				depsMVReadList = append(depsMVReadList, env.state.MVReadList())
+				env.depsMVFullWriteList = append(env.depsMVFullWriteList, env.state.MVFullWriteList())
-				depsMVFullWriteList = append(depsMVFullWriteList, env.state.MVFullWriteList())
+				env.mvReadMapList = append(env.mvReadMapList, env.state.MVReadMap())
-				mvReadMapList = append(mvReadMapList, env.state.MVReadMap())
+
+				if env.tcount > len(env.depsMVFullWriteList) {
+					log.Warn("blockstm - env.tcount > len(env.depsMVFullWriteList)", "env.tcount", env.tcount, "len(depsMVFullWriteList)", len(env.depsMVFullWriteList))
+				}
 
 				temp := blockstm.TxDep{
 					Index:         env.tcount - 1,
-					ReadList:      depsMVReadList[count],
+					ReadList:      env.state.MVReadList(),
-					FullWriteList: depsMVFullWriteList,
+					FullWriteList: env.depsMVFullWriteList,
 				}
 
 				chDeps <- temp
-				count++
 			}
 
 			txs.Shift()
@@ -1122,8 +1116,8 @@ mainloop:
 		tempVanity := env.header.Extra[:types.ExtraVanityLength]
 		tempSeal := env.header.Extra[len(env.header.Extra)-types.ExtraSealLength:]
 
-		if len(mvReadMapList) > 0 {
+		if len(env.mvReadMapList) > 0 {
-			tempDeps := make([][]uint64, len(mvReadMapList))
+			tempDeps := make([][]uint64, len(env.mvReadMapList))
 
 			for j := range deps[0] {
 				tempDeps[0] = append(tempDeps[0], uint64(j))
@@ -1131,14 +1125,15 @@ mainloop:
 
 			delayFlag := true
 
-			for i := 1; i <= len(mvReadMapList)-1; i++ {
+			for i := 1; i <= len(env.mvReadMapList)-1; i++ {
-				reads := mvReadMapList[i-1]
+				reads := env.mvReadMapList[i-1]
 
 				_, ok1 := reads[blockstm.NewSubpathKey(env.coinbase, state.BalancePath)]
 				_, ok2 := reads[blockstm.NewSubpathKey(common.HexToAddress(w.chainConfig.Bor.CalculateBurntContract(env.header.Number.Uint64())), state.BalancePath)]
 
 				if ok1 || ok2 {
 					delayFlag = false
+					break
 				}
 
 				for j := range deps[i] {
@@ -1194,7 +1189,7 @@ mainloop:
 
 // generateParams wraps various of settings for generating sealing task.
 type generateParams struct {
-	timestamp   uint64            // The timstamp for sealing task
+	timestamp   uint64            // The timestamp for sealing task
 	forceTime   bool              // Flag whether the given timestamp is immutable or not
 	parentHash  common.Hash       // Parent block hash, empty means the latest chain head
 	coinbase    common.Address    // The fee recipient address for including transaction

miner/worker_test.go

@@ -928,7 +928,7 @@ func BenchmarkBorMining(b *testing.B) {
 }
 
 // uses core.NewParallelBlockChain to use the dependencies present in the block header
-// params.BorUnittestChainConfig contains the ParallelUniverseBlock ad big.NewInt(5), so the first 4 blocks will not have metadata.
+// params.BorUnittestChainConfig contains the NapoliBlock as big.NewInt(5), so the first 4 blocks will not have metadata.
 // nolint: gocognit
 func BenchmarkBorMiningBlockSTMMetadata(b *testing.B) {
 	chainConfig := params.BorUnittestChainConfig

p2p/msgrate/msgrate.go

@@ -80,7 +80,7 @@ const ttlLimit = time.Minute
 
 // tuningConfidenceCap is the number of active peers above which to stop detuning
 // the confidence number. The idea here is that once we hone in on the capacity
-// of a meaningful number of peers, adding one more should ot have a significant
+// of a meaningful number of peers, adding one more should not have a significant
 // impact on things, so just ron with the originals.
 const tuningConfidenceCap = 10
 

p2p/rlpx/rlpx_test.go

@@ -450,7 +450,7 @@ func BenchmarkThroughput(b *testing.B) {
 	conn2.SetSnappy(true)
 
 	if err := <-handshakeDone; err != nil {
-		b.Fatal("server hanshake error:", err)
+		b.Fatal("server handshake error:", err)
 	}
 
 	// Read N messages.

p2p/simulations/adapters/inproc.go

@@ -177,7 +177,7 @@ type SimNode struct {
 	registerOnce sync.Once
 }
 
-// Close closes the underlaying node.Node to release
+// Close closes the underlying node.Node to release
 // acquired resources.
 func (sn *SimNode) Close() error {
 	return sn.node.Close()

p2p/simulations/network_test.go

@@ -740,7 +740,7 @@ func triggerChecks(ctx context.Context, ids []enode.ID, trigger chan enode.ID, i
 	}
 }
 
-// \todo: refactor to implement shapshots
+// \todo: refactor to implement snapshots
 // and connect configuration methods once these are moved from
 // swarm/network/simulations/connect.go
 func BenchmarkMinimalService(b *testing.B) {

packaging/templates/package_scripts/control

@@ -1,5 +1,5 @@
 Source: bor
-Version: 1.2.0-beta
+Version: 1.2.3
 Section: develop
 Priority: standard
 Maintainer: Polygon <release-team@polygon.technology>

packaging/templates/package_scripts/control.arm64

@@ -1,5 +1,5 @@
 Source: bor
-Version: 1.2.0-beta
+Version: 1.2.3
 Section: develop
 Priority: standard
 Maintainer: Polygon <release-team@polygon.technology>

packaging/templates/package_scripts/control.profile.amd64

@@ -1,5 +1,5 @@
 Source: bor-profile
-Version: 1.2.0-beta
+Version: 1.2.3
 Section: develop
 Priority: standard
 Maintainer: Polygon <release-team@polygon.technology>

packaging/templates/package_scripts/control.profile.arm64

@@ -1,5 +1,5 @@
 Source: bor-profile
-Version: 1.2.0-beta
+Version: 1.2.3
 Section: develop
 Priority: standard
 Maintainer: Polygon <release-team@polygon.technology>

packaging/templates/package_scripts/control.validator

@@ -1,5 +1,5 @@
 Source: bor-profile
-Version: 1.2.0-beta
+Version: 1.2.3
 Section: develop
 Priority: standard
 Maintainer: Polygon <release-team@polygon.technology>

packaging/templates/package_scripts/control.validator.arm64

@@ -1,5 +1,5 @@
 Source: bor-profile
-Version: 1.2.0-beta
+Version: 1.2.3
 Section: develop
 Priority: standard
 Maintainer: Polygon <release-team@polygon.technology>

params/config.go

@@ -162,7 +162,6 @@ var (
 		BerlinBlock:         big.NewInt(0),
 		LondonBlock:         big.NewInt(0),
 		Bor: &BorConfig{
-			ParallelUniverseBlock: big.NewInt(5),
 			Period: map[string]uint64{
 				"0": 1,
 			},
@@ -201,10 +200,9 @@ var (
 		LondonBlock:         big.NewInt(22640000),
 		ShanghaiBlock:       big.NewInt(41874000),
 		Bor: &BorConfig{
-			JaipurBlock:           big.NewInt(22770000),
+			JaipurBlock: big.NewInt(22770000),
-			DelhiBlock:            big.NewInt(29638656),
+			DelhiBlock:  big.NewInt(29638656),
-			ParallelUniverseBlock: big.NewInt(0),
+			IndoreBlock: big.NewInt(37075456),
-			IndoreBlock:           big.NewInt(37075456),
 			StateSyncConfirmationDelay: map[string]uint64{
 				"37075456": 128,
 			},
@@ -268,10 +266,9 @@ var (
 		LondonBlock:         big.NewInt(73100),
 		ShanghaiBlock:       big.NewInt(73100),
 		Bor: &BorConfig{
-			JaipurBlock:           big.NewInt(73100),
+			JaipurBlock: big.NewInt(73100),
-			DelhiBlock:            big.NewInt(73100),
+			DelhiBlock:  big.NewInt(73100),
-			ParallelUniverseBlock: nil,
+			IndoreBlock: big.NewInt(73100),
-			IndoreBlock:           big.NewInt(73100),
 			StateSyncConfirmationDelay: map[string]uint64{
 				"0": 128,
 			},
@@ -313,10 +310,9 @@ var (
 		LondonBlock:         big.NewInt(23850000),
 		ShanghaiBlock:       big.NewInt(50523000),
 		Bor: &BorConfig{
-			JaipurBlock:           big.NewInt(23850000),
+			JaipurBlock: big.NewInt(23850000),
-			DelhiBlock:            big.NewInt(38189056),
+			DelhiBlock:  big.NewInt(38189056),
-			ParallelUniverseBlock: big.NewInt(0),
+			IndoreBlock: big.NewInt(44934656),
-			IndoreBlock:           big.NewInt(44934656),
 			StateSyncConfirmationDelay: map[string]uint64{
 				"44934656": 128,
 			},
@@ -617,7 +613,6 @@ type BorConfig struct {
 	BurntContract              map[string]string      `json:"burntContract"`              // governance contract where the token will be sent to and burnt in london fork
 	JaipurBlock                *big.Int               `json:"jaipurBlock"`                // Jaipur switch block (nil = no fork, 0 = already on jaipur)
 	DelhiBlock                 *big.Int               `json:"delhiBlock"`                 // Delhi switch block (nil = no fork, 0 = already on delhi)
-	ParallelUniverseBlock      *big.Int               `json:"parallelUniverseBlock"`      // TODO: update all occurrence, change name and finalize number (hardfork for block-stm related changes)
 	IndoreBlock                *big.Int               `json:"indoreBlock"`                // Indore switch block (nil = no fork, 0 = already on indore)
 	StateSyncConfirmationDelay map[string]uint64      `json:"stateSyncConfirmationDelay"` // StateSync Confirmation Delay, in seconds, to calculate `to`
 }
@@ -659,16 +654,16 @@ func (c *BorConfig) CalculateStateSyncDelay(number uint64) uint64 {
 	return borKeyValueConfigHelper(c.StateSyncConfirmationDelay, number)
 }
 
-// TODO: modify this function once the block number is finalized
+// // TODO: modify this function once the block number is finalized
-func (c *BorConfig) IsParallelUniverse(number *big.Int) bool {
+// func (c *BorConfig) IsNapoli(number *big.Int) bool {
-	if c.ParallelUniverseBlock != nil {
+// 	if c.NapoliBlock != nil {
-		if c.ParallelUniverseBlock.Cmp(big.NewInt(0)) == 0 {
+// 		if c.NapoliBlock.Cmp(big.NewInt(0)) == 0 {
-			return false
+// 			return false
-		}
+// 		}
-	}
+// 	}
 
-	return isBlockForked(c.ParallelUniverseBlock, number)
+// 	return isBlockForked(c.NapoliBlock, number)
-}
+// }
 
 func (c *BorConfig) IsSprintStart(number uint64) bool {
 	return number%c.CalculateSprint(number) == 0

params/version.go

@@ -21,10 +21,10 @@ import (
 )
 
 const (
-	VersionMajor = 1      // Major version component of the current release
+	VersionMajor = 1  // Major version component of the current release
-	VersionMinor = 2      // Minor version component of the current release
+	VersionMinor = 2  // Minor version component of the current release
-	VersionPatch = 0      // Patch version component of the current release
+	VersionPatch = 3  // Patch version component of the current release
-	VersionMeta  = "beta" // Version metadata to append to the version string
+	VersionMeta  = "" // Version metadata to append to the version string
 )
 
 var GitCommit string

rlp/rlpgen/gen.go

@@ -166,7 +166,7 @@ type op interface {
 // basicOp handles basic types bool, uint*, string.
 type basicOp struct {
 	typ           types.Type
-	writeMethod   string     // calle write the value
+	writeMethod   string     // calls write value
 	writeArgType  types.Type // parameter type of writeMethod
 	decMethod     string
 	decResultType types.Type // return type of decMethod

signer/core/api.go

@@ -692,7 +692,7 @@ func (api *SignerAPI) SignGnosisSafeTx(ctx context.Context, signerAddress common
 	}
 
 	typedData := gnosisTx.ToTypedData()
-	// might aswell error early.
+	// might as well error early.
 	// we are expected to sign. If our calculated hash does not match what they want,
 	// The gnosis safetx input contains a 'safeTxHash' which is the expected safeTxHash that
 	sighash, _, err := apitypes.TypedDataAndHash(typedData)

tests/bor/bor_test.go

@@ -299,7 +299,7 @@ func TestForkWithBlockTime(t *testing.T) {
 			// Iterate over all the nodes and start mining
 			for _, node := range nodes {
 				if err := node.StartMining(); err != nil {
-					t.Fatal("Error occured while starting miner", "node", node, "error", err)
+					t.Fatal("Error occurred while starting miner", "node", node, "error", err)
 				}
 			}
 			var wg sync.WaitGroup
@@ -333,22 +333,22 @@ func TestForkWithBlockTime(t *testing.T) {
 
 			author0, err := nodes[0].Engine().Author(blockHeaderVal0)
 			if err != nil {
-				t.Error("Error occured while fetching author", "err", err)
+				t.Error("Error occurred while fetching author", "err", err)
 			}
 			author1, err := nodes[1].Engine().Author(blockHeaderVal1)
 			if err != nil {
-				t.Error("Error occured while fetching author", "err", err)
+				t.Error("Error occurred while fetching author", "err", err)
 			}
 			assert.Equal(t, author0, author1)
 
 			// After the end of sprint
 			author2, err := nodes[0].Engine().Author(blockHeaders[0])
 			if err != nil {
-				t.Error("Error occured while fetching author", "err", err)
+				t.Error("Error occurred while fetching author", "err", err)
 			}
 			author3, err := nodes[1].Engine().Author(blockHeaders[1])
 			if err != nil {
-				t.Error("Error occured while fetching author", "err", err)
+				t.Error("Error occurred while fetching author", "err", err)
 			}
 
 			if test.forkExpected {

tests/bor/helper.go

@@ -92,7 +92,7 @@ func setupMiner(t *testing.T, n int, genesis *core.Genesis) ([]*node.Node, []*et
 		// Start the node and wait until it's up
 		stack, ethBackend, err := InitMiner(genesis, keys[i], true)
 		if err != nil {
-			t.Fatal("Error occured while initialising miner", "error", err)
+			t.Fatal("Error occurred while initialising miner", "error", err)
 		}
 
 		for stack.Server().NodeInfo().Ports.Listener == 0 {

trie/proof.go

@@ -428,7 +428,7 @@ func unset(parent node, child node, key []byte, pos int, removeLeft bool) error
 			} else {
 				if bytes.Compare(cld.Key, key[pos:]) > 0 {
 					// The key of fork shortnode is greater than the
-					// path(it belongs to the range), unset the entrie
+					// path(it belongs to the range), unset the entire
 					// branch. The parent must be a fullnode.
 					fn := parent.(*fullNode)
 					fn.Children[key[pos-1]] = nil

trie/trie_test.go

@@ -352,7 +352,7 @@ func TestLargeValue(t *testing.T) {
 	trie.Hash()
 }
 
-// TestRandomCases tests som cases that were found via random fuzzing
+// TestRandomCases tests some cases that were found via random fuzzing
 func TestRandomCases(t *testing.T) {
 	var rt = []randTestStep{
 		{op: 6, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")},                                                                                                 // step 0