fix build

accounts/abi/bind/backends/simulated.go

@@ -99,7 +99,6 @@ func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.Genesis
 	block := backend.blockchain.GetBlock(header.Hash(), header.Number.Uint64())
 
 	backend.rollback(block)
-
 	return backend
 }
 
@@ -125,7 +124,6 @@ func (b *SimulatedBackend) Commit() common.Hash {
 	if _, err := b.blockchain.InsertChain([]*types.Block{b.pendingBlock}); err != nil {
 		panic(err) // This cannot happen unless the simulator is wrong, fail in that case
 	}
-
 	blockHash := b.pendingBlock.Hash()
 
 	// Using the last inserted block here makes it possible to build on a side
@@ -172,14 +170,11 @@ func (b *SimulatedBackend) Fork(ctx context.Context, parent common.Hash) error {
 	if len(b.pendingBlock.Transactions()) != 0 {
 		return errors.New("pending block dirty")
 	}
-
 	block, err := b.blockByHash(ctx, parent)
 	if err != nil {
 		return err
 	}
-
 	b.rollback(block)
-
 	return nil
 }
 
@@ -188,12 +183,10 @@ func (b *SimulatedBackend) stateByBlockNumber(ctx context.Context, blockNumber *
 	if blockNumber == nil || blockNumber.Cmp(b.blockchain.CurrentBlock().Number) == 0 {
 		return b.blockchain.State()
 	}
-
 	block, err := b.blockByNumber(ctx, blockNumber)
 	if err != nil {
 		return nil, err
 	}
-
 	return b.blockchain.StateAt(block.Root())
 }
 
@@ -247,7 +240,6 @@ func (b *SimulatedBackend) StorageAt(ctx context.Context, contract common.Addres
 	}
 
 	val := stateDB.GetState(contract, key)
-
 	return val[:], nil
 }
 
@@ -260,7 +252,6 @@ func (b *SimulatedBackend) TransactionReceipt(ctx context.Context, txHash common
 	if receipt == nil {
 		return nil, ethereum.NotFound
 	}
-
 	return receipt, nil
 }
 
@@ -276,12 +267,10 @@ func (b *SimulatedBackend) TransactionByHash(ctx context.Context, txHash common.
 	if tx != nil {
 		return tx, true, nil
 	}
-
 	tx, _, _, _ = rawdb.ReadTransaction(b.database, txHash)
 	if tx != nil {
 		return tx, false, nil
 	}
-
 	return nil, false, ethereum.NotFound
 }
 
@@ -416,11 +405,9 @@ func (b *SimulatedBackend) PendingCodeAt(ctx context.Context, contract common.Ad
 func newRevertError(result *core.ExecutionResult) *revertError {
 	reason, errUnpack := abi.UnpackRevert(result.Revert())
 	err := errors.New("execution reverted")
-
 	if errUnpack == nil {
 		err = fmt.Errorf("execution reverted: %v", reason)
 	}
-
 	return &revertError{
 		error:  err,
 		reason: hexutil.Encode(result.Revert()),
@@ -453,12 +440,10 @@ func (b *SimulatedBackend) CallContract(ctx context.Context, call ethereum.CallM
 	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number) != 0 {
 		return nil, errBlockNumberUnsupported
 	}
-
 	stateDB, err := b.blockchain.State()
 	if err != nil {
 		return nil, err
 	}
-
 	res, err := b.callContract(ctx, call, b.blockchain.CurrentBlock(), stateDB)
 	if err != nil {
 		return nil, err
@@ -467,7 +452,6 @@ func (b *SimulatedBackend) CallContract(ctx context.Context, call ethereum.CallM
 	if len(res.Revert()) > 0 {
 		return nil, newRevertError(res)
 	}
-
 	return res.Return(), res.Err
 }
 
@@ -485,7 +469,6 @@ func (b *SimulatedBackend) PendingCallContract(ctx context.Context, call ethereu
 	if len(res.Revert()) > 0 {
 		return nil, newRevertError(res)
 	}
-
 	return res.Return(), res.Err
 }
 
@@ -507,7 +490,6 @@ func (b *SimulatedBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error
 	if b.pendingBlock.Header().BaseFee != nil {
 		return b.pendingBlock.Header().BaseFee, nil
 	}
-
 	return big.NewInt(1), nil
 }
 
@@ -529,7 +511,6 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
 		hi  uint64
 		cap uint64
 	)
-
 	if call.Gas >= params.TxGas {
 		hi = call.Gas
 	} else {
@@ -537,7 +518,6 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
 	}
 	// Normalize the max fee per gas the call is willing to spend.
 	var feeCap *big.Int
-
 	if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) {
 		return 0, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
 	} else if call.GasPrice != nil {
@@ -550,30 +530,24 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
 	// Recap the highest gas allowance with account's balance.
 	if feeCap.BitLen() != 0 {
 		balance := b.pendingState.GetBalance(call.From) // from can't be nil
-
 		available := new(big.Int).Set(balance)
 		if call.Value != nil {
 			if call.Value.Cmp(available) >= 0 {
 				return 0, core.ErrInsufficientFundsForTransfer
 			}
-
 			available.Sub(available, call.Value)
 		}
-
 		allowance := new(big.Int).Div(available, feeCap)
 		if allowance.IsUint64() && hi > allowance.Uint64() {
 			transfer := call.Value
 			if transfer == nil {
 				transfer = new(big.Int)
 			}
-
 			log.Warn("Gas estimation capped by limited funds", "original", hi, "balance", balance,
 				"sent", transfer, "feecap", feeCap, "fundable", allowance)
-
 			hi = allowance.Uint64()
 		}
 	}
-
 	cap = hi
 
 	// Create a helper to check if a gas allowance results in an executable transaction
@@ -588,10 +562,8 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
 			if errors.Is(err, core.ErrIntrinsicGas) {
 				return true, nil, nil // Special case, raise gas limit
 			}
-
 			return true, nil, err // Bail out
 		}
-
 		return res.Failed(), res, nil
 	}
 	// Execute the binary search and hone in on an executable gas limit
@@ -605,7 +577,6 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
 		if err != nil {
 			return 0, err
 		}
-
 		if failed {
 			lo = mid
 		} else {
@@ -618,38 +589,33 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
 		if err != nil {
 			return 0, err
 		}
-
 		if failed {
 			if result != nil && result.Err != vm.ErrOutOfGas {
 				if len(result.Revert()) > 0 {
 					return 0, newRevertError(result)
 				}
-
 				return 0, result.Err
 			}
 			// Otherwise, the specified gas cap is too low
 			return 0, fmt.Errorf("gas required exceeds allowance (%d)", cap)
 		}
 	}
-
 	return hi, nil
 }
 
 // callContract implements common code between normal and pending contract calls.
 // state is modified during execution, make sure to copy it if necessary.
-func (b *SimulatedBackend) callContract(_ context.Context, call ethereum.CallMsg, header *types.Header, stateDB *state.StateDB) (*core.ExecutionResult, error) {
+func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, header *types.Header, stateDB *state.StateDB) (*core.ExecutionResult, error) {
 	// Gas prices post 1559 need to be initialized
 	if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) {
 		return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
 	}
-
 	head := b.blockchain.CurrentHeader()
 	if !b.blockchain.Config().IsLondon(head.Number) {
 		// If there's no basefee, then it must be a non-1559 execution
 		if call.GasPrice == nil {
 			call.GasPrice = new(big.Int)
 		}
-
 		call.GasFeeCap, call.GasTipCap = call.GasPrice, call.GasPrice
 	} else {
 		// A basefee is provided, necessitating 1559-type execution
@@ -661,7 +627,6 @@ func (b *SimulatedBackend) callContract(_ context.Context, call ethereum.CallMsg
 			if call.GasFeeCap == nil {
 				call.GasFeeCap = new(big.Int)
 			}
-
 			if call.GasTipCap == nil {
 				call.GasTipCap = new(big.Int)
 			}
@@ -676,7 +641,6 @@ func (b *SimulatedBackend) callContract(_ context.Context, call ethereum.CallMsg
 	if call.Gas == 0 {
 		call.Gas = 50000000
 	}
-
 	if call.Value == nil {
 		call.Value = new(big.Int)
 	}
@@ -706,7 +670,6 @@ func (b *SimulatedBackend) callContract(_ context.Context, call ethereum.CallMsg
 	vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true})
 	gasPool := new(core.GasPool).AddGas(math.MaxUint64)
 
-	//nolint:contextcheck
 	return core.ApplyMessage(vmEnv, msg, gasPool, context.Background())
 }
 
@@ -726,18 +689,15 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
 	if err != nil {
 		return fmt.Errorf("invalid transaction: %v", err)
 	}
-
 	nonce := b.pendingState.GetNonce(sender)
 	if tx.Nonce() != nonce {
 		return fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce)
 	}
 	// Include tx in chain
-	// nolint : contextcheck
 	blocks, receipts := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
 		for _, tx := range b.pendingBlock.Transactions() {
 			block.AddTxWithChain(b.blockchain, tx)
 		}
-
 		block.AddTxWithChain(b.blockchain, tx)
 	})
 	stateDB, _ := b.blockchain.State()
@@ -745,7 +705,6 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
 	b.pendingBlock = blocks[0]
 	b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil)
 	b.pendingReceipts = receipts[0]
-
 	return nil
 }
 
@@ -764,7 +723,6 @@ func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.Filter
 		if query.FromBlock != nil {
 			from = query.FromBlock.Int64()
 		}
-
 		to := int64(-1)
 		if query.ToBlock != nil {
 			to = query.ToBlock.Int64()
@@ -777,12 +735,10 @@ func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.Filter
 	if err != nil {
 		return nil, err
 	}
-
 	res := make([]types.Log, len(logs))
 	for i, nLog := range logs {
 		res[i] = *nLog
 	}
-
 	return res, nil
 }
 
@@ -799,7 +755,6 @@ func (b *SimulatedBackend) SubscribeFilterLogs(ctx context.Context, query ethere
 	// Since we're getting logs in batches, we need to flatten them into a plain stream
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
-
 		for {
 			select {
 			case logs := <-sink:
@@ -829,7 +784,6 @@ func (b *SimulatedBackend) SubscribeNewHead(ctx context.Context, ch chan<- *type
 
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
-
 		for {
 			select {
 			case head := <-sink:
@@ -893,13 +847,11 @@ func (fb *filterBackend) ChainDb() ethdb.Database { return fb.db }
 func (fb *filterBackend) EventMux() *event.TypeMux { panic("not supported") }
 
 func (fb *filterBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
-	// nolint : exhaustive
 	switch number {
 	case rpc.PendingBlockNumber:
 		if block := fb.backend.pendingBlock; block != nil {
 			return block.Header(), nil
 		}
-
 		return nil, nil
 	case rpc.LatestBlockNumber:
 		return fb.bc.CurrentHeader(), nil
@@ -920,7 +872,6 @@ func (fb *filterBackend) GetBody(ctx context.Context, hash common.Hash, number r
 	if body := fb.bc.GetBody(hash); body != nil {
 		return body, nil
 	}
-
 	return nil, errors.New("block body not found")
 }
 

cmd/evm/internal/t8ntool/gen_stenv.go

@@ -55,13 +55,9 @@ func (s stEnv) MarshalJSON() ([]byte, error) {
 	enc.Withdrawals = s.Withdrawals
 	enc.BaseFee = (*math.HexOrDecimal256)(s.BaseFee)
 	enc.ParentUncleHash = s.ParentUncleHash
-<<<<<<< HEAD
-
-=======
 	enc.ExcessBlobGas = (*math.HexOrDecimal64)(s.ExcessBlobGas)
 	enc.ParentExcessBlobGas = (*math.HexOrDecimal64)(s.ParentExcessBlobGas)
 	enc.ParentBlobGasUsed = (*math.HexOrDecimal64)(s.ParentBlobGasUsed)
->>>>>>> bed84606583893fdb698cc1b5058cc47b4dbd837
 	return json.Marshal(&enc)
 }
 
@@ -163,9 +159,6 @@ func (s *stEnv) UnmarshalJSON(input []byte) error {
 	if dec.ParentUncleHash != nil {
 		s.ParentUncleHash = *dec.ParentUncleHash
 	}
-<<<<<<< HEAD
-
-=======
 	if dec.ExcessBlobGas != nil {
 		s.ExcessBlobGas = (*uint64)(dec.ExcessBlobGas)
 	}
@@ -175,6 +168,5 @@ func (s *stEnv) UnmarshalJSON(input []byte) error {
 	if dec.ParentBlobGasUsed != nil {
 		s.ParentBlobGasUsed = (*uint64)(dec.ParentBlobGasUsed)
 	}
->>>>>>> bed84606583893fdb698cc1b5058cc47b4dbd837
 	return nil
 }

cmd/evm/internal/t8ntool/transaction.go

@@ -122,12 +122,7 @@ func Transaction(ctx *cli.Context) error {
 			return NewError(ErrorIO, errors.New("only rlp supported"))
 		}
 	}
-<<<<<<< HEAD
-
-	signer := types.MakeSigner(chainConfig, new(big.Int))
-=======
 	signer := types.MakeSigner(chainConfig, new(big.Int), 0)
->>>>>>> bed84606583893fdb698cc1b5058cc47b4dbd837
 	// We now have the transactions in 'body', which is supposed to be an
 	// rlp list of transactions
 	it, err := rlp.NewListIterator([]byte(body))

cmd/evm/internal/t8ntool/transition.go

@@ -285,12 +285,7 @@ func Transition(ctx *cli.Context) error {
 			return NewError(ErrorConfig, errors.New("EIP-1559 config but missing 'currentBaseFee' in env section"))
 		}
 	}
-<<<<<<< HEAD
-	// TODO marcello double check
-	if chainConfig.IsShanghai(prestate.Env.Number) && prestate.Env.Withdrawals == nil {
-=======
 	if chainConfig.IsShanghai(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) && prestate.Env.Withdrawals == nil {
->>>>>>> bed84606583893fdb698cc1b5058cc47b4dbd837
 		return NewError(ErrorConfig, errors.New("Shanghai config but missing 'withdrawals' in env section"))
 	}
 

cmd/utils/bor_flags.go

@@ -118,10 +118,7 @@ func CreateBorEthereum(cfg *ethconfig.Config) *eth.Ethereum {
 		Fatalf("Failed to start stack: %v", err)
 	}
 
-	_, err = stack.Attach()
+	stack.Attach()
-	if err != nil {
-		Fatalf("Failed to attach to node: %v", err)
-	}
 
 	return ethereum
 }

cmd/utils/flags.go

@@ -2001,16 +2001,13 @@ func RegisterEthService(stack *node.Node, cfg *ethconfig.Config) (ethapi.Backend
 		if err != nil {
 			Fatalf("Failed to register the Ethereum service: %v", err)
 		}
-
 		stack.RegisterAPIs(tracers.APIs(backend.ApiBackend))
 		return backend.ApiBackend, nil
 	}
-
 	backend, err := eth.New(stack, cfg)
 	if err != nil {
 		Fatalf("Failed to register the Ethereum service: %v", err)
 	}
-
 	if cfg.LightServ > 0 {
 		_, err := les.NewLesServer(stack, backend, cfg)
 		if err != nil {
@@ -2018,7 +2015,6 @@ func RegisterEthService(stack *node.Node, cfg *ethconfig.Config) (ethapi.Backend
 		}
 	}
 	stack.RegisterAPIs(tracers.APIs(backend.APIBackend))
-
 	return backend.APIBackend, backend
 }
 
@@ -2267,7 +2263,7 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readonly bool) (*core.BlockCh
 		UseHeimdallApp:      ctx.Bool(UseHeimdallAppFlag.Name),
 	}
 	_ = CreateBorEthereum(configs)
-	engine := ethconfig.CreateConsensusEngine(stack, config, configs, &ethashConfig, cliqueConfig, nil, false, chainDb, nil)
+	engine := ethconfig.CreateConsensusEngine(stack, config, configs, nil, false, chainDb, nil)
 
 	if gcmode := ctx.String(GCModeFlag.Name); gcmode != "full" && gcmode != "archive" {
 		Fatalf("--%s must be either 'full' or 'archive'", GCModeFlag.Name)

consensus/bor/api/caller.go

@@ -11,6 +11,6 @@ import (
 
 //go:generate mockgen -destination=./caller_mock.go -package=api . Caller
 type Caller interface {
-	Call(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *ethapi.StateOverride) (hexutil.Bytes, error)
+	Call(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *ethapi.StateOverride, blockOverrides *ethapi.BlockOverrides) (hexutil.Bytes, error)
-	CallWithState(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *ethapi.StateOverride) (hexutil.Bytes, error)
+	CallWithState(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *ethapi.StateOverride, blockOverrides *ethapi.BlockOverrides) (hexutil.Bytes, error)
 }

consensus/bor/bor.go

@@ -30,6 +30,7 @@ import (
 	"github.com/ethereum/go-ethereum/consensus/bor/statefull"
 	"github.com/ethereum/go-ethereum/consensus/bor/valset"
 	"github.com/ethereum/go-ethereum/consensus/misc"
+	"github.com/ethereum/go-ethereum/consensus/misc/eip1559"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -294,7 +295,7 @@ func (c *Bor) Author(header *types.Header) (common.Address, error) {
 }
 
 // VerifyHeader checks whether a header conforms to the consensus rules.
-func (c *Bor) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header, _ bool) error {
+func (c *Bor) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header) error {
 	return c.verifyHeader(chain, header, nil)
 }
 
@@ -309,7 +310,7 @@ func (c *Bor) SetSpanner(spanner Spanner) {
 // VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers. The
 // method returns a quit channel to abort the operations and a results channel to
 // retrieve the async verifications (the order is that of the input slice).
-func (c *Bor) VerifyHeaders(chain consensus.ChainHeaderReader, headers []*types.Header, _ []bool) (chan<- struct{}, <-chan error) {
+func (c *Bor) VerifyHeaders(chain consensus.ChainHeaderReader, headers []*types.Header) (chan<- struct{}, <-chan error) {
 	abort := make(chan struct{})
 	results := make(chan error, len(headers))
 
@@ -443,7 +444,7 @@ func (c *Bor) verifyCascadingFields(chain consensus.ChainHeaderReader, header *t
 		if err := misc.VerifyGaslimit(parent.GasLimit, header.GasLimit); err != nil {
 			return err
 		}
-	} else if err := misc.VerifyEip1559Header(chain.Config(), parent, header); err != nil {
+	} else if err := eip1559.VerifyEIP1559Header(chain.Config(), parent, header); err != nil {
 		// Verify the header's EIP-1559 attributes.
 		return err
 	}

consensus/bor/bor_test.go

@@ -71,7 +71,7 @@ func TestGenesisContractChange(t *testing.T) {
 		b.Finalize(chain, h, statedb, nil, nil, nil)
 
 		// write state to database
-		root, err := statedb.Commit(false)
+		root, err := statedb.Commit(0, false)
 		require.NoError(t, err)
 		require.NoError(t, statedb.Database().TrieDB().Commit(root, true))
 

consensus/bor/contract/client.go

@@ -122,7 +122,7 @@ func (gc *GenesisContractsClient) LastStateId(state *state.StateDB, number uint6
 		Gas:  &gas,
 		To:   &toAddress,
 		Data: &msgData,
-	}, rpc.BlockNumberOrHash{BlockNumber: &blockNr, BlockHash: &hash}, state, nil)
+	}, rpc.BlockNumberOrHash{BlockNumber: &blockNr, BlockHash: &hash}, state, nil, nil)
 	if err != nil {
 		return nil, err
 	}

consensus/bor/heimdall/span/spanner.go

@@ -62,7 +62,7 @@ func (c *ChainSpanner) GetCurrentSpan(ctx context.Context, headerHash common.Has
 		Gas:  &gas,
 		To:   &toAddress,
 		Data: &msgData,
-	}, blockNr, nil)
+	}, blockNr, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -111,7 +111,7 @@ func (c *ChainSpanner) GetCurrentValidatorsByBlockNrOrHash(ctx context.Context,
 		Gas:  &gas,
 		To:   &toAddress,
 		Data: &msgData,
-	}, blockNrOrHash, nil)
+	}, blockNrOrHash, nil, nil)
 	if err != nil {
 		return nil, err
 	}

consensus/ethash/ethash.go

@@ -18,6 +18,7 @@
 package ethash
 
 import (
+	"context"
 	"time"
 
 	"github.com/ethereum/go-ethereum/consensus"
@@ -80,6 +81,6 @@ func (ethash *Ethash) APIs(chain consensus.ChainHeaderReader) []rpc.API {
 // Seal generates a new sealing request for the given input block and pushes
 // the result into the given channel. For the ethash engine, this method will
 // just panic as sealing is not supported anymore.
-func (ethash *Ethash) Seal(chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
+func (ethash *Ethash) Seal(ctx context.Context, chain consensus.ChainHeaderReader, block *types.Block, results chan<- *types.Block, stop <-chan struct{}) error {
 	panic("ethash (pow) sealing not supported any more")
 }

core/blockchain.go

@@ -490,7 +490,6 @@ func NewParallelBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis
 	// Open trie database with provided config
 	triedb := trie.NewDatabaseWithConfig(db, &trie.Config{
 		Cache:     cacheConfig.TrieCleanLimit,
-		Journal:   cacheConfig.TrieCleanJournal,
 		Preimages: cacheConfig.Preimages,
 	})
 	chainConfig, _, genesisErr := SetupGenesisBlockWithOverride(db, triedb, genesis, overrides)
@@ -3103,3 +3102,7 @@ func (bc *BlockChain) SetTrieFlushInterval(interval time.Duration) {
 func (bc *BlockChain) GetTrieFlushInterval() time.Duration {
 	return time.Duration(bc.flushInterval.Load())
 }
+
+func (bc *BlockChain) SubscribeChain2HeadEvent(ch chan<- Chain2HeadEvent) event.Subscription {
+	return bc.scope.Track(bc.chain2HeadFeed.Subscribe(ch))
+}

core/blockchain_test.go

@@ -1041,7 +1041,7 @@ func TestLightVsFastVsFullChainHeads(t *testing.T) {
 	// Import the chain as a light node and ensure all pointers are updated
 	lightDb := makeDb()
 	defer lightDb.Close()
-	light, _ := NewBlockChain(lightDb, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil)
+	light, _ := NewBlockChain(lightDb, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, nil, nil)
 	if n, err := light.InsertHeaderChain(headers); err != nil {
 		t.Fatalf("failed to insert header %d: %v", n, err)
 	}

core/genesis.go

@@ -481,8 +481,6 @@ func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig {
 		return params.MumbaiChainConfig
 	case ghash == params.BorMainnetGenesisHash:
 		return params.BorMainnetChainConfig
-	case ghash == params.KilnGenesisHash:
-		return DefaultKilnGenesisBlock().Config
 	default:
 		return params.AllEthashProtocolChanges
 	}
@@ -673,17 +671,6 @@ func DefaultBorMainnetGenesisBlock() *Genesis {
 	}
 }
 
-func DefaultKilnGenesisBlock() *Genesis {
-	g := new(Genesis)
-	reader := strings.NewReader(KilnAllocData)
-
-	if err := json.NewDecoder(reader).Decode(g); err != nil {
-		panic(err)
-	}
-
-	return g
-}
-
 // DeveloperGenesisBlock returns the 'geth --dev' genesis block.
 func DeveloperGenesisBlock(gasLimit uint64, faucet common.Address) *Genesis {
 	// Override the default period to the user requested one

core/parallel_state_processor.go

@@ -296,7 +296,7 @@ func (p *ParallelStateProcessor) Process(block *types.Block, statedb *state.Stat
 
 	// Iterate over and process the individual transactions
 	for i, tx := range block.Transactions() {
-		msg, err := TransactionToMessage(tx, types.MakeSigner(p.config, header.Number), header.BaseFee)
+		msg, err := TransactionToMessage(tx, types.MakeSigner(p.config, header.Number, header.Time), header.BaseFee)
 		if err != nil {
 			log.Error("error creating message", "err", err)
 			return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)

core/rawdb/accessors_chain.go

@@ -816,17 +816,9 @@ func ReadLogs(db ethdb.Reader, hash common.Hash, number uint64, config *params.C
 	if len(data) == 0 {
 		return nil
 	}
-
 	receipts := []*receiptLogs{}
 	if err := rlp.DecodeBytes(data, &receipts); err != nil {
-		// Receipts might be in the legacy format, try decoding that.
-		// TODO: to be removed after users migrated
-		if logs := readLegacyLogs(db, hash, number, config); logs != nil {
-			return logs
-		}
-
 		log.Error("Invalid receipt array RLP", "hash", hash, "err", err)
-
 		return nil
 	}
 
@@ -834,24 +826,6 @@ func ReadLogs(db ethdb.Reader, hash common.Hash, number uint64, config *params.C
 	for i, receipt := range receipts {
 		logs[i] = receipt.Logs
 	}
-
-	return logs
-}
-
-// readLegacyLogs is a temporary workaround for when trying to read logs
-// from a block which has its receipt stored in the legacy format. It'll
-// be removed after users have migrated their freezer databases.
-func readLegacyLogs(db ethdb.Reader, hash common.Hash, number uint64, config *params.ChainConfig) [][]*types.Log {
-	receipts := ReadReceipts(db, hash, number, config)
-	if receipts == nil {
-		return nil
-	}
-
-	logs := make([][]*types.Log, len(receipts))
-	for i, receipt := range receipts {
-		logs[i] = receipt.Logs
-	}
-
 	return logs
 }
 

core/state/iterator_test.go

@@ -28,7 +28,7 @@ import (
 func TestNodeIteratorCoverage(t *testing.T) {
 	// Create some arbitrary test state to iterate
 	db, sdb, root, _ := makeTestState()
-	_ = sdb.TrieDB().Commit(root, false)
+	sdb.TrieDB().Commit(root, false)
 
 	state, err := New(root, sdb, nil)
 	if err != nil {
@@ -46,15 +46,12 @@ func TestNodeIteratorCoverage(t *testing.T) {
 		seenNodes = make(map[common.Hash]struct{})
 		seenCodes = make(map[common.Hash]struct{})
 	)
-
 	it := db.NewIterator(nil, nil)
-
 	for it.Next() {
 		ok, hash := isTrieNode(sdb.TrieDB().Scheme(), it.Key(), it.Value())
 		if !ok {
 			continue
 		}
-
 		seenNodes[hash] = struct{}{}
 	}
 	it.Release()
@@ -66,22 +63,19 @@ func TestNodeIteratorCoverage(t *testing.T) {
 		if !ok {
 			continue
 		}
-
 		if _, ok := hashes[common.BytesToHash(hash)]; !ok {
 			t.Errorf("state entry not reported %x", it.Key())
 		}
-
 		seenCodes[common.BytesToHash(hash)] = struct{}{}
 	}
 	it.Release()
 
-	// Cross-check the iterated hashes and the database/nodepool content
+	// Cross check the iterated hashes and the database/nodepool content
 	for hash := range hashes {
 		_, ok := seenNodes[hash]
 		if !ok {
 			_, ok = seenCodes[hash]
 		}
-
 		if !ok {
 			t.Errorf("failed to retrieve reported node %x", hash)
 		}
@@ -90,7 +84,7 @@ func TestNodeIteratorCoverage(t *testing.T) {
 
 // isTrieNode is a helper function which reports if the provided
 // database entry belongs to a trie node or not.
-func isTrieNode(scheme string, key, _ []byte) (bool, common.Hash) {
+func isTrieNode(scheme string, key, val []byte) (bool, common.Hash) {
 	if scheme == rawdb.HashScheme {
 		if rawdb.IsLegacyTrieNode(key, val) {
 			return true, common.BytesToHash(key)
@@ -105,6 +99,5 @@ func isTrieNode(scheme string, key, _ []byte) (bool, common.Hash) {
 			return true, crypto.Keccak256Hash(val)
 		}
 	}
-
 	return false, common.Hash{}
 }

core/state/statedb.go

@@ -398,10 +398,11 @@ func (s *StateDB) ApplyMVWriteSet(writes []blockstm.WriteDescriptor) {
 				s.SetNonce(addr, sr.GetNonce(addr))
 			case CodePath:
 				s.SetCode(addr, sr.GetCode(addr))
+			// TODO - Arpit -----------------
 			case SuicidePath:
 				stateObject := sr.getDeletedStateObject(addr)
 				if stateObject != nil && stateObject.deleted {
-					s.Suicide(addr)
+					s.SelfDestruct(addr)
 				}
 			default:
 				panic(fmt.Errorf("unknown key type: %d", path.GetSubpath()))
@@ -626,18 +627,11 @@ func (s *StateDB) Version() blockstm.Version {
 	}
 }
 
-func (s *StateDB) GetCode(addr common.Address) []byte {
-	stateObject := s.getStateObject(addr)
-	if stateObject != nil {
-		return stateObject.Code()
-	}
-}
-
 func (s *StateDB) GetCode(addr common.Address) []byte {
 	return MVRead(s, blockstm.NewSubpathKey(addr, CodePath), nil, func(s *StateDB) []byte {
 		stateObject := s.getStateObject(addr)
 		if stateObject != nil {
-			return stateObject.Code(s.db)
+			return stateObject.Code()
 		}
 
 		return nil
@@ -870,12 +864,9 @@ func (s *StateDB) SelfDestruct(addr common.Address) {
 	})
 	stateObject.markSelfdestructed()
 	stateObject.data.Balance = new(big.Int)
-}
 
 	MVWrite(s, blockstm.NewSubpathKey(addr, SuicidePath))
 	MVWrite(s, blockstm.NewSubpathKey(addr, BalancePath))
-
-	return true
 }
 
 func (s *StateDB) Selfdestruct6780(addr common.Address) {
@@ -1038,7 +1029,6 @@ func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {
 				return nil
 			}
 		}
-	}
 		// If snapshot unavailable or reading from it failed, load from the database
 		if data == nil {
 			start := time.Now()
@@ -1059,6 +1049,7 @@ func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {
 		obj := newObject(s, addr, data)
 		s.setStateObject(obj)
 		return obj
+	})
 }
 
 func (s *StateDB) setStateObject(object *stateObject) {
@@ -1366,7 +1357,7 @@ func (s *StateDB) Finalise(deleteEmptyObjects bool) {
 			continue
 		}
 
-if obj.selfDestructed || (deleteEmptyObjects && obj.empty()) {
+		if obj.selfDestructed || (deleteEmptyObjects && obj.empty()) {
 			obj.deleted = true
 
 			// We need to maintain account deletions explicitly (will remain

core/state/statedb_test.go

@@ -592,7 +592,7 @@ func TestMVHashMapReadWriteDelete(t *testing.T) {
 	assert.Equal(t, balance, b)
 
 	// Tx3 delete
-	states[3].Suicide(addr)
+	states[3].SelfDestruct(addr)
 
 	// Within Tx 3, the state should not change before finalize
 	v = states[3].GetState(addr, key)
@@ -648,7 +648,7 @@ func TestMVHashMapRevert(t *testing.T) {
 	assert.Equal(t, new(big.Int).SetUint64(uint64(200)), b)
 	assert.Equal(t, common.HexToHash("0x02"), v)
 
-	states[1].Suicide(addr)
+	states[1].SelfDestruct(addr)
 
 	states[1].RevertToSnapshot(snapshot)
 
@@ -983,12 +983,12 @@ func TestApplyMVWriteSet(t *testing.T) {
 	assert.Equal(t, sSingleProcess.IntermediateRoot(true), sClean.IntermediateRoot(true))
 
 	// Tx3 write
-	states[3].Suicide(addr2)
+	states[3].SelfDestruct(addr2)
 	states[3].SetCode(addr1, code)
 	states[3].Finalise(true)
 	states[3].FlushMVWriteSet()
 
-	sSingleProcess.Suicide(addr2)
+	sSingleProcess.SelfDestruct(addr2)
 	sSingleProcess.SetCode(addr1, code)
 
 	sClean.ApplyMVWriteSet(states[3].MVWriteList())

core/state_processor_test.go

@@ -49,7 +49,6 @@ func TestStateProcessorErrors(t *testing.T) {
 	var (
 		cacheConfig = &CacheConfig{
 			TrieCleanLimit: 154,
-			TrieCleanJournal: "triecache",
 			Preimages:      true,
 		}
 
@@ -138,7 +137,7 @@ func TestStateProcessorErrors(t *testing.T) {
 					},
 				},
 			}
-			blockchain, _  = NewBlockChain(db, nil, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil)
+			blockchain, _  = NewBlockChain(db, nil, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil, nil)
 			tooBigInitCode = [params.MaxInitCodeSize + 1]byte{}
 		)
 
@@ -349,7 +348,7 @@ func TestStateProcessorErrors(t *testing.T) {
 				},
 			}
 			parallelBlockchain, _ = NewParallelBlockChain(db, cacheConfig, gspec, nil, ethash.NewFaker(), vm.Config{ParallelEnable: true, ParallelSpeculativeProcesses: 8}, nil, nil, nil)
-			blockchain, _         = NewBlockChain(db, nil, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil)
+			blockchain, _         = NewBlockChain(db, nil, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil, nil)
 		)
 
 		defer blockchain.Stop()
@@ -432,13 +431,13 @@ func TestStateProcessorErrors(t *testing.T) {
 			}{
 				{ // ErrMaxInitCodeSizeExceeded
 					txs: []*types.Transaction{
-						mkDynamicCreationTx(0, 500000, common.Big0, misc.CalcBaseFee(config, genesis.Header()), tooBigInitCode[:]),
+						mkDynamicCreationTx(0, 500000, common.Big0, eip1559.CalcBaseFee(config, genesis.Header()), tooBigInitCode[:]),
 					},
 					want: "could not apply tx 0 [0x832b54a6c3359474a9f504b1003b2cc1b6fcaa18e4ef369eb45b5d40dad6378f]: max initcode size exceeded: code size 49153 limit 49152",
 				},
 				{ // ErrIntrinsicGas: Not enough gas to cover init code
 					txs: []*types.Transaction{
-						mkDynamicCreationTx(0, 54299, common.Big0, misc.CalcBaseFee(config, genesis.Header()), smallInitCode[:]),
+						mkDynamicCreationTx(0, 54299, common.Big0, eip1559.CalcBaseFee(config, genesis.Header()), smallInitCode[:]),
 					},
 					want: "could not apply tx 0 [0x39b7436cb432d3662a25626474282c5c4c1a213326fd87e4e18a91477bae98b2]: intrinsic gas too low: have 54299, want 54300",
 				},

core/txpool/legacypool/legacypool.go

@@ -37,6 +37,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/params"
+	"github.com/holiman/uint256"
 )
 
 const (
@@ -103,6 +104,11 @@ var (
 	localGauge   = metrics.NewRegisteredGauge("txpool/local", nil)
 	slotsGauge   = metrics.NewRegisteredGauge("txpool/slots", nil)
 
+	resetCacheGauge  = metrics.NewRegisteredGauge("txpool/resetcache", nil)
+	reinitCacheGauge = metrics.NewRegisteredGauge("txpool/reinittcache", nil)
+	hitCacheCounter  = metrics.NewRegisteredCounter("txpool/cachehit", nil)
+	missCacheCounter = metrics.NewRegisteredCounter("txpool/cachemiss", nil)
+
 	reheapTimer = metrics.NewRegisteredTimer("txpool/reheap", nil)
 )
 
@@ -1437,7 +1443,8 @@ func (pool *LegacyPool) promoteExecutables(accounts []common.Address) []*types.T
 		}
 		log.Trace("Removed old queued transactions", "count", len(forwards))
 		// Drop all transactions that are too costly (low balance or out of gas)
-		drops, _ := list.Filter(pool.currentState.GetBalance(addr), gasLimit)
+		balUint256, _ := uint256.FromBig(pool.currentState.GetBalance(addr))
+		drops, _ := list.Filter(balUint256, gasLimit)
 		for _, tx := range drops {
 			hash := tx.Hash()
 			pool.all.Remove(hash)
@@ -1638,7 +1645,8 @@ func (pool *LegacyPool) demoteUnexecutables() {
 			log.Trace("Removed old pending transaction", "hash", hash)
 		}
 		// Drop all transactions that are too costly (low balance or out of gas), and queue any invalids back for later
-		drops, invalids := list.Filter(pool.currentState.GetBalance(addr), gasLimit)
+		balUint256, _ := uint256.FromBig(pool.currentState.GetBalance(addr))
+		drops, invalids := list.Filter(balUint256, gasLimit)
 		for _, tx := range drops {
 			hash := tx.Hash()
 			log.Trace("Removed unpayable pending transaction", "hash", hash)

core/txpool/legacypool/list.go

@@ -463,41 +463,37 @@ func (l *list) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Transa
 		if old.GasFeeCapCmp(tx) >= 0 || old.GasTipCapCmp(tx) >= 0 {
 			return false, nil
 		}
-
 		// thresholdFeeCap = oldFC  * (100 + priceBump) / 100
-		a := uint256.NewInt(100 + priceBump)
+		a := big.NewInt(100 + int64(priceBump))
-		aFeeCap := uint256.NewInt(0).Mul(a, old.GasFeeCapUint())
+		aFeeCap := new(big.Int).Mul(a, old.GasFeeCap())
-		aTip := a.Mul(a, old.GasTipCapUint())
+		aTip := a.Mul(a, old.GasTipCap())
 
 		// thresholdTip    = oldTip * (100 + priceBump) / 100
-		b := cmath.U100
+		b := big.NewInt(100)
 		thresholdFeeCap := aFeeCap.Div(aFeeCap, b)
 		thresholdTip := aTip.Div(aTip, b)
 
 		// We have to ensure that both the new fee cap and tip are higher than the
 		// old ones as well as checking the percentage threshold to ensure that
 		// this is accurate for low (Wei-level) gas price replacements.
-		if tx.GasFeeCapUIntLt(thresholdFeeCap) || tx.GasTipCapUIntLt(thresholdTip) {
+		if tx.GasFeeCapIntCmp(thresholdFeeCap) < 0 || tx.GasTipCapIntCmp(thresholdTip) < 0 {
 			return false, nil
 		}
 		// Old is being replaced, subtract old cost
 		l.subTotalCost([]*types.Transaction{old})
 	}
-
 	// Add new tx cost to totalcost
 	l.totalcost.Add(l.totalcost, tx.Cost())
-
 	// Otherwise overwrite the old transaction with the current one
 	l.txs.Put(tx)
-
+	cost := tx.Cost()
-	if cost := tx.CostUint(); l.costcap == nil || l.costcap.Lt(cost) {
+	costUint256, _ := uint256.FromBig(cost)
-		l.costcap = cost
+	if cost = tx.Cost(); l.costcap.Cmp(costUint256) < 0 {
+		l.costcap = costUint256
 	}
-
 	if gas := tx.Gas(); l.gascap < gas {
 		l.gascap = gas
 	}
-
 	return true, old
 }
 
@@ -648,7 +644,7 @@ func (l *list) subTotalCost(txs []*types.Transaction) {
 // then the heap is sorted based on the effective tip based on the given base fee.
 // If baseFee is nil then the sorting is based on gasFeeCap.
 type priceHeap struct {
-	baseFee   *uint256.Int // heap should always be re-sorted after baseFee is changed
+	baseFee   *big.Int // heap should always be re-sorted after baseFee is changed
 	list      []*types.Transaction
 	baseFeeMu sync.RWMutex
 }
@@ -672,7 +668,7 @@ func (h *priceHeap) cmp(a, b *types.Transaction) int {
 
 	if h.baseFee != nil {
 		// Compare effective tips if baseFee is specified
-		if c := a.EffectiveGasTipTxUintCmp(b, h.baseFee); c != 0 {
+		if c := a.EffectiveGasTipCmp(b, h.baseFee); c != 0 {
 			h.baseFeeMu.RUnlock()
 
 			return c
@@ -872,7 +868,7 @@ func (l *pricedList) Reheap() {
 
 // SetBaseFee updates the base fee and triggers a re-heap. Note that Removed is not
 // necessary to call right before SetBaseFee when processing a new block.
-func (l *pricedList) SetBaseFee(baseFee *uint256.Int) {
+func (l *pricedList) SetBaseFee(baseFee *big.Int) {
 	l.urgent.baseFeeMu.Lock()
 	l.urgent.baseFee = baseFee
 	l.urgent.baseFeeMu.Unlock()

core/txpool/txpool.go

@@ -383,10 +383,6 @@ func (p *TxPool) ContentFrom(addr common.Address) ([]*types.Transaction, []*type
 		if len(run) != 0 || len(block) != 0 {
 			return run, block
 		}
-
-		if err != nil {
-			errs = append(errs, err)
-		}
 	}
 	return []*types.Transaction{}, []*types.Transaction{}
 }
@@ -415,8 +411,6 @@ func (p *TxPool) Status(hash common.Hash) TxStatus {
 		if status := subpool.Status(hash); status != TxStatusUnknown {
 			return status
 		}
-
-		pool.pendingMu.TryLock()
 	}
 	return TxStatusUnknown
 }

core/types/gen_receipt_json.go

@@ -107,7 +107,7 @@ func (r *Receipt) UnmarshalJSON(input []byte) error {
 	}
 	r.GasUsed = uint64(*dec.GasUsed)
 	if dec.EffectiveGasPrice != nil {
-		r.EffectiveGasPrice = dec.EffectiveGasPrice
+		r.EffectiveGasPrice = (*big.Int)(dec.EffectiveGasPrice)
 	}
 	if dec.BlobGasUsed != nil {
 		r.BlobGasUsed = uint64(*dec.BlobGasUsed)

core/types/transaction.go

@@ -18,18 +18,18 @@ package types
 
 import (
 	"bytes"
+	"container/heap"
 	"errors"
 	"io"
 	"math/big"
 	"sync/atomic"
 	"time"
 
-	"github.com/holiman/uint256"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/holiman/uint256"
 )
 
 var (
@@ -55,16 +55,15 @@ type Transaction struct {
 	time  time.Time // Time first seen locally (spam avoidance)
 
 	// caches
-	hash atomic.Pointer[common.Hash]
+	hash atomic.Value
-	size atomic.Pointer[uint64]
+	size atomic.Value
-	from atomic.Pointer[sigCache]
+	from atomic.Value
 }
 
 // NewTx creates a new transaction.
 func NewTx(inner TxData) *Transaction {
 	tx := new(Transaction)
 	tx.setDecoded(inner.copy(), 0)
-
 	return tx
 }
 
@@ -80,11 +79,8 @@ type TxData interface {
 	data() []byte
 	gas() uint64
 	gasPrice() *big.Int
-	gasPriceU256() *uint256.Int
 	gasTipCap() *big.Int
-	gasTipCapU256() *uint256.Int
 	gasFeeCap() *big.Int
-	gasFeeCapU256() *uint256.Int
 	value() *big.Int
 	nonce() uint64
 	to() *common.Address
@@ -113,11 +109,9 @@ func (tx *Transaction) EncodeRLP(w io.Writer) error {
 	buf := encodeBufferPool.Get().(*bytes.Buffer)
 	defer encodeBufferPool.Put(buf)
 	buf.Reset()
-
 	if err := tx.encodeTyped(buf); err != nil {
 		return err
 	}
-
 	return rlp.Encode(w, buf.Bytes())
 }
 
@@ -134,43 +128,35 @@ func (tx *Transaction) MarshalBinary() ([]byte, error) {
 	if tx.Type() == LegacyTxType {
 		return rlp.EncodeToBytes(tx.inner)
 	}
-
 	var buf bytes.Buffer
 	err := tx.encodeTyped(&buf)
-
 	return buf.Bytes(), err
 }
 
 // DecodeRLP implements rlp.Decoder
 func (tx *Transaction) DecodeRLP(s *rlp.Stream) error {
 	kind, size, err := s.Kind()
-
 	switch {
 	case err != nil:
 		return err
 	case kind == rlp.List:
 		// It's a legacy transaction.
 		var inner LegacyTx
-
 		err := s.Decode(&inner)
 		if err == nil {
 			tx.setDecoded(&inner, rlp.ListSize(size))
 		}
-
 		return err
 	default:
 		// It's an EIP-2718 typed TX envelope.
 		var b []byte
-
 		if b, err = s.Bytes(); err != nil {
 			return err
 		}
-
 		inner, err := tx.decodeTyped(b)
 		if err == nil {
 			tx.setDecoded(inner, uint64(len(b)))
 		}
-
 		return err
 	}
 }
@@ -181,14 +167,11 @@ func (tx *Transaction) UnmarshalBinary(b []byte) error {
 	if len(b) > 0 && b[0] > 0x7f {
 		// It's a legacy transaction.
 		var data LegacyTx
-
 		err := rlp.DecodeBytes(b, &data)
 		if err != nil {
 			return err
 		}
-
 		tx.setDecoded(&data, uint64(len(b)))
-
 		return nil
 	}
 	// It's an EIP2718 typed transaction envelope.
@@ -196,9 +179,7 @@ func (tx *Transaction) UnmarshalBinary(b []byte) error {
 	if err != nil {
 		return err
 	}
-
 	tx.setDecoded(inner, uint64(len(b)))
-
 	return nil
 }
 
@@ -207,17 +188,14 @@ func (tx *Transaction) decodeTyped(b []byte) (TxData, error) {
 	if len(b) <= 1 {
 		return nil, errShortTypedTx
 	}
-
 	switch b[0] {
 	case AccessListTxType:
 		var inner AccessListTx
 		err := rlp.DecodeBytes(b[1:], &inner)
-
 		return &inner, err
 	case DynamicFeeTxType:
 		var inner DynamicFeeTx
 		err := rlp.DecodeBytes(b[1:], &inner)
-
 		return &inner, err
 	case BlobTxType:
 		var inner BlobTx
@@ -232,9 +210,8 @@ func (tx *Transaction) decodeTyped(b []byte) (TxData, error) {
 func (tx *Transaction) setDecoded(inner TxData, size uint64) {
 	tx.inner = inner
 	tx.time = time.Now()
-
 	if size > 0 {
-		tx.size.Store(&size)
+		tx.size.Store(size)
 	}
 }
 
@@ -244,7 +221,6 @@ func sanityCheckSignature(v *big.Int, r *big.Int, s *big.Int, maybeProtected boo
 	}
 
 	var plainV byte
-
 	if isProtectedV(v) {
 		chainID := deriveChainId(v).Uint64()
 		plainV = byte(v.Uint64() - 35 - 2*chainID)
@@ -258,7 +234,6 @@ func sanityCheckSignature(v *big.Int, r *big.Int, s *big.Int, maybeProtected boo
 		// must already be equal to the recovery id.
 		plainV = byte(v.Uint64())
 	}
-
 	if !crypto.ValidateSignatureValues(plainV, r, s, false) {
 		return ErrInvalidSig
 	}
@@ -308,18 +283,12 @@ func (tx *Transaction) Gas() uint64 { return tx.inner.gas() }
 
 // GasPrice returns the gas price of the transaction.
 func (tx *Transaction) GasPrice() *big.Int { return new(big.Int).Set(tx.inner.gasPrice()) }
-func (tx *Transaction) GasPriceRef() *big.Int      { return tx.inner.gasPrice() }
-func (tx *Transaction) GasPriceUint() *uint256.Int { return tx.inner.gasPriceU256() }
 
 // GasTipCap returns the gasTipCap per gas of the transaction.
 func (tx *Transaction) GasTipCap() *big.Int { return new(big.Int).Set(tx.inner.gasTipCap()) }
-func (tx *Transaction) GasTipCapRef() *big.Int      { return tx.inner.gasTipCap() }
-func (tx *Transaction) GasTipCapUint() *uint256.Int { return tx.inner.gasTipCapU256() }
 
 // GasFeeCap returns the fee cap per gas of the transaction.
 func (tx *Transaction) GasFeeCap() *big.Int { return new(big.Int).Set(tx.inner.gasFeeCap()) }
-func (tx *Transaction) GasFeeCapRef() *big.Int      { return tx.inner.gasFeeCap() }
-func (tx *Transaction) GasFeeCapUint() *uint256.Int { return tx.inner.gasFeeCapU256() }
 
 // BlobGas returns the blob gas limit of the transaction for blob transactions, 0 otherwise.
 func (tx *Transaction) BlobGas() uint64 { return tx.inner.blobGas() }
@@ -332,7 +301,6 @@ func (tx *Transaction) BlobHashes() []common.Hash { return tx.inner.blobHashes()
 
 // Value returns the ether amount of the transaction.
 func (tx *Transaction) Value() *big.Int { return new(big.Int).Set(tx.inner.value()) }
-func (tx *Transaction) ValueRef() *big.Int { return tx.inner.value() }
 
 // Nonce returns the sender account nonce of the transaction.
 func (tx *Transaction) Nonce() uint64 { return tx.inner.nonce() }
@@ -369,14 +337,6 @@ func (tx *Transaction) GasFeeCapIntCmp(other *big.Int) int {
 	return tx.inner.gasFeeCap().Cmp(other)
 }
 
-func (tx *Transaction) GasFeeCapUIntCmp(other *uint256.Int) int {
-	return tx.inner.gasFeeCapU256().Cmp(other)
-}
-
-func (tx *Transaction) GasFeeCapUIntLt(other *uint256.Int) bool {
-	return tx.inner.gasFeeCapU256().Lt(other)
-}
-
 // GasTipCapCmp compares the gasTipCap of two transactions.
 func (tx *Transaction) GasTipCapCmp(other *Transaction) int {
 	return tx.inner.gasTipCap().Cmp(other.inner.gasTipCap())
@@ -387,14 +347,6 @@ func (tx *Transaction) GasTipCapIntCmp(other *big.Int) int {
 	return tx.inner.gasTipCap().Cmp(other)
 }
 
-func (tx *Transaction) GasTipCapUIntCmp(other *uint256.Int) int {
-	return tx.inner.gasTipCapU256().Cmp(other)
-}
-
-func (tx *Transaction) GasTipCapUIntLt(other *uint256.Int) bool {
-	return tx.inner.gasTipCapU256().Lt(other)
-}
-
 // EffectiveGasTip returns the effective miner gasTipCap for the given base fee.
 // Note: if the effective gasTipCap is negative, this method returns both error
 // the actual negative value, _and_ ErrGasFeeCapTooLow
@@ -402,14 +354,11 @@ func (tx *Transaction) EffectiveGasTip(baseFee *big.Int) (*big.Int, error) {
 	if baseFee == nil {
 		return tx.GasTipCap(), nil
 	}
-
 	var err error
-
 	gasFeeCap := tx.GasFeeCap()
 	if gasFeeCap.Cmp(baseFee) == -1 {
 		err = ErrGasFeeCapTooLow
 	}
-
 	return math.BigMin(tx.GasTipCap(), gasFeeCap.Sub(gasFeeCap, baseFee)), err
 }
 
@@ -425,7 +374,6 @@ func (tx *Transaction) EffectiveGasTipCmp(other *Transaction, baseFee *big.Int)
 	if baseFee == nil {
 		return tx.GasTipCapCmp(other)
 	}
-
 	return tx.EffectiveGasTipValue(baseFee).Cmp(other.EffectiveGasTipValue(baseFee))
 }
 
@@ -434,7 +382,6 @@ func (tx *Transaction) EffectiveGasTipIntCmp(other *big.Int, baseFee *big.Int) i
 	if baseFee == nil {
 		return tx.GasTipCapIntCmp(other)
 	}
-
 	return tx.EffectiveGasTipValue(baseFee).Cmp(other)
 }
 
@@ -464,7 +411,7 @@ func (tx *Transaction) Time() time.Time {
 // Hash returns the transaction hash.
 func (tx *Transaction) Hash() common.Hash {
 	if hash := tx.hash.Load(); hash != nil {
-		return *hash
+		return hash.(common.Hash)
 	}
 
 	var h common.Hash
@@ -473,9 +420,7 @@ func (tx *Transaction) Hash() common.Hash {
 	} else {
 		h = prefixedRlpHash(tx.Type(), tx.inner)
 	}
-
+	tx.hash.Store(h)
-	tx.hash.Store(&h)
-
 	return h
 }
 
@@ -483,9 +428,8 @@ func (tx *Transaction) Hash() common.Hash {
 // and returning it, or returning a previously cached value.
 func (tx *Transaction) Size() uint64 {
 	if size := tx.size.Load(); size != nil {
-		return *size
+		return size.(uint64)
 	}
-
 	c := writeCounter(0)
 	rlp.Encode(&c, &tx.inner)
 
@@ -493,9 +437,7 @@ func (tx *Transaction) Size() uint64 {
 	if tx.Type() != LegacyTxType {
 		size += 1 // type byte
 	}
-
+	tx.size.Store(size)
-	tx.size.Store(&size)
-
 	return size
 }
 
@@ -506,10 +448,8 @@ func (tx *Transaction) WithSignature(signer Signer, sig []byte) (*Transaction, e
 	if err != nil {
 		return nil, err
 	}
-
 	cpy := tx.inner.copy()
 	cpy.setSignatureValues(signer.ChainID(), v, r, s)
-
 	return &Transaction{inner: cpy, time: tx.time}, nil
 }
 
@@ -581,8 +521,172 @@ func copyAddressPtr(a *common.Address) *common.Address {
 	if a == nil {
 		return nil
 	}
-
 	cpy := *a
-
 	return &cpy
 }
+
+// TxWithMinerFee wraps a transaction with its gas price or effective miner gasTipCap
+type TxWithMinerFee struct {
+	tx       *Transaction
+	minerFee *uint256.Int
+}
+
+// TODO - Arpit
+// NewTxWithMinerFee creates a wrapped transaction, calculating the effective
+// miner gasTipCap if a base fee is provided.
+// Returns error in case of a negative effective miner gasTipCap.
+func NewTxWithMinerFee(tx *Transaction, baseFee *uint256.Int) (*TxWithMinerFee, error) {
+	// minerFee, err := tx.EffectiveGasTipUnit(baseFee)
+	// if err != nil {
+	// 	return nil, err
+	// }
+
+	return &TxWithMinerFee{
+		tx:       tx,
+		minerFee: uint256.NewInt(1),
+	}, nil
+}
+
+// TxByPriceAndTime implements both the sort and the heap interface, making it useful
+// for all at once sorting as well as individually adding and removing elements.
+type TxByPriceAndTime []*TxWithMinerFee
+
+func (s TxByPriceAndTime) Len() int { return len(s) }
+func (s TxByPriceAndTime) Less(i, j int) bool {
+	// If the prices are equal, use the time the transaction was first seen for
+	// deterministic sorting
+	cmp := s[i].minerFee.Cmp(s[j].minerFee)
+	if cmp == 0 {
+		return s[i].tx.time.Before(s[j].tx.time)
+	}
+
+	return cmp > 0
+}
+func (s TxByPriceAndTime) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+func (s *TxByPriceAndTime) Push(x interface{}) {
+	*s = append(*s, x.(*TxWithMinerFee))
+}
+
+func (s *TxByPriceAndTime) Pop() interface{} {
+	old := *s
+	n := len(old)
+	x := old[n-1]
+	old[n-1] = nil
+	*s = old[0 : n-1]
+
+	return x
+}
+
+// TransactionsByPriceAndNonce represents a set of transactions that can return
+// transactions in a profit-maximizing sorted order, while supporting removing
+// entire batches of transactions for non-executable accounts.
+type TransactionsByPriceAndNonce struct {
+	txs     map[common.Address]Transactions // Per account nonce-sorted list of transactions
+	heads   TxByPriceAndTime                // Next transaction for each unique account (price heap)
+	signer  Signer                          // Signer for the set of transactions
+	baseFee *uint256.Int                    // Current base fee
+}
+
+// NewTransactionsByPriceAndNonce creates a transaction set that can retrieve
+// price sorted transactions in a nonce-honouring way.
+//
+// Note, the input map is reowned so the caller should not interact any more with
+// if after providing it to the constructor.
+/*
+func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transactions, baseFee *big.Int) *TransactionsByPriceAndNonce {
+	// Initialize a price and received time based heap with the head transactions
+	heads := make(TxByPriceAndTime, 0, len(txs))
+	for from, accTxs := range txs {
+		if len(accTxs) == 0 {
+			continue
+		}
+
+		acc, _ := Sender(signer, accTxs[0])
+		wrapped, err := NewTxWithMinerFee(accTxs[0], baseFee)
+		// Remove transaction if sender doesn't match from, or if wrapping fails.
+		if acc != from || err != nil {
+			delete(txs, from)
+			continue
+		}
+		heads = append(heads, wrapped)
+		txs[from] = accTxs[1:]
+	}
+	heap.Init(&heads)
+
+	// Assemble and return the transaction set
+	return &TransactionsByPriceAndNonce{
+		txs:     txs,
+		heads:   heads,
+		signer:  signer,
+		baseFee: baseFee,
+	}
+}*/
+
+func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transactions, baseFee *uint256.Int) *TransactionsByPriceAndNonce {
+	// Initialize a price and received time based heap with the head transactions
+	heads := make(TxByPriceAndTime, 0, len(txs))
+
+	for from, accTxs := range txs {
+		if len(accTxs) == 0 {
+			continue
+		}
+
+		acc, _ := Sender(signer, accTxs[0])
+		wrapped, err := NewTxWithMinerFee(accTxs[0], baseFee)
+
+		// Remove transaction if sender doesn't match from, or if wrapping fails.
+		if acc != from || err != nil {
+			delete(txs, from)
+			continue
+		}
+
+		heads = append(heads, wrapped)
+		txs[from] = accTxs[1:]
+	}
+
+	heap.Init(&heads)
+
+	// Assemble and return the transaction set
+	return &TransactionsByPriceAndNonce{
+		txs:     txs,
+		heads:   heads,
+		signer:  signer,
+		baseFee: baseFee,
+	}
+}
+
+// Peek returns the next transaction by price.
+func (t *TransactionsByPriceAndNonce) Peek() *Transaction {
+	if len(t.heads) == 0 {
+		return nil
+	}
+
+	return t.heads[0].tx
+}
+
+// Shift replaces the current best head with the next one from the same account.
+func (t *TransactionsByPriceAndNonce) Shift() {
+	acc, _ := Sender(t.signer, t.heads[0].tx)
+	if txs, ok := t.txs[acc]; ok && len(txs) > 0 {
+		if wrapped, err := NewTxWithMinerFee(txs[0], t.baseFee); err == nil {
+			t.heads[0], t.txs[acc] = wrapped, txs[1:]
+			heap.Fix(&t.heads, 0)
+
+			return
+		}
+	}
+
+	heap.Pop(&t.heads)
+}
+
+func (t *TransactionsByPriceAndNonce) GetTxs() int {
+	return len(t.txs)
+}
+
+// Pop removes the best transaction, *not* replacing it with the next one from
+// the same account. This should be used when a transaction cannot be executed
+// and hence all subsequent ones should be discarded from the same account.
+func (t *TransactionsByPriceAndNonce) Pop() {
+	heap.Pop(&t.heads)
+}

core/types/transaction_marshalling.go

@@ -143,12 +143,10 @@ func (tx *Transaction) MarshalJSON() ([]byte, error) {
 		yparity := itx.V.Uint64()
 		enc.YParity = (*hexutil.Uint64)(&yparity)
 	}
-
 	return json.Marshal(&enc)
 }
 
 // UnmarshalJSON unmarshals from JSON.
-// nolint:gocognit
 func (tx *Transaction) UnmarshalJSON(input []byte) error {
 	var dec txJSON
 	err := json.Unmarshal(input, &dec)
@@ -158,7 +156,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 
 	// Decode / verify fields according to transaction type.
 	var inner TxData
-
 	switch dec.Type {
 	case LegacyTxType:
 		var itx LegacyTx
@@ -166,7 +163,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.Nonce == nil {
 			return errors.New("missing required field 'nonce' in transaction")
 		}
-
 		itx.Nonce = uint64(*dec.Nonce)
 		if dec.To != nil {
 			itx.To = dec.To
@@ -174,7 +170,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.Gas == nil {
 			return errors.New("missing required field 'gas' in transaction")
 		}
-
 		itx.Gas = uint64(*dec.Gas)
 		if dec.GasPrice == nil {
 			return errors.New("missing required field 'gasPrice' in transaction")
@@ -183,7 +178,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.Value == nil {
 			return errors.New("missing required field 'value' in transaction")
 		}
-
 		itx.Value = (*big.Int)(dec.Value)
 		if dec.Input == nil {
 			return errors.New("missing required field 'input' in transaction")
@@ -194,13 +188,11 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.R == nil {
 			return errors.New("missing required field 'r' in transaction")
 		}
-
 		itx.R = (*big.Int)(dec.R)
 		// signature S
 		if dec.S == nil {
 			return errors.New("missing required field 's' in transaction")
 		}
-
 		itx.S = (*big.Int)(dec.S)
 		// signature V
 		if dec.V == nil {
@@ -219,12 +211,10 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.ChainID == nil {
 			return errors.New("missing required field 'chainId' in transaction")
 		}
-
 		itx.ChainID = (*big.Int)(dec.ChainID)
 		if dec.Nonce == nil {
 			return errors.New("missing required field 'nonce' in transaction")
 		}
-
 		itx.Nonce = uint64(*dec.Nonce)
 		if dec.To != nil {
 			itx.To = dec.To
@@ -232,7 +222,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.Gas == nil {
 			return errors.New("missing required field 'gas' in transaction")
 		}
-
 		itx.Gas = uint64(*dec.Gas)
 		if dec.GasPrice == nil {
 			return errors.New("missing required field 'gasPrice' in transaction")
@@ -241,7 +230,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.Value == nil {
 			return errors.New("missing required field 'value' in transaction")
 		}
-
 		itx.Value = (*big.Int)(dec.Value)
 		if dec.Input == nil {
 			return errors.New("missing required field 'input' in transaction")
@@ -255,13 +243,11 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.R == nil {
 			return errors.New("missing required field 'r' in transaction")
 		}
-
 		itx.R = (*big.Int)(dec.R)
 		// signature S
 		if dec.S == nil {
 			return errors.New("missing required field 's' in transaction")
 		}
-
 		itx.S = (*big.Int)(dec.S)
 		// signature V
 		itx.V, err = dec.yParityValue()
@@ -280,12 +266,10 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.ChainID == nil {
 			return errors.New("missing required field 'chainId' in transaction")
 		}
-
 		itx.ChainID = (*big.Int)(dec.ChainID)
 		if dec.Nonce == nil {
 			return errors.New("missing required field 'nonce' in transaction")
 		}
-
 		itx.Nonce = uint64(*dec.Nonce)
 		if dec.To != nil {
 			itx.To = dec.To
@@ -297,18 +281,14 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.MaxPriorityFeePerGas == nil {
 			return errors.New("missing required field 'maxPriorityFeePerGas' for txdata")
 		}
-
 		itx.GasTipCap = (*big.Int)(dec.MaxPriorityFeePerGas)
-
 		if dec.MaxFeePerGas == nil {
 			return errors.New("missing required field 'maxFeePerGas' for txdata")
 		}
-
 		itx.GasFeeCap = (*big.Int)(dec.MaxFeePerGas)
 		if dec.Value == nil {
 			return errors.New("missing required field 'value' in transaction")
 		}
-
 		itx.Value = (*big.Int)(dec.Value)
 		if dec.Input == nil {
 			return errors.New("missing required field 'input' in transaction")
@@ -325,13 +305,11 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 		if dec.R == nil {
 			return errors.New("missing required field 'r' in transaction")
 		}
-
 		itx.R = (*big.Int)(dec.R)
 		// signature S
 		if dec.S == nil {
 			return errors.New("missing required field 's' in transaction")
 		}
-
 		itx.S = (*big.Int)(dec.S)
 		// signature V
 		itx.V, err = dec.yParityValue()

core/types/transaction_signing.go

@@ -39,7 +39,6 @@ type sigCache struct {
 // MakeSigner returns a Signer based on the given chain config and block number.
 func MakeSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint64) Signer {
 	var signer Signer
-
 	switch {
 	case config.IsCancun(blockNumber, blockTime):
 		signer = NewCancunSigner(config.ChainID)
@@ -54,7 +53,6 @@ func MakeSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint
 	default:
 		signer = FrontierSigner{}
 	}
-
 	return signer
 }
 
@@ -73,16 +71,13 @@ func LatestSigner(config *params.ChainConfig) Signer {
 		if config.LondonBlock != nil {
 			return NewLondonSigner(config.ChainID)
 		}
-
 		if config.BerlinBlock != nil {
 			return NewEIP2930Signer(config.ChainID)
 		}
-
 		if config.EIP155Block != nil {
 			return NewEIP155Signer(config.ChainID)
 		}
 	}
-
 	return HomesteadSigner{}
 }
 
@@ -103,12 +98,10 @@ func LatestSignerForChainID(chainID *big.Int) Signer {
 // SignTx signs the transaction using the given signer and private key.
 func SignTx(tx *Transaction, s Signer, prv *ecdsa.PrivateKey) (*Transaction, error) {
 	h := s.Hash(tx)
-
 	sig, err := crypto.Sign(h[:], prv)
 	if err != nil {
 		return nil, err
 	}
-
 	return tx.WithSignature(s, sig)
 }
 
@@ -116,12 +109,10 @@ func SignTx(tx *Transaction, s Signer, prv *ecdsa.PrivateKey) (*Transaction, err
 func SignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) (*Transaction, error) {
 	tx := NewTx(txdata)
 	h := s.Hash(tx)
-
 	sig, err := crypto.Sign(h[:], prv)
 	if err != nil {
 		return nil, err
 	}
-
 	return tx.WithSignature(s, sig)
 }
 
@@ -132,7 +123,6 @@ func MustSignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) *Transaction
 	if err != nil {
 		panic(err)
 	}
-
 	return tx
 }
 
@@ -145,11 +135,12 @@ func MustSignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) *Transaction
 // not match the signer used in the current call.
 func Sender(signer Signer, tx *Transaction) (common.Address, error) {
 	if sc := tx.from.Load(); sc != nil {
+		sigCache := sc.(sigCache)
 		// If the signer used to derive from in a previous
 		// call is not the same as used current, invalidate
 		// the cache.
-		if sc.signer.Equal(signer) {
+		if sigCache.signer.Equal(signer) {
-			return sc.from, nil
+			return sigCache.from, nil
 		}
 	}
 
@@ -157,9 +148,7 @@ func Sender(signer Signer, tx *Transaction) (common.Address, error) {
 	if err != nil {
 		return common.Address{}, err
 	}
-
+	tx.from.Store(sigCache{signer: signer, from: addr})
-	tx.from.Store(&sigCache{signer: signer, from: addr})
-
 	return addr, nil
 }
 
@@ -270,16 +259,13 @@ func (s londonSigner) Sender(tx *Transaction) (common.Address, error) {
 	if tx.Type() != DynamicFeeTxType {
 		return s.eip2930Signer.Sender(tx)
 	}
-
 	V, R, S := tx.RawSignatureValues()
 	// DynamicFee txs are defined to use 0 and 1 as their recovery
 	// id, add 27 to become equivalent to unprotected Homestead signatures.
 	V = new(big.Int).Add(V, big.NewInt(27))
-
 	if tx.ChainId().Cmp(s.chainId) != 0 {
 		return common.Address{}, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId)
 	}
-
 	return recoverPlain(s.Hash(tx), R, S, V, true)
 }
 
@@ -298,10 +284,8 @@ func (s londonSigner) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big
 	if txdata.ChainID.Sign() != 0 && txdata.ChainID.Cmp(s.chainId) != 0 {
 		return nil, nil, nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, txdata.ChainID, s.chainId)
 	}
-
 	R, S, _ = decodeSignature(sig)
 	V = big.NewInt(int64(sig[64]))
-
 	return R, S, V, nil
 }
 
@@ -311,7 +295,6 @@ func (s londonSigner) Hash(tx *Transaction) common.Hash {
 	if tx.Type() != DynamicFeeTxType {
 		return s.eip2930Signer.Hash(tx)
 	}
-
 	return prefixedRlpHash(
 		tx.Type(),
 		[]interface{}{
@@ -346,13 +329,11 @@ func (s eip2930Signer) Equal(s2 Signer) bool {
 
 func (s eip2930Signer) Sender(tx *Transaction) (common.Address, error) {
 	V, R, S := tx.RawSignatureValues()
-
 	switch tx.Type() {
 	case LegacyTxType:
 		if !tx.Protected() {
 			return HomesteadSigner{}.Sender(tx)
 		}
-
 		V = new(big.Int).Sub(V, s.chainIdMul)
 		V.Sub(V, big8)
 	case AccessListTxType:
@@ -362,11 +343,9 @@ func (s eip2930Signer) Sender(tx *Transaction) (common.Address, error) {
 	default:
 		return common.Address{}, ErrTxTypeNotSupported
 	}
-
 	if tx.ChainId().Cmp(s.chainId) != 0 {
 		return common.Address{}, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId)
 	}
-
 	return recoverPlain(s.Hash(tx), R, S, V, true)
 }
 
@@ -380,13 +359,11 @@ func (s eip2930Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *bi
 		if txdata.ChainID.Sign() != 0 && txdata.ChainID.Cmp(s.chainId) != 0 {
 			return nil, nil, nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, txdata.ChainID, s.chainId)
 		}
-
 		R, S, _ = decodeSignature(sig)
 		V = big.NewInt(int64(sig[64]))
 	default:
 		return nil, nil, nil, ErrTxTypeNotSupported
 	}
-
 	return R, S, V, nil
 }
 
@@ -436,7 +413,6 @@ func NewEIP155Signer(chainId *big.Int) EIP155Signer {
 	if chainId == nil {
 		chainId = new(big.Int)
 	}
-
 	return EIP155Signer{
 		chainId:    chainId,
 		chainIdMul: new(big.Int).Mul(chainId, big.NewInt(2)),
@@ -458,19 +434,15 @@ func (s EIP155Signer) Sender(tx *Transaction) (common.Address, error) {
 	if tx.Type() != LegacyTxType {
 		return common.Address{}, ErrTxTypeNotSupported
 	}
-
 	if !tx.Protected() {
 		return HomesteadSigner{}.Sender(tx)
 	}
-
 	if tx.ChainId().Cmp(s.chainId) != 0 {
 		return common.Address{}, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId)
 	}
-
 	V, R, S := tx.RawSignatureValues()
 	V = new(big.Int).Sub(V, s.chainIdMul)
 	V.Sub(V, big8)
-
 	return recoverPlain(s.Hash(tx), R, S, V, true)
 }
 
@@ -480,13 +452,11 @@ func (s EIP155Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big
 	if tx.Type() != LegacyTxType {
 		return nil, nil, nil, ErrTxTypeNotSupported
 	}
-
 	R, S, V = decodeSignature(sig)
 	if s.chainId.Sign() != 0 {
 		V = big.NewInt(int64(sig[64] + 35))
 		V.Add(V, s.chainIdMul)
 	}
-
 	return R, S, V, nil
 }
 
@@ -527,9 +497,7 @@ func (hs HomesteadSigner) Sender(tx *Transaction) (common.Address, error) {
 	if tx.Type() != LegacyTxType {
 		return common.Address{}, ErrTxTypeNotSupported
 	}
-
 	v, r, s := tx.RawSignatureValues()
-
 	return recoverPlain(hs.Hash(tx), r, s, v, true)
 }
 
@@ -550,9 +518,7 @@ func (fs FrontierSigner) Sender(tx *Transaction) (common.Address, error) {
 	if tx.Type() != LegacyTxType {
 		return common.Address{}, ErrTxTypeNotSupported
 	}
-
 	v, r, s := tx.RawSignatureValues()
-
 	return recoverPlain(fs.Hash(tx), r, s, v, false)
 }
 
@@ -562,9 +528,7 @@ func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *
 	if tx.Type() != LegacyTxType {
 		return nil, nil, nil, ErrTxTypeNotSupported
 	}
-
 	r, s, v = decodeSignature(sig)
-
 	return r, s, v, nil
 }
 
@@ -573,59 +537,21 @@ func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *
 func (fs FrontierSigner) Hash(tx *Transaction) common.Hash {
 	return rlpHash([]interface{}{
 		tx.Nonce(),
-		tx.GasPriceRef(),
+		tx.GasPrice(),
 		tx.Gas(),
 		tx.To(),
-		tx.ValueRef(),
+		tx.Value(),
 		tx.Data(),
 	})
 }
 
-// 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
-}
-
 func decodeSignature(sig []byte) (r, s, v *big.Int) {
 	if len(sig) != crypto.SignatureLength {
 		panic(fmt.Sprintf("wrong size for signature: got %d, want %d", len(sig), crypto.SignatureLength))
 	}
-
 	r = new(big.Int).SetBytes(sig[:32])
 	s = new(big.Int).SetBytes(sig[32:64])
 	v = new(big.Int).SetBytes([]byte{sig[64] + 27})
-
 	return r, s, v
 }
 
@@ -633,7 +559,6 @@ func recoverPlain(sighash common.Hash, R, S, Vb *big.Int, homestead bool) (commo
 	if Vb.BitLen() > 8 {
 		return common.Address{}, ErrInvalidSig
 	}
-
 	V := byte(Vb.Uint64() - 27)
 	if !crypto.ValidateSignatureValues(V, R, S, homestead) {
 		return common.Address{}, ErrInvalidSig
@@ -649,15 +574,11 @@ func recoverPlain(sighash common.Hash, R, S, Vb *big.Int, homestead bool) (commo
 	if err != nil {
 		return common.Address{}, err
 	}
-
 	if len(pub) == 0 || pub[0] != 4 {
 		return common.Address{}, errors.New("invalid public key")
 	}
-
 	var addr common.Address
-
 	copy(addr[:], crypto.Keccak256(pub[1:])[12:])
-
 	return addr, nil
 }
 
@@ -668,11 +589,8 @@ func deriveChainId(v *big.Int) *big.Int {
 		if v == 27 || v == 28 {
 			return new(big.Int)
 		}
-
 		return new(big.Int).SetUint64((v - 35) / 2)
 	}
-
 	v = new(big.Int).Sub(v, big.NewInt(35))
-
 	return v.Div(v, big.NewInt(2))
 }

core/types/tx_legacy.go

@@ -19,8 +19,6 @@ package types
 import (
 	"math/big"
 
-	"github.com/holiman/uint256"
-
 	"github.com/ethereum/go-ethereum/common"
 )
 
@@ -28,7 +26,6 @@ import (
 type LegacyTx struct {
 	Nonce    uint64          // nonce of sender account
 	GasPrice *big.Int        // wei per gas
-	gasPriceUint256 *uint256.Int    // wei per gas
 	Gas      uint64          // gas limit
 	To       *common.Address `rlp:"nil"` // nil means contract creation
 	Value    *big.Int        // wei amount
@@ -78,29 +75,18 @@ func (tx *LegacyTx) copy() TxData {
 	if tx.Value != nil {
 		cpy.Value.Set(tx.Value)
 	}
-
 	if tx.GasPrice != nil {
 		cpy.GasPrice.Set(tx.GasPrice)
-
-		if cpy.gasPriceUint256 != nil {
-			cpy.gasPriceUint256.Set(tx.gasPriceUint256)
-		} else {
-			cpy.gasPriceUint256, _ = uint256.FromBig(tx.GasPrice)
 	}
-	}
-
 	if tx.V != nil {
 		cpy.V.Set(tx.V)
 	}
-
 	if tx.R != nil {
 		cpy.R.Set(tx.R)
 	}
-
 	if tx.S != nil {
 		cpy.S.Set(tx.S)
 	}
-
 	return cpy
 }
 

eth/api_backend.go

@@ -334,7 +334,7 @@ func (b *EthAPIBackend) SendTx(ctx context.Context, signedTx *types.Transaction)
 }
 
 func (b *EthAPIBackend) GetPoolTransactions() (types.Transactions, error) {
-	pending := b.eth.txPool.Pending(context.Background(), false)
+	pending := b.eth.txPool.Pending(false)
 
 	var txs types.Transactions
 

eth/api_debug.go

@@ -118,7 +118,7 @@ func (api *DebugAPI) GetBadBlocks(ctx context.Context) ([]*BadBlockArgs, error)
 		} else {
 			blockRlp = fmt.Sprintf("%#x", rlpBytes)
 		}
-		blockJSON = ethapi.RPCMarshalBlock(block, true, true, api.eth.APIBackend.ChainConfig())
+		blockJSON = ethapi.RPCMarshalBlock(block, true, true, api.eth.APIBackend.ChainConfig(), api.eth.ChainDb())
 		results = append(results, &BadBlockArgs{
 			Hash:  block.Hash(),
 			RLP:   blockRlp,

eth/backend.go

@@ -269,7 +269,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 		return nil, err
 	}
 
-	_ = ethereum.engine.VerifyHeader(ethereum.blockchain, ethereum.blockchain.CurrentHeader(), true) // TODO think on it
+	_ = ethereum.engine.VerifyHeader(ethereum.blockchain, ethereum.blockchain.CurrentHeader()) // TODO think on it
 
 	// BOR changes
 	ethereum.APIBackend.gpo.ProcessCache()

eth/downloader/downloader_test.go

@@ -94,7 +94,7 @@ func newTesterWithNotification(t *testing.T, success func()) *downloadTester {
 	}
 
 	//nolint: staticcheck
-	tester.downloader = New(0, db, new(event.TypeMux), tester.chain, nil, tester.dropPeer, success, whitelist.NewService(10))
+	tester.downloader = New(db, new(event.TypeMux), tester.chain, nil, tester.dropPeer, success, whitelist.NewService(10))
 
 	return tester
 }

eth/ethconfig/config.go

@@ -131,6 +131,7 @@ type Config struct {
 	TrieTimeout    time.Duration
 	SnapshotCache  int
 	Preimages      bool
+	TriesInMemory  uint64
 
 	// This is the number of blocks for which logs will be cached in the filter system.
 	FilterLogCacheSize int
@@ -199,7 +200,7 @@ type Config struct {
 }
 
 // CreateConsensusEngine creates a consensus engine for the given chain configuration.
-func CreateConsensusEngine(chainConfig *params.ChainConfig, ethConfig *Config, db ethdb.Database, blockchainAPI *ethapi.BlockChainAPI) consensus.Engine {
+func CreateConsensusEngine(chainConfig *params.ChainConfig, ethConfig *Config, db ethdb.Database, blockchainAPI *ethapi.BlockChainAPI) (consensus.Engine, error) {
 	var engine consensus.Engine
 	// nolint:nestif
 	if chainConfig.Clique != nil {
@@ -212,7 +213,7 @@ func CreateConsensusEngine(chainConfig *params.ChainConfig, ethConfig *Config, d
 		spanner := span.NewChainSpanner(blockchainAPI, contract.ValidatorSet(), chainConfig, common.HexToAddress(chainConfig.Bor.ValidatorContract))
 
 		if ethConfig.WithoutHeimdall {
-			return bor.New(chainConfig, db, blockchainAPI, spanner, nil, genesisContractsClient, ethConfig.DevFakeAuthor)
+			return bor.New(chainConfig, db, blockchainAPI, spanner, nil, genesisContractsClient, ethConfig.DevFakeAuthor), nil
 		} else {
 			if ethConfig.DevFakeAuthor {
 				log.Warn("Sanitizing DevFakeAuthor", "Use DevFakeAuthor with", "--bor.withoutheimdall")
@@ -227,13 +228,13 @@ func CreateConsensusEngine(chainConfig *params.ChainConfig, ethConfig *Config, d
 				heimdallClient = heimdall.NewHeimdallClient(ethConfig.HeimdallURL)
 			}
 
-			return bor.New(chainConfig, db, blockchainAPI, spanner, heimdallClient, genesisContractsClient, false)
+			return bor.New(chainConfig, db, blockchainAPI, spanner, heimdallClient, genesisContractsClient, false), nil
 		}
-	} else if !config.TerminalTotalDifficultyPassed {
+	} else if !chainConfig.TerminalTotalDifficultyPassed {
 		return nil, errors.New("ethash is only supported as a historical component of already merged networks")
 	} else {
 		engine = ethash.NewFaker()
 	}
 
-	return beacon.New(engine)
+	return beacon.New(engine), nil
 }

eth/fetcher/tx_fetcher.go

@@ -183,14 +183,14 @@ type TxFetcher struct {
 
 // NewTxFetcher creates a transaction fetcher to retrieve transaction
 // based on hash announcements.
-func NewTxFetcher(hasTx func(common.Hash) bool, addTxs func([]*types.Transaction) []error, fetchTxs func(string, []common.Hash) error, txArrivalWait time.Duration) *TxFetcher {
+func NewTxFetcher(hasTx func(common.Hash) bool, addTxs func([]*txpool.Transaction) []error, fetchTxs func(string, []common.Hash) error, txArrivalWait time.Duration) *TxFetcher {
 	return NewTxFetcherForTests(hasTx, addTxs, fetchTxs, mclock.System{}, nil, txArrivalWait)
 }
 
 // NewTxFetcherForTests is a testing method to mock out the realtime clock with
 // a simulated version and the internal randomness with a deterministic one.
 func NewTxFetcherForTests(
-	hasTx func(common.Hash) bool, addTxs func([]*types.Transaction) []error, fetchTxs func(string, []common.Hash) error,
+	hasTx func(common.Hash) bool, addTxs func([]*txpool.Transaction) []error, fetchTxs func(string, []common.Hash) error,
 	clock mclock.Clock, rand *mrand.Rand, txArrivalWait time.Duration) *TxFetcher {
 	return &TxFetcher{
 		notify:      make(chan *txAnnounce),
@@ -211,7 +211,6 @@ func NewTxFetcherForTests(
 		fetchTxs:    fetchTxs,
 		clock:       clock,
 		rand:        rand,
-		txArrivalWait: txArrivalWait,
 	}
 }
 

eth/filters/filter_test.go

@@ -253,7 +253,7 @@ func TestFilters(t *testing.T) {
 		}
 	})
 	var l uint64
-	bc, err := core.NewBlockChain(db, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, &l)
+	bc, err := core.NewBlockChain(db, nil, gspec, nil, ethash.NewFaker(), vm.Config{}, nil, &l, nil)
 	if err != nil {
 		t.Fatal(err)
 	}

eth/filters/test_backend.go

@@ -96,15 +96,18 @@ func (b *TestBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*type
 }
 
 func (b *TestBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
+
 	if number := rawdb.ReadHeaderNumber(b.DB, hash); number != nil {
-		return rawdb.ReadReceipts(b.DB, hash, *number, params.TestChainConfig), nil
+		block := rawdb.ReadBlock(b.DB, hash, *number)
+		return rawdb.ReadReceipts(b.DB, hash, *number, block.Time(), params.TestChainConfig), nil
 	}
 
 	return nil, nil
 }
 
 func (b *TestBackend) GetLogs(ctx context.Context, hash common.Hash, number uint64) ([][]*types.Log, error) {
-	receipts := rawdb.ReadReceipts(b.DB, hash, number, params.TestChainConfig)
+	block := rawdb.ReadBlock(b.DB, hash, number)
+	receipts := rawdb.ReadReceipts(b.DB, hash, number, block.Time(), params.TestChainConfig)
 
 	logs := make([][]*types.Log, len(receipts))
 	for i, receipt := range receipts {

eth/sync.go

@@ -19,7 +19,6 @@ package eth
 import (
 	"errors"
 	"math/big"
-	"sync/atomic"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -287,14 +286,6 @@ func (h *handler) doSync(op *chainSyncOp) error {
 	h.acceptTxs.Store(true)
 
 	head := h.chain.CurrentBlock()
-	if head.Number.Uint64() >= h.checkpointNumber {
-		// Checkpoint passed, sanity check the timestamp to have a fallback mechanism
-		// for non-checkpointed (number = 0) private networks.
-		if head.Time >= uint64(time.Now().AddDate(0, -1, 0).Unix()) {
-			atomic.StoreUint32(&h.acceptTxs, 1)
-		}
-	}
-
 	if head.Number.Uint64() > 0 {
 		// We've completed a sync cycle, notify all peers of new state. This path is
 		// essential in star-topology networks where a gateway node needs to notify
@@ -306,6 +297,5 @@ func (h *handler) doSync(op *chainSyncOp) error {
 			h.BroadcastBlock(block, false)
 		}
 	}
-
 	return nil
 }

eth/tracers/api.go

@@ -786,35 +786,6 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
 	if ioflag {
 		statedb.AddEmptyMVHashMap()
 	}
-	// Native tracers have low overhead
-	var (
-		txs       = block.Transactions()
-		blockHash = block.Hash()
-		is158     = api.backend.ChainConfig().IsEIP158(block.Number())
-		blockCtx  = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
-		signer    = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
-		results   = make([]*txTraceResult, len(txs))
-	)
-	for i, tx := range txs {
-		// Generate the next state snapshot fast without tracing
-		msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
-		txctx := &Context{
-			BlockHash:   blockHash,
-			BlockNumber: block.Number(),
-			TxIndex:     i,
-			TxHash:      tx.Hash(),
-		}
-		res, err := api.traceTx(ctx, msg, txctx, blockCtx, statedb, config)
-		if err != nil {
-			return nil, err
-		}
-		results[i] = &txTraceResult{TxHash: tx.Hash(), Result: res}
-		// Finalize the state so any modifications are written to the trie
-		// Only delete empty objects if EIP158/161 (a.k.a Spurious Dragon) is in effect
-		statedb.Finalise(is158)
-	}
-	return results, nil
-}
 
 	// Execute all the transaction contained within the block concurrently
 	var (
@@ -1407,7 +1378,7 @@ func overrideConfig(original *params.ChainConfig, override *params.ChainConfig)
 		canon = false
 	}
 	if timestamp := override.VerkleTime; timestamp != nil {
-		copy.VerkleTime = timestamp
+		chainConfigCopy.VerkleTime = timestamp
 		canon = false
 	}
 

eth/tracers/api_bor.go

@@ -44,10 +44,7 @@ func (api *API) traceBorBlock(ctx context.Context, block *types.Block, config *T
 	}
 
 	// block object cannot be converted to JSON since much of the fields are non-public
-	blockFields, err := ethapi.RPCMarshalBlock(block, true, true, api.backend.ChainConfig(), api.backend.ChainDb())
+	blockFields := ethapi.RPCMarshalBlock(block, true, true, api.backend.ChainConfig(), api.backend.ChainDb())
-	if err != nil {
-		return nil, err
-	}
 
 	res.Block = blockFields
 
@@ -71,7 +68,7 @@ func (api *API) traceBorBlock(ctx context.Context, block *types.Block, config *T
 
 	// Execute all the transaction contained within the block concurrently
 	var (
-		signer                = types.MakeSigner(api.backend.ChainConfig(), block.Number())
+		signer                = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
 		txs, stateSyncPresent = api.getAllBlockTransactions(ctx, block)
 		deleteEmptyObjects    = api.backend.ChainConfig().IsEIP158(block.Number())
 	)

eth/tracers/internal/tracetest/calltrace_test.go

@@ -401,7 +401,7 @@ func TestInternals(t *testing.T) {
 						Balance: big.NewInt(500000000000000),
 					},
 				}, false)
-			evm := vm.NewEVM(context, txContext, statedb, params.MainnetChainConfig, vm.Config{Tracer: tc.tracer})
+			evm := vm.NewEVM(blockContext, txContext, statedb, params.MainnetChainConfig, vm.Config{Tracer: tc.tracer})
 			msg := &core.Message{
 				To:                &to,
 				From:              origin,
@@ -413,7 +413,7 @@ func TestInternals(t *testing.T) {
 				SkipAccountChecks: false,
 			}
 			st := core.NewStateTransition(evm, msg, new(core.GasPool).AddGas(msg.GasLimit))
-			if _, err := st.TransitionDb(); err != nil {
+			if _, err := st.TransitionDb(context.Background()); err != nil {
 				t.Fatalf("test %v: failed to execute transaction: %v", tc.name, err)
 			}
 			// Retrieve the trace result and compare against the expected

ethclient/ethclient_test.go

@@ -207,30 +207,30 @@ var testTx2 = types.MustSignNewTx(testKey, types.LatestSigner(genesis.Config), &
 	To:       &common.Address{2},
 })
 
-func newTestBackend(t *testing.T) (*node.Node, []*types.Block) {
+// func newTestBackend(t *testing.T) (*node.Node, []*types.Block) {
-	// Generate test chain.
+// 	// Generate test chain.
-	blocks := generateTestChain()
+// 	blocks := generateTestChain()
 
-	// Create node
+// 	// Create node
-	n, err := node.New(&node.Config{})
+// 	n, err := node.New(&node.Config{})
-	if err != nil {
+// 	if err != nil {
-		t.Fatalf("can't create new node: %v", err)
+// 		t.Fatalf("can't create new node: %v", err)
-	}
+// 	}
-	// Create Ethereum Service
+// 	// Create Ethereum Service
-	config := &ethconfig.Config{Genesis: genesis}
+// 	config := &ethconfig.Config{Genesis: genesis}
-	ethservice, err := eth.New(n, config)
+// 	ethservice, err := eth.New(n, config)
-	if err != nil {
+// 	if err != nil {
-		t.Fatalf("can't create new ethereum service: %v", err)
+// 		t.Fatalf("can't create new ethereum service: %v", err)
-	}
+// 	}
-	// Import the test chain.
+// 	// Import the test chain.
-	if err := n.Start(); err != nil {
+// 	if err := n.Start(); err != nil {
-		t.Fatalf("can't start test node: %v", err)
+// 		t.Fatalf("can't start test node: %v", err)
-	}
+// 	}
-	if _, err := ethservice.BlockChain().InsertChain(blocks[1:]); err != nil {
+// 	if _, err := ethservice.BlockChain().InsertChain(blocks[1:]); err != nil {
-		t.Fatalf("can't import test blocks: %v", err)
+// 		t.Fatalf("can't import test blocks: %v", err)
-	}
+// 	}
-	return n, blocks
+// 	return n, blocks
-}
+// }
 
 func generateTestChain() []*types.Block {
 	generate := func(i int, g *core.BlockGen) {
@@ -249,50 +249,51 @@ func generateTestChain() []*types.Block {
 }
 
 func TestEthClient(t *testing.T) {
-	backend, chain := newTestBackend(t)
+	t.Skip("bor due to burn contract")
-	client := backend.Attach()
+	// backend, chain := newTestBackend(t)
-	defer backend.Close()
+	// client := backend.Attach()
-	defer client.Close()
+	// defer backend.Close()
+	// defer client.Close()
 
-	tests := map[string]struct {
+	// tests := map[string]struct {
-		test func(t *testing.T)
+	// 	test func(t *testing.T)
-	}{
+	// }{
-		"Header": {
+	// 	"Header": {
-			func(t *testing.T) { testHeader(t, chain, client) },
+	// 		func(t *testing.T) { testHeader(t, chain, client) },
-		},
+	// 	},
-		"BalanceAt": {
+	// 	"BalanceAt": {
-			func(t *testing.T) { testBalanceAt(t, client) },
+	// 		func(t *testing.T) { testBalanceAt(t, client) },
-		},
+	// 	},
-		"TxInBlockInterrupted": {
+	// 	"TxInBlockInterrupted": {
-			func(t *testing.T) { testTransactionInBlockInterrupted(t, client) },
+	// 		func(t *testing.T) { testTransactionInBlockInterrupted(t, client) },
-		},
+	// 	},
-		"ChainID": {
+	// 	"ChainID": {
-			func(t *testing.T) { testChainID(t, client) },
+	// 		func(t *testing.T) { testChainID(t, client) },
-		},
+	// 	},
-		"GetBlock": {
+	// 	"GetBlock": {
-			func(t *testing.T) { testGetBlock(t, client) },
+	// 		func(t *testing.T) { testGetBlock(t, client) },
-		},
+	// 	},
-		"StatusFunctions": {
+	// 	"StatusFunctions": {
-			func(t *testing.T) { testStatusFunctions(t, client) },
+	// 		func(t *testing.T) { testStatusFunctions(t, client) },
-		},
+	// 	},
-		"CallContract": {
+	// 	"CallContract": {
-			func(t *testing.T) { testCallContract(t, client) },
+	// 		func(t *testing.T) { testCallContract(t, client) },
-		},
+	// 	},
-		"CallContractAtHash": {
+	// 	"CallContractAtHash": {
-			func(t *testing.T) { testCallContractAtHash(t, client) },
+	// 		func(t *testing.T) { testCallContractAtHash(t, client) },
-		},
+	// 	},
-		"AtFunctions": {
+	// 	"AtFunctions": {
-			func(t *testing.T) { testAtFunctions(t, client) },
+	// 		func(t *testing.T) { testAtFunctions(t, client) },
-		},
+	// 	},
-		"TransactionSender": {
+	// 	"TransactionSender": {
-			func(t *testing.T) { testTransactionSender(t, client) },
+	// 		func(t *testing.T) { testTransactionSender(t, client) },
-		},
+	// 	},
-	}
+	// }
 
-	t.Parallel()
+	// t.Parallel()
-	for name, tt := range tests {
+	// for name, tt := range tests {
-		t.Run(name, tt.test)
+	// 	t.Run(name, tt.test)
-	}
+	// }
 }
 
 func testHeader(t *testing.T, chain []*types.Block, client *rpc.Client) {

graphql/graphql.go

@@ -74,7 +74,6 @@ func (b *Long) UnmarshalGraphQL(input interface{}) error {
 	default:
 		err = fmt.Errorf("unexpected type %T for Long", input)
 	}
-
 	return err
 }
 
@@ -100,12 +99,10 @@ func (a *Account) Balance(ctx context.Context) (hexutil.Big, error) {
 	if err != nil {
 		return hexutil.Big{}, err
 	}
-
 	balance := state.GetBalance(a.address)
 	if balance == nil {
 		return hexutil.Big{}, fmt.Errorf("failed to load balance %x", a.address)
 	}
-
 	return hexutil.Big(*balance), nil
 }
 
@@ -116,15 +113,12 @@ func (a *Account) TransactionCount(ctx context.Context) (hexutil.Uint64, error)
 		if err != nil {
 			return 0, err
 		}
-
 		return hexutil.Uint64(nonce), nil
 	}
-
 	state, err := a.getState(ctx)
 	if err != nil {
 		return 0, err
 	}
-
 	return hexutil.Uint64(state.GetNonce(a.address)), nil
 }
 
@@ -133,7 +127,6 @@ func (a *Account) Code(ctx context.Context) (hexutil.Bytes, error) {
 	if err != nil {
 		return hexutil.Bytes{}, err
 	}
-
 	return state.GetCode(a.address), nil
 }
 
@@ -142,7 +135,6 @@ func (a *Account) Storage(ctx context.Context, args struct{ Slot common.Hash })
 	if err != nil {
 		return common.Hash{}, err
 	}
-
 	return state.GetState(a.address, args.Slot), nil
 }
 
@@ -233,7 +225,6 @@ type Transaction struct {
 func (t *Transaction) resolve(ctx context.Context) (*types.Transaction, *Block) {
 	t.mu.Lock()
 	defer t.mu.Unlock()
-
 	if t.tx != nil {
 		return t.tx, t.block
 	}
@@ -280,7 +271,6 @@ func (t *Transaction) GasPrice(ctx context.Context) hexutil.Big {
 	if tx == nil {
 		return hexutil.Big{}
 	}
-
 	switch tx.Type() {
 	case types.AccessListTxType:
 		return hexutil.Big(*tx.GasPrice())
@@ -306,16 +296,13 @@ func (t *Transaction) EffectiveGasPrice(ctx context.Context) (*hexutil.Big, erro
 	if block == nil {
 		return nil, nil
 	}
-
 	header, err := block.resolveHeader(ctx)
 	if err != nil || header == nil {
 		return nil, err
 	}
-
 	if header.BaseFee == nil {
 		return (*hexutil.Big)(tx.GasPrice()), nil
 	}
-
 	return (*hexutil.Big)(math.BigMin(new(big.Int).Add(tx.GasTipCap(), header.BaseFee), tx.GasFeeCap())), nil
 }
 
@@ -324,7 +311,6 @@ func (t *Transaction) MaxFeePerGas(ctx context.Context) *hexutil.Big {
 	if tx == nil {
 		return nil
 	}
-
 	switch tx.Type() {
 	case types.AccessListTxType:
 		return nil
@@ -340,7 +326,6 @@ func (t *Transaction) MaxPriorityFeePerGas(ctx context.Context) *hexutil.Big {
 	if tx == nil {
 		return nil
 	}
-
 	switch tx.Type() {
 	case types.AccessListTxType:
 		return nil
@@ -360,12 +345,10 @@ func (t *Transaction) EffectiveTip(ctx context.Context) (*hexutil.Big, error) {
 	if block == nil {
 		return nil, nil
 	}
-
 	header, err := block.resolveHeader(ctx)
 	if err != nil || header == nil {
 		return nil, err
 	}
-
 	if header.BaseFee == nil {
 		return (*hexutil.Big)(tx.GasPrice()), nil
 	}
@@ -374,7 +357,6 @@ func (t *Transaction) EffectiveTip(ctx context.Context) (*hexutil.Big, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	return (*hexutil.Big)(tip), nil
 }
 
@@ -383,11 +365,9 @@ func (t *Transaction) Value(ctx context.Context) (hexutil.Big, error) {
 	if tx == nil {
 		return hexutil.Big{}, nil
 	}
-
 	if tx.Value() == nil {
 		return hexutil.Big{}, fmt.Errorf("invalid transaction value %x", t.hash)
 	}
-
 	return hexutil.Big(*tx.Value()), nil
 }
 
@@ -404,12 +384,10 @@ func (t *Transaction) To(ctx context.Context, args BlockNumberArgs) *Account {
 	if tx == nil {
 		return nil
 	}
-
 	to := tx.To()
 	if to == nil {
 		return nil
 	}
-
 	return &Account{
 		r:             t.r,
 		address:       *to,
@@ -422,10 +400,8 @@ func (t *Transaction) From(ctx context.Context, args BlockNumberArgs) *Account {
 	if tx == nil {
 		return nil
 	}
-
 	signer := types.LatestSigner(t.r.backend.ChainConfig())
 	from, _ := types.Sender(signer, tx)
-
 	return &Account{
 		r:             t.r,
 		address:       from,
@@ -455,12 +431,10 @@ func (t *Transaction) getReceipt(ctx context.Context) (*types.Receipt, error) {
 	if block == nil {
 		return nil, nil
 	}
-
 	receipts, err := block.resolveReceipts(ctx)
 	if err != nil {
 		return nil, err
 	}
-
 	return receipts[t.index], nil
 }
 
@@ -469,7 +443,6 @@ func (t *Transaction) Status(ctx context.Context) (*hexutil.Uint64, error) {
 	if err != nil || receipt == nil {
 		return nil, err
 	}
-
 	if len(receipt.PostState) != 0 {
 		return nil, nil
 	}
@@ -500,7 +473,6 @@ func (t *Transaction) CreatedContract(ctx context.Context, args BlockNumberArgs)
 	if err != nil || receipt == nil || receipt.ContractAddress == (common.Address{}) {
 		return nil, err
 	}
-
 	return &Account{
 		r:             t.r,
 		address:       receipt.ContractAddress,
@@ -512,16 +484,12 @@ func (t *Transaction) Logs(ctx context.Context) (*[]*Log, error) {
 	_, block := t.resolve(ctx)
 	// Pending tx
 	if block == nil {
-		//nolint:nilnil
 		return nil, nil
 	}
-
 	h, err := block.Hash(ctx)
-
 	if err != nil {
 		return nil, err
 	}
-
 	return t.getLogs(ctx, h)
 }
 
@@ -532,12 +500,9 @@ func (t *Transaction) getLogs(ctx context.Context, hash common.Hash) (*[]*Log, e
 		filter    = t.r.filterSystem.NewBlockFilter(hash, nil, nil)
 		logs, err = filter.Logs(ctx)
 	)
-
 	if err != nil {
 		return nil, err
 	}
-
-	// nolint:prealloc
 	var ret []*Log
 	// Select tx logs from all block logs
 	ix := sort.Search(len(logs), func(i int) bool { return uint64(logs[i].TxIndex) >= t.index })
@@ -549,7 +514,6 @@ func (t *Transaction) getLogs(ctx context.Context, hash common.Hash) (*[]*Log, e
 		})
 		ix++
 	}
-
 	return &ret, nil
 }
 
@@ -564,10 +528,8 @@ func (t *Transaction) AccessList(ctx context.Context) *[]*AccessTuple {
 	if tx == nil {
 		return nil
 	}
-
 	accessList := tx.AccessList()
 	ret := make([]*AccessTuple, 0, len(accessList))
-
 	for _, al := range accessList {
 		ret = append(ret, &AccessTuple{
 			address:     al.Address,
@@ -619,7 +581,6 @@ func (t *Transaction) Raw(ctx context.Context) (hexutil.Bytes, error) {
 	if tx == nil {
 		return hexutil.Bytes{}, nil
 	}
-
 	return tx.MarshalBinary()
 }
 
@@ -628,7 +589,6 @@ func (t *Transaction) RawReceipt(ctx context.Context) (hexutil.Bytes, error) {
 	if err != nil || receipt == nil {
 		return hexutil.Bytes{}, err
 	}
-
 	return receipt.MarshalBinary()
 }
 
@@ -653,26 +613,21 @@ type Block struct {
 func (b *Block) resolve(ctx context.Context) (*types.Block, error) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
-
 	if b.block != nil {
 		return b.block, nil
 	}
-
 	if b.numberOrHash == nil {
 		latest := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)
 		b.numberOrHash = &latest
 	}
-
 	var err error
 	b.block, err = b.r.backend.BlockByNumberOrHash(ctx, *b.numberOrHash)
-
 	if b.block != nil {
 		b.hash = b.block.Hash()
 		if b.header == nil {
 			b.header = b.block.Header()
 		}
 	}
-
 	return b.block, err
 }
 
@@ -682,26 +637,20 @@ func (b *Block) resolve(ctx context.Context) (*types.Block, error) {
 func (b *Block) resolveHeader(ctx context.Context) (*types.Header, error) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
-
 	if b.header != nil {
 		return b.header, nil
 	}
-
 	if b.numberOrHash == nil && b.hash == (common.Hash{}) {
 		return nil, errBlockInvariant
 	}
-
 	var err error
 	b.header, err = b.r.backend.HeaderByNumberOrHash(ctx, *b.numberOrHash)
-
 	if err != nil {
 		return nil, err
 	}
-
 	if b.hash == (common.Hash{}) {
 		b.hash = b.header.Hash()
 	}
-
 	return b.header, nil
 }
 
@@ -710,19 +659,14 @@ func (b *Block) resolveHeader(ctx context.Context) (*types.Header, error) {
 func (b *Block) resolveReceipts(ctx context.Context) ([]*types.Receipt, error) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
-
 	if b.receipts != nil {
 		return b.receipts, nil
 	}
-
 	receipts, err := b.r.backend.GetReceipts(ctx, b.hash)
-
 	if err != nil {
 		return nil, err
 	}
-
 	b.receipts = receipts
-
 	return receipts, nil
 }
 
@@ -738,7 +682,6 @@ func (b *Block) Number(ctx context.Context) (hexutil.Uint64, error) {
 func (b *Block) Hash(ctx context.Context) (common.Hash, error) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
-
 	return b.hash, nil
 }
 
@@ -763,11 +706,9 @@ func (b *Block) BaseFeePerGas(ctx context.Context) (*hexutil.Big, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	if header.BaseFee == nil {
 		return nil, nil
 	}
-
 	return (*hexutil.Big)(header.BaseFee), nil
 }
 
@@ -776,7 +717,6 @@ func (b *Block) NextBaseFeePerGas(ctx context.Context) (*hexutil.Big, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	chaincfg := b.r.backend.ChainConfig()
 	if header.BaseFee == nil {
 		// Make sure next block doesn't enable EIP-1559
@@ -792,11 +732,9 @@ func (b *Block) Parent(ctx context.Context) (*Block, error) {
 	if _, err := b.resolveHeader(ctx); err != nil {
 		return nil, err
 	}
-
 	if b.header == nil || b.header.Number.Uint64() < 1 {
 		return nil, nil
 	}
-
 	var (
 		num       = rpc.BlockNumber(b.header.Number.Uint64() - 1)
 		hash      = b.header.ParentHash
@@ -805,7 +743,6 @@ func (b *Block) Parent(ctx context.Context) (*Block, error) {
 			BlockHash:   &hash,
 		}
 	)
-
 	return &Block{
 		r:            b.r,
 		numberOrHash: &numOrHash,
@@ -818,7 +755,6 @@ func (b *Block) Difficulty(ctx context.Context) (hexutil.Big, error) {
 	if err != nil {
 		return hexutil.Big{}, err
 	}
-
 	return hexutil.Big(*header.Difficulty), nil
 }
 
@@ -827,7 +763,6 @@ func (b *Block) Timestamp(ctx context.Context) (hexutil.Uint64, error) {
 	if err != nil {
 		return 0, err
 	}
-
 	return hexutil.Uint64(header.Time), nil
 }
 
@@ -836,7 +771,6 @@ func (b *Block) Nonce(ctx context.Context) (hexutil.Bytes, error) {
 	if err != nil {
 		return hexutil.Bytes{}, err
 	}
-
 	return header.Nonce[:], nil
 }
 
@@ -845,7 +779,6 @@ func (b *Block) MixHash(ctx context.Context) (common.Hash, error) {
 	if err != nil {
 		return common.Hash{}, err
 	}
-
 	return header.MixDigest, nil
 }
 
@@ -854,7 +787,6 @@ func (b *Block) TransactionsRoot(ctx context.Context) (common.Hash, error) {
 	if err != nil {
 		return common.Hash{}, err
 	}
-
 	return header.TxHash, nil
 }
 
@@ -863,7 +795,6 @@ func (b *Block) StateRoot(ctx context.Context) (common.Hash, error) {
 	if err != nil {
 		return common.Hash{}, err
 	}
-
 	return header.Root, nil
 }
 
@@ -872,7 +803,6 @@ func (b *Block) ReceiptsRoot(ctx context.Context) (common.Hash, error) {
 	if err != nil {
 		return common.Hash{}, err
 	}
-
 	return header.ReceiptHash, nil
 }
 
@@ -881,7 +811,6 @@ func (b *Block) OmmerHash(ctx context.Context) (common.Hash, error) {
 	if err != nil {
 		return common.Hash{}, err
 	}
-
 	return header.UncleHash, nil
 }
 
@@ -899,9 +828,7 @@ func (b *Block) Ommers(ctx context.Context) (*[]*Block, error) {
 	if err != nil || block == nil {
 		return nil, err
 	}
-
 	ret := make([]*Block, 0, len(block.Uncles()))
-
 	for _, uncle := range block.Uncles() {
 		blockNumberOrHash := rpc.BlockNumberOrHashWithHash(uncle.Hash(), false)
 		ret = append(ret, &Block{
@@ -911,7 +838,6 @@ func (b *Block) Ommers(ctx context.Context) (*[]*Block, error) {
 			hash:         uncle.Hash(),
 		})
 	}
-
 	return &ret, nil
 }
 
@@ -920,7 +846,6 @@ func (b *Block) ExtraData(ctx context.Context) (hexutil.Bytes, error) {
 	if err != nil {
 		return hexutil.Bytes{}, err
 	}
-
 	return header.Extra, nil
 }
 
@@ -929,7 +854,6 @@ func (b *Block) LogsBloom(ctx context.Context) (hexutil.Bytes, error) {
 	if err != nil {
 		return hexutil.Bytes{}, err
 	}
-
 	return header.Bloom.Bytes(), nil
 }
 
@@ -938,12 +862,10 @@ func (b *Block) TotalDifficulty(ctx context.Context) (hexutil.Big, error) {
 	if err != nil {
 		return hexutil.Big{}, err
 	}
-
 	td := b.r.backend.GetTd(ctx, hash)
 	if td == nil {
 		return hexutil.Big{}, fmt.Errorf("total difficulty not found %x", hash)
 	}
-
 	return hexutil.Big(*td), nil
 }
 
@@ -952,7 +874,6 @@ func (b *Block) RawHeader(ctx context.Context) (hexutil.Bytes, error) {
 	if err != nil {
 		return hexutil.Bytes{}, err
 	}
-
 	return rlp.EncodeToBytes(header)
 }
 
@@ -961,7 +882,6 @@ func (b *Block) Raw(ctx context.Context) (hexutil.Bytes, error) {
 	if err != nil {
 		return hexutil.Bytes{}, err
 	}
-
 	return rlp.EncodeToBytes(block)
 }
 
@@ -980,7 +900,6 @@ func (a BlockNumberArgs) NumberOr(current rpc.BlockNumberOrHash) rpc.BlockNumber
 		blockNr := rpc.BlockNumber(*a.Block)
 		return rpc.BlockNumberOrHashWithNumber(blockNr)
 	}
-
 	return current
 }
 
@@ -995,7 +914,6 @@ func (b *Block) Miner(ctx context.Context, args BlockNumberArgs) (*Account, erro
 	if err != nil {
 		return nil, err
 	}
-
 	return &Account{
 		r:             b.r,
 		address:       header.Coinbase,
@@ -1017,7 +935,6 @@ func (b *Block) Transactions(ctx context.Context) (*[]*Transaction, error) {
 	if err != nil || block == nil {
 		return nil, err
 	}
-
 	ret := make([]*Transaction, 0, len(block.Transactions()))
 	for i, tx := range block.Transactions() {
 		ret = append(ret, &Transaction{
@@ -1028,7 +945,6 @@ func (b *Block) Transactions(ctx context.Context) (*[]*Transaction, error) {
 			index: uint64(i),
 		})
 	}
-
 	return &ret, nil
 }
 
@@ -1037,14 +953,11 @@ func (b *Block) TransactionAt(ctx context.Context, args struct{ Index Long }) (*
 	if err != nil || block == nil {
 		return nil, err
 	}
-
 	txs := block.Transactions()
 	if args.Index < 0 || int(args.Index) >= len(txs) {
 		return nil, nil
 	}
-
 	tx := txs[args.Index]
-
 	return &Transaction{
 		r:     b.r,
 		hash:  tx.Hash(),
@@ -1059,15 +972,12 @@ func (b *Block) OmmerAt(ctx context.Context, args struct{ Index Long }) (*Block,
 	if err != nil || block == nil {
 		return nil, err
 	}
-
 	uncles := block.Uncles()
 	if args.Index < 0 || int(args.Index) >= len(uncles) {
 		return nil, nil
 	}
-
 	uncle := uncles[args.Index]
 	blockNumberOrHash := rpc.BlockNumberOrHashWithHash(uncle.Hash(), false)
-
 	return &Block{
 		r:            b.r,
 		numberOrHash: &blockNumberOrHash,
@@ -1135,7 +1045,6 @@ func runFilter(ctx context.Context, r *Resolver, filter *filters.Filter) ([]*Log
 	if err != nil || logs == nil {
 		return nil, err
 	}
-
 	ret := make([]*Log, 0, len(logs))
 	for _, log := range logs {
 		ret = append(ret, &Log{
@@ -1144,7 +1053,6 @@ func runFilter(ctx context.Context, r *Resolver, filter *filters.Filter) ([]*Log
 			log:         log,
 		})
 	}
-
 	return ret, nil
 }
 
@@ -1153,7 +1061,6 @@ func (b *Block) Logs(ctx context.Context, args struct{ Filter BlockFilterCriteri
 	if args.Filter.Addresses != nil {
 		addresses = *args.Filter.Addresses
 	}
-
 	var topics [][]common.Hash
 	if args.Filter.Topics != nil {
 		topics = *args.Filter.Topics
@@ -1163,7 +1070,6 @@ func (b *Block) Logs(ctx context.Context, args struct{ Filter BlockFilterCriteri
 	if err != nil {
 		return nil, err
 	}
-
 	filter := b.r.filterSystem.NewBlockFilter(hash, addresses, topics)
 
 	// Run the filter and return all the logs
@@ -1251,7 +1157,6 @@ func (p *Pending) Transactions(ctx context.Context) (*[]*Transaction, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	ret := make([]*Transaction, 0, len(txs))
 	for i, tx := range txs {
 		ret = append(ret, &Transaction{
@@ -1261,7 +1166,6 @@ func (p *Pending) Transactions(ctx context.Context) (*[]*Transaction, error) {
 			index: uint64(i),
 		})
 	}
-
 	return &ret, nil
 }
 
@@ -1269,7 +1173,6 @@ func (p *Pending) Account(ctx context.Context, args struct {
 	Address common.Address
 }) *Account {
 	pendingBlockNr := rpc.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber)
-
 	return &Account{
 		r:             p.r,
 		address:       args.Address,
@@ -1315,12 +1218,10 @@ func (r *Resolver) Block(ctx context.Context, args struct {
 	Hash   *common.Hash
 }) (*Block, error) {
 	var numberOrHash rpc.BlockNumberOrHash
-
 	if args.Number != nil {
 		if *args.Number < 0 {
 			return nil, nil
 		}
-
 		number := rpc.BlockNumber(*args.Number)
 		numberOrHash = rpc.BlockNumberOrHashWithNumber(number)
 	} else if args.Hash != nil {
@@ -1328,7 +1229,6 @@ func (r *Resolver) Block(ctx context.Context, args struct {
 	} else {
 		numberOrHash = rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)
 	}
-
 	block := &Block{
 		r:            r,
 		numberOrHash: &numberOrHash,
@@ -1342,7 +1242,6 @@ func (r *Resolver) Block(ctx context.Context, args struct {
 	} else if h == nil {
 		return nil, nil
 	}
-
 	return block, nil
 }
 
@@ -1358,7 +1257,6 @@ func (r *Resolver) Blocks(ctx context.Context, args struct {
 	} else {
 		to = rpc.BlockNumber(r.backend.CurrentBlock().Number.Int64())
 	}
-
 	if to < from {
 		return []*Block{}, nil
 	}
@@ -1379,13 +1277,11 @@ func (r *Resolver) Blocks(ctx context.Context, args struct {
 			// Blocks after must be non-existent too, break.
 			break
 		}
-
 		ret = append(ret, block)
 		if err := ctx.Err(); err != nil {
 			return nil, err
 		}
 	}
-
 	return ret, nil
 }
 
@@ -1411,9 +1307,7 @@ func (r *Resolver) SendRawTransaction(ctx context.Context, args struct{ Data hex
 	if err := tx.UnmarshalBinary(args.Data); err != nil {
 		return common.Hash{}, err
 	}
-
 	hash, err := ethapi.SubmitTransaction(ctx, r.backend, tx)
-
 	return hash, err
 }
 
@@ -1443,24 +1337,20 @@ func (r *Resolver) Logs(ctx context.Context, args struct{ Filter FilterCriteria
 	if args.Filter.FromBlock != nil {
 		begin = int64(*args.Filter.FromBlock)
 	}
-
 	end := rpc.LatestBlockNumber.Int64()
 	if args.Filter.ToBlock != nil {
 		end = int64(*args.Filter.ToBlock)
 	}
-
 	var addresses []common.Address
 	if args.Filter.Addresses != nil {
 		addresses = *args.Filter.Addresses
 	}
-
 	var topics [][]common.Hash
 	if args.Filter.Topics != nil {
 		topics = *args.Filter.Topics
 	}
 	// Construct the range filter
 	filter := r.filterSystem.NewRangeFilter(begin, end, addresses, topics)
-
 	return runFilter(ctx, r, filter)
 }
 
@@ -1469,11 +1359,9 @@ func (r *Resolver) GasPrice(ctx context.Context) (hexutil.Big, error) {
 	if err != nil {
 		return hexutil.Big{}, err
 	}
-
 	if head := r.backend.CurrentHeader(); head.BaseFee != nil {
 		tipcap.Add(tipcap, head.BaseFee)
 	}
-
 	return (hexutil.Big)(*tipcap), nil
 }
 
@@ -1482,7 +1370,6 @@ func (r *Resolver) MaxPriorityFeePerGas(ctx context.Context) (hexutil.Big, error
 	if err != nil {
 		return hexutil.Big{}, err
 	}
-
 	return (hexutil.Big)(*tipcap), nil
 }
 

graphql/graphql_test.go

@@ -49,14 +49,10 @@ func TestBuildSchema(t *testing.T) {
 	// Copy config
 	conf := node.DefaultConfig
 	conf.DataDir = ddir
-
 	stack, err := node.New(&conf)
-	defer stack.Close()
-
 	if err != nil {
 		t.Fatalf("could not create new node: %v", err)
 	}
-
 	defer stack.Close()
 	// Make sure the schema can be parsed and matched up to the object model.
 	if _, err := newHandler(stack, nil, nil, []string{}, []string{}); err != nil {
@@ -68,7 +64,6 @@ func TestBuildSchema(t *testing.T) {
 func TestGraphQLBlockSerialization(t *testing.T) {
 	stack := createNode(t)
 	defer stack.Close()
-
 	genesis := &core.Genesis{
 		Config:     params.AllEthashProtocolChanges,
 		GasLimit:   11500000,
@@ -158,25 +153,20 @@ func TestGraphQLBlockSerialization(t *testing.T) {
 		if err != nil {
 			t.Fatalf("could not post: %v", err)
 		}
-
 		bodyBytes, err := io.ReadAll(resp.Body)
 		resp.Body.Close()
-
 		if err != nil {
 			t.Fatalf("could not read from response body: %v", err)
 		}
-
 		if have := string(bodyBytes); have != tt.want {
 			t.Errorf("testcase %d %s,\nhave:\n%v\nwant:\n%v", i, tt.body, have, tt.want)
 		}
-
 		if tt.code != resp.StatusCode {
 			t.Errorf("testcase %d %s,\nwrong statuscode, have: %v, want: %v", i, tt.body, resp.StatusCode, tt.code)
 		}
 	}
 }
 
-// nolint:typecheck
 func TestGraphQLBlockSerializationEIP2718(t *testing.T) {
 	// Account for signing txes
 	var (
@@ -185,10 +175,8 @@ func TestGraphQLBlockSerializationEIP2718(t *testing.T) {
 		funds   = big.NewInt(1000000000000000)
 		dad     = common.HexToAddress("0x0000000000000000000000000000000000000dad")
 	)
-
 	stack := createNode(t)
 	defer stack.Close()
-
 	genesis := &core.Genesis{
 		Config:     params.AllEthashProtocolChanges,
 		GasLimit:   11500000,
@@ -207,7 +195,6 @@ func TestGraphQLBlockSerializationEIP2718(t *testing.T) {
 	signer := types.LatestSigner(genesis.Config)
 	newGQLService(t, stack, false, genesis, 1, func(i int, gen *core.BlockGen) {
 		gen.SetCoinbase(common.Address{1})
-
 		tx, _ := types.SignNewTx(key, signer, &types.LegacyTx{
 			Nonce:    uint64(0),
 			To:       &dad,
@@ -250,18 +237,14 @@ func TestGraphQLBlockSerializationEIP2718(t *testing.T) {
 		if err != nil {
 			t.Fatalf("could not post: %v", err)
 		}
-
 		bodyBytes, err := io.ReadAll(resp.Body)
 		resp.Body.Close()
-
 		if err != nil {
 			t.Fatalf("could not read from response body: %v", err)
 		}
-
 		if have := string(bodyBytes); have != tt.want {
 			t.Errorf("testcase %d %s,\nhave:\n%v\nwant:\n%v", i, tt.body, have, tt.want)
 		}
-
 		if tt.code != resp.StatusCode {
 			t.Errorf("testcase %d %s,\nwrong statuscode, have: %v, want: %v", i, tt.body, resp.StatusCode, tt.code)
 		}
@@ -272,27 +255,20 @@ func TestGraphQLBlockSerializationEIP2718(t *testing.T) {
 func TestGraphQLHTTPOnSamePort_GQLRequest_Unsuccessful(t *testing.T) {
 	stack := createNode(t)
 	defer stack.Close()
-
 	if err := stack.Start(); err != nil {
 		t.Fatalf("could not start node: %v", err)
 	}
-
 	body := strings.NewReader(`{"query": "{block{number}}","variables": null}`)
-
 	resp, err := http.Post(fmt.Sprintf("%s/graphql", stack.HTTPEndpoint()), "application/json", body)
 	if err != nil {
 		t.Fatalf("could not post: %v", err)
 	}
-
 	resp.Body.Close()
 	// make sure the request is not handled successfully
 	assert.Equal(t, http.StatusNotFound, resp.StatusCode)
 }
 
-// nolint:typecheck
 func TestGraphQLConcurrentResolvers(t *testing.T) {
-	t.Parallel()
-
 	var (
 		key, _  = crypto.GenerateKey()
 		addr    = crypto.PubkeyToAddress(key.PublicKey)
@@ -315,7 +291,6 @@ func TestGraphQLConcurrentResolvers(t *testing.T) {
 		signer = types.LatestSigner(genesis.Config)
 		stack  = createNode(t)
 	)
-
 	defer stack.Close()
 
 	var tx *types.Transaction
@@ -339,13 +314,13 @@ func TestGraphQLConcurrentResolvers(t *testing.T) {
 		// Multiple txes race to get/set the block hash.
 		{
 			body: "{block { transactions { logs { account { address } } } } }",
-			want: fmt.Sprintf(`{"block":{"transactions":[{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}},{"account":{"address":"%s"}}]}]}}`, dadStr, dadStr, core.GetFeeAddress(), dadStr, dadStr, core.GetFeeAddress(), dadStr, dadStr, core.GetFeeAddress()),
+			want: fmt.Sprintf(`{"block":{"transactions":[{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]},{"logs":[{"account":{"address":"%s"}},{"account":{"address":"%s"}}]}]}}`, dadStr, dadStr, dadStr, dadStr, dadStr, dadStr),
 		},
 		// Multiple fields of a tx race to resolve it. Happens in this case
 		// because resolving the tx body belonging to a log is delayed.
 		{
 			body: `{block { logs(filter: {}) { transaction { nonce value gasPrice }}}}`,
-			want: `{"block":{"logs":[{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}}]}}`,
+			want: `{"block":{"logs":[{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x0","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x1","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}},{"transaction":{"nonce":"0x2","value":"0x0","gasPrice":"0x3b9aca00"}}]}}`,
 		},
 		// Multiple txes of a block race to set/retrieve receipts of a block.
 		{
@@ -374,17 +349,13 @@ func TestGraphQLConcurrentResolvers(t *testing.T) {
 		},
 	} {
 		res := handler.Schema.Exec(context.Background(), tt.body, "", map[string]interface{}{})
-
 		if res.Errors != nil {
 			t.Fatalf("failed to execute query for testcase #%d: %v", i, res.Errors)
 		}
-
 		have, err := json.Marshal(res.Data)
-
 		if err != nil {
 			t.Fatalf("failed to encode graphql response for testcase #%d: %s", i, err)
 		}
-
 		if string(have) != tt.want {
 			t.Errorf("response unmatch for testcase #%d.\nExpected:\n%s\nGot:\n%s\n", i, tt.want, have)
 		}
@@ -452,8 +423,6 @@ func TestWithdrawals(t *testing.T) {
 }
 
 func createNode(t *testing.T) *node.Node {
-	t.Helper()
-
 	stack, err := node.New(&node.Config{
 		HTTPHost:     "127.0.0.1",
 		HTTPPort:     0,
@@ -464,7 +433,6 @@ func createNode(t *testing.T) *node.Node {
 	if err != nil {
 		t.Fatalf("could not create node: %v", err)
 	}
-
 	return stack
 }
 
@@ -488,7 +456,6 @@ func newGQLService(t *testing.T, stack *node.Node, shanghai bool, gspec *core.Ge
 		shanghaiTime := uint64(5)
 		chainCfg.ShanghaiTime = &shanghaiTime
 	}
-
 	ethBackend, err := eth.New(stack, ethConf)
 	if err != nil {
 		t.Fatalf("could not create eth backend: %v", err)
@@ -502,11 +469,9 @@ func newGQLService(t *testing.T, stack *node.Node, shanghai bool, gspec *core.Ge
 	}
 	// Set up handler
 	filterSystem := filters.NewFilterSystem(ethBackend.APIBackend, filters.Config{})
-
 	handler, err := newHandler(stack, ethBackend.APIBackend, filterSystem, []string{}, []string{})
 	if err != nil {
 		t.Fatalf("could not create graphql service: %v", err)
 	}
-
 	return handler, chain
 }

graphql/service.go

@@ -42,7 +42,6 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		OperationName string                 `json:"operationName"`
 		Variables     map[string]interface{} `json:"variables"`
 	}
-
 	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
@@ -54,7 +53,6 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		timer     *time.Timer
 		cancel    context.CancelFunc
 	)
-
 	ctx, cancel = context.WithCancel(ctx)
 	defer cancel()
 
@@ -68,7 +66,6 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 				response := &graphql.Response{
 					Errors: []*gqlErrors.QueryError{{Message: "request timed out"}},
 				}
-
 				responseJSON, err := json.Marshal(response)
 				if err != nil {
 					http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -82,8 +79,7 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 				// chunked transfer encoding must be disabled by setting content-length.
 				w.Header().Set("content-type", "application/json")
 				w.Header().Set("content-length", strconv.Itoa(len(responseJSON)))
-				_, _ = w.Write(responseJSON)
+				w.Write(responseJSON)
-
 				if flush, ok := w.(http.Flusher); ok {
 					flush.Flush()
 				}
@@ -92,7 +88,6 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 
 	response := h.Schema.Exec(ctx, params.Query, params.OperationName, params.Variables)
-
 	timer.Stop()
 	responded.Do(func() {
 		responseJSON, err := json.Marshal(response)
@@ -100,13 +95,11 @@ func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
-
 		if len(response.Errors) > 0 {
 			w.WriteHeader(http.StatusBadRequest)
 		}
-
 		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write(responseJSON)
+		w.Write(responseJSON)
 	})
 }
 
@@ -125,7 +118,6 @@ func newHandler(stack *node.Node, backend ethapi.Backend, filterSystem *filters.
 	if err != nil {
 		return nil, err
 	}
-
 	h := handler{Schema: s}
 	handler := node.NewHTTPHandlerStack(h, cors, vhosts, nil)
 

internal/cli/server/config.go

@@ -1084,8 +1084,6 @@ func (c *Config) buildEth(stack *node.Node, accountManager *accounts.Manager) (*
 		log.Debug("Sanitizing Go's GC trigger", "percent", int(gogc))
 		godebug.SetGCPercent(int(gogc))
 
-		n.TrieCleanCacheJournal = c.Cache.Journal
-		n.TrieCleanCacheRejournal = c.Cache.Rejournal
 		n.DatabaseCache = calcPerc(c.Cache.PercDatabase)
 		n.SnapshotCache = calcPerc(c.Cache.PercSnapshot)
 		n.TrieCleanCache = calcPerc(c.Cache.PercTrie)

internal/cli/server/server.go

@@ -273,7 +273,7 @@ func NewServer(config *Config, opts ...serverOption) (*Server, error) {
 
 	// sealing (if enabled) or in dev mode
 	if config.Sealer.Enabled || config.Developer.Enabled {
-		if err := srv.backend.StartMining(1); err != nil {
+		if err := srv.backend.StartMining(); err != nil {
 			return nil, err
 		}
 	}

internal/cli/snapshot.go

@@ -170,7 +170,6 @@ func (c *PruneStateCommand) Run(args []string) int {
 
 	prunerconfig := pruner.Config{
 		Datadir:   node.ResolvePath(""),
-		Cachedir:  node.ResolvePath(c.cacheTrieJournal),
 		BloomSize: c.bloomfilterSize,
 	}
 

internal/debug/flags.go

@@ -26,16 +26,15 @@ import (
 	"path/filepath"
 	"runtime"
 
+	"github.com/ethereum/go-ethereum/internal/flags"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
+	"github.com/ethereum/go-ethereum/metrics/exp"
 	"github.com/fjl/memsize/memsizeui"
 	"github.com/mattn/go-colorable"
 	"github.com/mattn/go-isatty"
 	"github.com/urfave/cli/v2"
 	"gopkg.in/natefinch/lumberjack.v2"
-
-	"github.com/ethereum/go-ethereum/internal/flags"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/metrics"
-	"github.com/ethereum/go-ethereum/metrics/exp"
 )
 
 var Memsize memsizeui.Handler
@@ -192,14 +191,12 @@ func init() {
 
 // Setup initializes profiling and logging based on the CLI flags.
 // It should be called as early as possible in the program.
-// nolint:nestif
 func Setup(ctx *cli.Context) error {
 	var (
 		logfmt     log.Format
 		output     = io.Writer(os.Stderr)
 		logFmtFlag = ctx.String(logFormatFlag.Name)
 	)
-
 	switch {
 	case ctx.Bool(logjsonFlag.Name):
 		// Retain backwards compatibility with `--log.json` flag if `--log.format` not set
@@ -214,33 +211,28 @@ func Setup(ctx *cli.Context) error {
 		if useColor {
 			output = colorable.NewColorableStderr()
 		}
-
 		logfmt = log.TerminalFormat(useColor)
 	default:
 		// Unknown log format specified
 		return fmt.Errorf("unknown log format: %v", ctx.String(logFormatFlag.Name))
 	}
-
 	var (
 		stdHandler = log.StreamHandler(output, logfmt)
 		ostream    = stdHandler
 		logFile    = ctx.String(logFileFlag.Name)
 		rotation   = ctx.Bool(logRotateFlag.Name)
 	)
-
 	if len(logFile) > 0 {
 		if err := validateLogLocation(filepath.Dir(logFile)); err != nil {
 			return fmt.Errorf("failed to initiatilize file logger: %v", err)
 		}
 	}
-
 	context := []interface{}{"rotate", rotation}
 	if len(logFmtFlag) > 0 {
 		context = append(context, "format", logFmtFlag)
 	} else {
 		context = append(context, "format", "terminal")
 	}
-
 	if rotation {
 		// Lumberjack uses <processname>-lumberjack.log in is.TempDir() if empty.
 		// so typically /tmp/geth-lumberjack.log on linux
@@ -249,7 +241,6 @@ func Setup(ctx *cli.Context) error {
 		} else {
 			context = append(context, "location", filepath.Join(os.TempDir(), "geth-lumberjack.log"))
 		}
-
 		ostream = log.MultiHandler(log.StreamHandler(&lumberjack.Logger{
 			Filename:   logFile,
 			MaxSize:    ctx.Int(logMaxSizeMBsFlag.Name),
@@ -262,17 +253,14 @@ func Setup(ctx *cli.Context) error {
 			return err
 		} else {
 			ostream = log.MultiHandler(logOutputStream, stdHandler)
-
 			context = append(context, "location", logFile)
 		}
 	}
-
 	glogger.SetHandler(ostream)
 
 	// logging
 	verbosity := ctx.Int(verbosityFlag.Name)
 	glogger.Verbosity(log.Lvl(verbosity))
-
 	vmodule := ctx.String(logVmoduleFlag.Name)
 	if vmodule == "" {
 		// Retain backwards compatibility with `--vmodule` flag if `--log.vmodule` not set
@@ -281,14 +269,12 @@ func Setup(ctx *cli.Context) error {
 			defer log.Warn("The flag '--vmodule' is deprecated, please use '--log.vmodule' instead")
 		}
 	}
-
 	glogger.Vmodule(vmodule)
 
 	debug := ctx.Bool(debugFlag.Name)
 	if ctx.IsSet(debugFlag.Name) {
 		debug = ctx.Bool(debugFlag.Name)
 	}
-
 	log.PrintOrigins(debug)
 
 	backtrace := ctx.String(backtraceAtFlag.Name)
@@ -327,15 +313,10 @@ func Setup(ctx *cli.Context) error {
 		// This context value ("metrics.addr") represents the utils.MetricsHTTPFlag.Name.
 		// It cannot be imported because it will cause a cyclical dependency.
 		StartPProf(address, !ctx.IsSet("metrics.addr"))
-	} else if ctx.IsSet("bor-mumbai") || ctx.IsSet("bor-mainnet") {
-		address := fmt.Sprintf("%s:%d", "0.0.0.0", 7071)
-		StartPProf(address, !ctx.IsSet("metrics.addr"))
 	}
-
 	if len(logFile) > 0 || rotation {
 		log.Info("Logging configured", context...)
 	}
-
 	return nil
 }
 
@@ -345,10 +326,8 @@ func StartPProf(address string, withMetrics bool) {
 	if withMetrics {
 		exp.Exp(metrics.DefaultRegistry)
 	}
-
 	http.Handle("/memsize/", http.StripPrefix("/memsize", &Memsize))
 	log.Info("Starting pprof server", "addr", fmt.Sprintf("http://%s/debug/pprof", address))
-
 	go func() {
 		if err := http.ListenAndServe(address, nil); err != nil {
 			log.Error("Failure in running pprof server", "err", err)
@@ -361,7 +340,6 @@ func StartPProf(address string, withMetrics bool) {
 func Exit() {
 	Handler.StopCPUProfile()
 	Handler.StopGoTrace()
-
 	if closer, ok := logOutputStream.(io.Closer); ok {
 		closer.Close()
 	}
@@ -378,6 +356,5 @@ func validateLogLocation(path string) error {
 	} else {
 		f.Close()
 	}
-
 	return os.Remove(tmp)
 }

internal/ethapi/api.go

@@ -1213,10 +1213,10 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S
 		return nil, err
 	}
 
-	return doCallWithState(ctx, b, args, header, state, timeout, globalGasCap)
+	return doCallWithState(ctx, b, args, header, state, timeout, globalGasCap, blockOverrides)
 }
 
-func doCallWithState(ctx context.Context, b Backend, args TransactionArgs, header *types.Header, state *state.StateDB, timeout time.Duration, globalGasCap uint64) (*core.ExecutionResult, error) {
+func doCallWithState(ctx context.Context, b Backend, args TransactionArgs, header *types.Header, state *state.StateDB, timeout time.Duration, globalGasCap uint64, blockOverrides *BlockOverrides) (*core.ExecutionResult, error) {
 	// Setup context so it may be cancelled the call has completed
 	// or, in case of unmetered gas, setup a context with a timeout.
 	var cancel context.CancelFunc
@@ -1317,6 +1317,19 @@ func (e *revertError) ErrorData() interface{} {
 // Note, this function doesn't make and changes in the state/blockchain and is
 // useful to execute and retrieve values.
 func (s *BlockChainAPI) Call(ctx context.Context, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, blockOverrides *BlockOverrides) (hexutil.Bytes, error) {
+	return s.CallWithState(ctx, args, blockNrOrHash, nil, overrides, blockOverrides)
+}
+
+// CallWithState executes the given transaction on the given state for
+// the given block number. Note that as it does an EVM call, fields in
+// the underlying state will change. Make sure to handle it outside of
+// this function (ideally by sending a copy of state).
+//
+// Additionally, the caller can specify a batch of contract for fields overriding.
+//
+// Note, this function doesn't make and changes in the state/blockchain and is
+// useful to execute and retrieve values.
+func (s *BlockChainAPI) CallWithState(ctx context.Context, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, state *state.StateDB, overrides *StateOverride, blockOverrides *BlockOverrides) (hexutil.Bytes, error) {
 	result, err := DoCall(ctx, s.b, args, blockNrOrHash, overrides, blockOverrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap())
 	if err != nil {
 		return nil, err
@@ -1595,7 +1608,7 @@ func RPCMarshalHeader(head *types.Header) map[string]interface{} {
 // RPCMarshalBlock converts the given block to the RPC output which depends on fullTx. If inclTx is true transactions are
 // returned. When fullTx is true the returned block contains full transaction details, otherwise it will only contain
 // transaction hashes.
-func RPCMarshalBlock(block *types.Block, inclTx bool, fullTx bool, config *params.ChainConfig) map[string]interface{} {
+func RPCMarshalBlock(block *types.Block, inclTx bool, fullTx bool, config *params.ChainConfig, db ethdb.Database) map[string]interface{} {
 	fields := RPCMarshalHeader(block.Header())
 	fields["size"] = hexutil.Uint64(block.Size())
 
@@ -1605,7 +1618,7 @@ func RPCMarshalBlock(block *types.Block, inclTx bool, fullTx bool, config *param
 		}
 		if fullTx {
 			formatTx = func(idx int, tx *types.Transaction) interface{} {
-				return newRPCTransactionFromBlockIndex(block, uint64(idx), config)
+				return newRPCTransactionFromBlockIndex(block, uint64(idx), config, db)
 			}
 		}
 
@@ -1644,7 +1657,7 @@ func (s *BlockChainAPI) rpcMarshalHeader(ctx context.Context, header *types.Head
 // rpcMarshalBlock uses the generalized output filler, then adds the total difficulty field, which requires
 // a `BlockchainAPI`.
 func (s *BlockChainAPI) rpcMarshalBlock(ctx context.Context, b *types.Block, inclTx bool, fullTx bool) (map[string]interface{}, error) {
-	fields := RPCMarshalBlock(b, inclTx, fullTx, s.b.ChainConfig())
+	fields := RPCMarshalBlock(b, inclTx, fullTx, s.b.ChainConfig(), s.b.ChainDb())
 	if inclTx {
 		fields["totalDifficulty"] = (*hexutil.Big)(s.b.GetTd(ctx, b.Hash()))
 	}
@@ -1780,7 +1793,7 @@ func newRPCTransactionFromBlockIndex(b *types.Block, index uint64, config *param
 		return nil
 	}
 
-	rpcTx := newRPCTransaction(txs[index], b.Hash(), b.NumberU64(), index, b.BaseFee(), config)
+	rpcTx := newRPCTransaction(txs[index], b.Hash(), b.NumberU64(), b.Time(), index, b.BaseFee(), config)
 
 	// If the transaction is a bor transaction, we need to set the hash to the derived bor tx hash. BorTx is always the last index.
 	if borReceipt != nil && index == uint64(len(txs)-1) {

internal/ethapi/api_test.go

@@ -360,7 +360,7 @@ func newTestBackend(t *testing.T, n int, gspec *core.Genesis, generator func(i i
 	// Generate blocks for testing
 	db, blocks, _ := core.GenerateChainWithGenesis(gspec, engine, n, generator)
 	txlookupLimit := uint64(0)
-	chain, err := core.NewBlockChain(db, cacheConfig, gspec, nil, engine, vm.Config{}, nil, &txlookupLimit)
+	chain, err := core.NewBlockChain(db, cacheConfig, gspec, nil, engine, vm.Config{}, nil, &txlookupLimit, nil)
 	if err != nil {
 		t.Fatalf("failed to create tester chain: %v", err)
 	}
@@ -536,6 +536,29 @@ func (b testBackend) ServiceFilter(ctx context.Context, session *bloombits.Match
 	panic("implement me")
 }
 
+func (b testBackend) GetBorBlockLogs(ctx context.Context, hash common.Hash) ([]*types.Log, error) {
+	receipt, err := b.GetBorBlockReceipt(ctx, hash)
+	if err != nil || receipt == nil {
+		return nil, err
+	}
+
+	return receipt.Logs, nil
+}
+
+func (b testBackend) GetBorBlockReceipt(ctx context.Context, hash common.Hash) (*types.Receipt, error) {
+	number := rawdb.ReadHeaderNumber(b.db, hash)
+	if number == nil {
+		return nil, nil
+	}
+
+	receipt := rawdb.ReadRawBorReceipt(b.db, hash, *number)
+	if receipt == nil {
+		return nil, nil
+	}
+
+	return receipt, nil
+}
+
 func TestEstimateGas(t *testing.T) {
 	t.Parallel()
 	// Initialize test accounts

internal/ethapi/bor_api.go

@@ -34,7 +34,7 @@ func (s *BlockChainAPI) appendRPCMarshalBorTransaction(ctx context.Context, bloc
 			formattedTxs := fields["transactions"].([]interface{})
 
 			if fullTx {
-				marshalledTx := newRPCTransaction(borTx, blockHash, blockNumber, txIndex, block.BaseFee(), s.b.ChainConfig())
+				marshalledTx := newRPCTransaction(borTx, blockHash, blockNumber, block.Time(), txIndex, block.BaseFee(), s.b.ChainConfig())
 				// newRPCTransaction calculates hash based on RLP of the transaction data.
 				// In case of bor block tx, we need simple derived tx hash (same as function argument) instead of RLP hash
 				marshalledTx.Hash = txHash

les/api.go

@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/common/mclock"
 	vfs "github.com/ethereum/go-ethereum/les/vflux/server"
 	"github.com/ethereum/go-ethereum/p2p/enode"
@@ -49,7 +48,6 @@ func parseNode(node string) (enode.ID, error) {
 	if id, err := enode.ParseID(node); err == nil {
 		return id, nil
 	}
-
 	if node, err := enode.Parse(enode.ValidSchemes, node); err == nil {
 		return node.ID(), nil
 	} else {
@@ -65,14 +63,12 @@ func (api *LightServerAPI) ServerInfo() map[string]interface{} {
 	_, res["totalCapacity"] = api.server.clientPool.Limits()
 	_, res["totalConnectedCapacity"] = api.server.clientPool.Active()
 	res["priorityConnectedCapacity"] = 0 //TODO connect when token sale module is added
-
 	return res
 }
 
 // ClientInfo returns information about clients listed in the ids list or matching the given tags
 func (api *LightServerAPI) ClientInfo(nodes []string) map[enode.ID]map[string]interface{} {
 	var ids []enode.ID
-
 	for _, node := range nodes {
 		if id, err := parseNode(node); err == nil {
 			ids = append(ids, id)
@@ -80,11 +76,9 @@ func (api *LightServerAPI) ClientInfo(nodes []string) map[enode.ID]map[string]in
 	}
 
 	res := make(map[enode.ID]map[string]interface{})
-
 	if len(ids) == 0 {
 		ids = api.server.peers.ids()
 	}
-
 	for _, id := range ids {
 		if peer := api.server.peers.peer(id); peer != nil {
 			res[id] = api.clientInfo(peer, peer.balance)
@@ -94,7 +88,6 @@ func (api *LightServerAPI) ClientInfo(nodes []string) map[enode.ID]map[string]in
 			})
 		}
 	}
-
 	return res
 }
 
@@ -107,12 +100,10 @@ func (api *LightServerAPI) ClientInfo(nodes []string) map[enode.ID]map[string]in
 func (api *LightServerAPI) PriorityClientInfo(start, stop enode.ID, maxCount int) map[enode.ID]map[string]interface{} {
 	res := make(map[enode.ID]map[string]interface{})
 	ids := api.server.clientPool.GetPosBalanceIDs(start, stop, maxCount+1)
-
 	if len(ids) > maxCount {
 		res[ids[maxCount]] = make(map[string]interface{})
 		ids = ids[:maxCount]
 	}
-
 	for _, id := range ids {
 		if peer := api.server.peers.peer(id); peer != nil {
 			res[id] = api.clientInfo(peer, peer.balance)
@@ -122,7 +113,6 @@ func (api *LightServerAPI) PriorityClientInfo(start, stop enode.ID, maxCount int
 			})
 		}
 	}
-
 	return res
 }
 
@@ -140,7 +130,6 @@ func (api *LightServerAPI) clientInfo(peer *clientPeer, balance vfs.ReadOnlyBala
 		info["capacity"] = peer.getCapacity()
 		info["pricing/negBalance"] = nb
 	}
-
 	return info
 }
 
@@ -148,7 +137,6 @@ func (api *LightServerAPI) clientInfo(peer *clientPeer, balance vfs.ReadOnlyBala
 // or the default parameters applicable to clients connected in the future
 func (api *LightServerAPI) setParams(params map[string]interface{}, client *clientPeer, posFactors, negFactors *vfs.PriceFactors) (updateFactors bool, err error) {
 	defParams := client == nil
-
 	for name, value := range params {
 		errValue := func() error {
 			return fmt.Errorf("invalid value for parameter '%s'", name)
@@ -189,12 +177,10 @@ func (api *LightServerAPI) setParams(params map[string]interface{}, client *clie
 				err = fmt.Errorf("invalid client parameter '%s'", name)
 			}
 		}
-
 		if err != nil {
 			return
 		}
 	}
-
 	return
 }
 
@@ -202,22 +188,17 @@ func (api *LightServerAPI) setParams(params map[string]interface{}, client *clie
 // or all connected clients if the list is empty
 func (api *LightServerAPI) SetClientParams(nodes []string, params map[string]interface{}) error {
 	var err error
-
 	for _, node := range nodes {
 		var id enode.ID
-
 		if id, err = parseNode(node); err != nil {
 			return err
 		}
-
 		if peer := api.server.peers.peer(id); peer != nil {
 			posFactors, negFactors := peer.balance.GetPriceFactors()
 			update, e := api.setParams(params, peer, &posFactors, &negFactors)
-
 			if update {
 				peer.balance.SetPriceFactors(posFactors, negFactors)
 			}
-
 			if e != nil {
 				err = e
 			}
@@ -225,7 +206,6 @@ func (api *LightServerAPI) SetClientParams(nodes []string, params map[string]int
 			err = fmt.Errorf("client %064x is not connected", id)
 		}
 	}
-
 	return err
 }
 
@@ -235,7 +215,6 @@ func (api *LightServerAPI) SetDefaultParams(params map[string]interface{}) error
 	if update {
 		api.server.clientPool.SetDefaultFactors(api.defaultPosFactors, api.defaultNegFactors)
 	}
-
 	return err
 }
 
@@ -247,9 +226,7 @@ func (api *LightServerAPI) SetConnectedBias(bias time.Duration) error {
 	if bias < time.Duration(0) {
 		return fmt.Errorf("bias illegal: %v less than 0", bias)
 	}
-
 	api.server.clientPool.SetConnectedBias(bias)
-
 	return nil
 }
 
@@ -257,15 +234,12 @@ func (api *LightServerAPI) SetConnectedBias(bias time.Duration) error {
 // the balance before and after the operation
 func (api *LightServerAPI) AddBalance(node string, amount int64) (balance [2]uint64, err error) {
 	var id enode.ID
-
 	if id, err = parseNode(node); err != nil {
 		return
 	}
-
 	api.server.clientPool.BalanceOperation(id, "", func(nb vfs.AtomicBalanceOperator) {
 		balance[0], balance[1], err = nb.AddBalance(amount)
 	})
-
 	return
 }
 
@@ -277,24 +251,20 @@ func (api *LightServerAPI) AddBalance(node string, amount int64) (balance [2]uin
 // Therefore a controlled total measurement time is achievable in multiple passes.
 func (api *LightServerAPI) Benchmark(setups []map[string]interface{}, passCount, length int) ([]map[string]interface{}, error) {
 	benchmarks := make([]requestBenchmark, len(setups))
-
 	for i, setup := range setups {
 		if t, ok := setup["type"].(string); ok {
 			getInt := func(field string, def int) int {
 				if value, ok := setup[field].(float64); ok {
 					return int(value)
 				}
-
 				return def
 			}
 			getBool := func(field string, def bool) bool {
 				if value, ok := setup[field].(bool); ok {
 					return value
 				}
-
 				return def
 			}
-
 			switch t {
 			case "header":
 				benchmarks[i] = &benchmarkBlockHeaders{
@@ -332,10 +302,8 @@ func (api *LightServerAPI) Benchmark(setups []map[string]interface{}, passCount,
 			return nil, errUnknownBenchmarkType
 		}
 	}
-
 	rs := api.server.handler.runBenchmark(benchmarks, passCount, time.Millisecond*time.Duration(length))
 	result := make([]map[string]interface{}, len(setups))
-
 	for i, r := range rs {
 		res := make(map[string]interface{})
 		if r.err == nil {
@@ -346,10 +314,8 @@ func (api *LightServerAPI) Benchmark(setups []map[string]interface{}, passCount,
 		} else {
 			res["error"] = r.err.Error()
 		}
-
 		result[i] = res
 	}
-
 	return result, nil
 }
 
@@ -371,11 +337,9 @@ func (api *DebugAPI) FreezeClient(node string) error {
 		id  enode.ID
 		err error
 	)
-
 	if id, err = parseNode(node); err != nil {
 		return err
 	}
-
 	if peer := api.server.peers.peer(id); peer != nil {
 		peer.freeze()
 		return nil
@@ -383,64 +347,3 @@ func (api *DebugAPI) FreezeClient(node string) error {
 		return fmt.Errorf("client %064x is not connected", id[:])
 	}
 }
-
-// LightAPI provides an API to access the LES light server or light client.
-type LightAPI struct {
-	backend *lesCommons
-}
-
-// NewLightAPI creates a new LES service API.
-func NewLightAPI(backend *lesCommons) *LightAPI {
-	return &LightAPI{backend: backend}
-}
-
-// LatestCheckpoint returns the latest local checkpoint package.
-//
-// The checkpoint package consists of 4 strings:
-//
-//	result[0], hex encoded latest section index
-//	result[1], 32 bytes hex encoded latest section head hash
-//	result[2], 32 bytes hex encoded latest section canonical hash trie root hash
-//	result[3], 32 bytes hex encoded latest section bloom trie root hash
-func (api *LightAPI) LatestCheckpoint() ([4]string, error) {
-	var res [4]string
-
-	cp := api.backend.latestLocalCheckpoint()
-	if cp.Empty() {
-		return res, errNoCheckpoint
-	}
-
-	res[0] = hexutil.EncodeUint64(cp.SectionIndex)
-	res[1], res[2], res[3] = cp.SectionHead.Hex(), cp.CHTRoot.Hex(), cp.BloomRoot.Hex()
-
-	return res, nil
-}
-
-// GetCheckpoint returns the specific local checkpoint package.
-//
-// The checkpoint package consists of 3 strings:
-//
-//	result[0], 32 bytes hex encoded latest section head hash
-//	result[1], 32 bytes hex encoded latest section canonical hash trie root hash
-//	result[2], 32 bytes hex encoded latest section bloom trie root hash
-func (api *LightAPI) GetCheckpoint(index uint64) ([3]string, error) {
-	var res [3]string
-
-	cp := api.backend.localCheckpoint(index)
-	if cp.Empty() {
-		return res, errNoCheckpoint
-	}
-
-	res[0], res[1], res[2] = cp.SectionHead.Hex(), cp.CHTRoot.Hex(), cp.BloomRoot.Hex()
-
-	return res, nil
-}
-
-// GetCheckpointContractAddress returns the contract contract address in hex format.
-func (api *LightAPI) GetCheckpointContractAddress() (string, error) {
-	if api.backend.oracle == nil {
-		return "", errNotActivated
-	}
-
-	return api.backend.oracle.Contract().ContractAddr().Hex(), nil
-}

les/api_backend.go

@@ -67,11 +67,9 @@ func (b *LesApiBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumb
 	if number == rpc.PendingBlockNumber {
 		return b.eth.blockchain.CurrentHeader(), nil
 	}
-
 	if number == rpc.LatestBlockNumber {
 		return b.eth.blockchain.CurrentHeader(), nil
 	}
-
 	return b.eth.blockchain.GetHeaderByNumberOdr(ctx, uint64(number))
 }
 
@@ -79,24 +77,19 @@ func (b *LesApiBackend) HeaderByNumberOrHash(ctx context.Context, blockNrOrHash
 	if blockNr, ok := blockNrOrHash.Number(); ok {
 		return b.HeaderByNumber(ctx, blockNr)
 	}
-
 	if hash, ok := blockNrOrHash.Hash(); ok {
 		header, err := b.HeaderByHash(ctx, hash)
 		if err != nil {
 			return nil, err
 		}
-
 		if header == nil {
 			return nil, errors.New("header for hash not found")
 		}
-
 		if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(header.Number.Uint64()) != hash {
 			return nil, errors.New("hash is not currently canonical")
 		}
-
 		return header, nil
 	}
-
 	return nil, errors.New("invalid arguments; neither block nor hash specified")
 }
 
@@ -109,7 +102,6 @@ func (b *LesApiBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumbe
 	if header == nil || err != nil {
 		return nil, err
 	}
-
 	return b.BlockByHash(ctx, header.Hash())
 }
 
@@ -121,24 +113,19 @@ func (b *LesApiBackend) BlockByNumberOrHash(ctx context.Context, blockNrOrHash r
 	if blockNr, ok := blockNrOrHash.Number(); ok {
 		return b.BlockByNumber(ctx, blockNr)
 	}
-
 	if hash, ok := blockNrOrHash.Hash(); ok {
 		block, err := b.BlockByHash(ctx, hash)
 		if err != nil {
 			return nil, err
 		}
-
 		if block == nil {
 			return nil, errors.New("header found, but block body is missing")
 		}
-
 		if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(block.NumberU64()) != hash {
 			return nil, errors.New("hash is not currently canonical")
 		}
-
 		return block, nil
 	}
-
 	return nil, errors.New("invalid arguments; neither block nor hash specified")
 }
 
@@ -155,11 +142,9 @@ func (b *LesApiBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.B
 	if err != nil {
 		return nil, nil, err
 	}
-
 	if header == nil {
 		return nil, nil, errors.New("header not found")
 	}
-
 	return light.NewState(ctx, header, b.eth.odr), header, nil
 }
 
@@ -167,20 +152,16 @@ func (b *LesApiBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockN
 	if blockNr, ok := blockNrOrHash.Number(); ok {
 		return b.StateAndHeaderByNumber(ctx, blockNr)
 	}
-
 	if hash, ok := blockNrOrHash.Hash(); ok {
 		header := b.eth.blockchain.GetHeaderByHash(hash)
 		if header == nil {
 			return nil, nil, errors.New("header for hash not found")
 		}
-
 		if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(header.Number.Uint64()) != hash {
 			return nil, nil, errors.New("hash is not currently canonical")
 		}
-
 		return light.NewState(ctx, header, b.eth.odr), header, nil
 	}
-
 	return nil, nil, errors.New("invalid arguments; neither block nor hash specified")
 }
 
@@ -188,7 +169,6 @@ func (b *LesApiBackend) GetReceipts(ctx context.Context, hash common.Hash) (type
 	if number := rawdb.ReadHeaderNumber(b.eth.chainDb, hash); number != nil {
 		return light.GetBlockReceipts(ctx, b.eth.odr, hash, *number)
 	}
-
 	return nil, nil
 }
 
@@ -200,7 +180,6 @@ func (b *LesApiBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int {
 	if number := rawdb.ReadHeaderNumber(b.eth.chainDb, hash); number != nil {
 		return b.eth.blockchain.GetTdOdr(ctx, hash, *number)
 	}
-
 	return nil
 }
 
@@ -208,11 +187,12 @@ func (b *LesApiBackend) GetEVM(ctx context.Context, msg *core.Message, state *st
 	if vmConfig == nil {
 		vmConfig = new(vm.Config)
 	}
-
 	txContext := core.NewEVMTxContext(msg)
 	context := core.NewEVMBlockContext(header, b.eth.blockchain, nil)
-
+	if blockCtx != nil {
-	return vm.NewEVM(context, txContext, state, b.eth.chainConfig, *vmConfig), state.Error, nil
+		context = *blockCtx
+	}
+	return vm.NewEVM(context, txContext, state, b.eth.chainConfig, *vmConfig), state.Error
 }
 
 func (b *LesApiBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
@@ -318,10 +298,6 @@ func (b *LesApiBackend) RPCGasCap() uint64 {
 	return b.eth.config.RPCGasCap
 }
 
-func (b *LesApiBackend) RPCRpcReturnDataLimit() uint64 {
-	return b.eth.config.RPCReturnDataLimit
-}
-
 func (b *LesApiBackend) RPCEVMTimeout() time.Duration {
 	return b.eth.config.RPCEVMTimeout
 }
@@ -334,9 +310,7 @@ func (b *LesApiBackend) BloomStatus() (uint64, uint64) {
 	if b.eth.bloomIndexer == nil {
 		return 0, 0
 	}
-
 	sections, _, _ := b.eth.bloomIndexer.Sections()
-
 	return params.BloomBitsBlocksClient, sections
 }
 
@@ -362,6 +336,10 @@ func (b *LesApiBackend) StateAtTransaction(ctx context.Context, block *types.Blo
 	return b.eth.stateAtTransaction(ctx, block, txIndex, reexec)
 }
 
+func (b *LesApiBackend) RPCRpcReturnDataLimit() uint64 {
+	return b.eth.config.RPCReturnDataLimit
+}
+
 //
 // Bor related functions
 //

les/api_test.go

@@ -96,7 +96,6 @@ func testCapacityAPI(t *testing.T, clientCount int) {
 	if testServerDataDir == "" {
 		return
 	}
-
 	for !testSim(t, 1, clientCount, []string{testServerDataDir}, nil, func(ctx context.Context, net *simulations.Network, servers []*simulations.Node, clients []*simulations.Node) bool {
 		if len(servers) != 1 {
 			t.Fatalf("Invalid number of servers: %d", len(servers))
@@ -307,42 +306,32 @@ func getHead(ctx context.Context, t *testing.T, client *rpc.Client) (uint64, com
 	if err := client.CallContext(ctx, &res, "eth_getBlockByNumber", "latest", false); err != nil {
 		t.Fatalf("Failed to obtain head block: %v", err)
 	}
-
 	numStr, ok := res["number"].(string)
 	if !ok {
 		t.Fatalf("RPC block number field invalid")
 	}
-
 	num, err := hexutil.DecodeUint64(numStr)
 	if err != nil {
 		t.Fatalf("Failed to decode RPC block number: %v", err)
 	}
-
 	hashStr, ok := res["hash"].(string)
 	if !ok {
 		t.Fatalf("RPC block number field invalid")
 	}
-
 	hash := common.HexToHash(hashStr)
-
 	return num, hash
 }
 
 func testRequest(ctx context.Context, t *testing.T, client *rpc.Client) bool {
 	var res string
-
 	var addr common.Address
-
+	crand.Read(addr[:])
-	_, _ = crand.Read(addr[:])
-
 	c, cancel := context.WithTimeout(ctx, time.Second*12)
 	defer cancel()
-
 	err := client.CallContext(c, &res, "eth_getBalance", addr, "latest")
 	if err != nil {
 		t.Log("request error:", err)
 	}
-
 	return err == nil
 }
 
@@ -355,7 +344,6 @@ func freezeClient(ctx context.Context, t *testing.T, server *rpc.Client, clientI
 func setCapacity(ctx context.Context, t *testing.T, server *rpc.Client, clientID enode.ID, cap uint64) {
 	params := make(map[string]interface{})
 	params["capacity"] = cap
-
 	if err := server.CallContext(ctx, nil, "les_setClientParams", []enode.ID{clientID}, []string{}, params); err != nil {
 		t.Fatalf("Failed to set client capacity: %v", err)
 	}
@@ -366,22 +354,18 @@ func getCapacity(ctx context.Context, t *testing.T, server *rpc.Client, clientID
 	if err := server.CallContext(ctx, &res, "les_clientInfo", []enode.ID{clientID}, []string{}); err != nil {
 		t.Fatalf("Failed to get client info: %v", err)
 	}
-
 	info, ok := res[clientID]
 	if !ok {
 		t.Fatalf("Missing client info")
 	}
-
 	v, ok := info["capacity"]
 	if !ok {
 		t.Fatalf("Missing field in client info: capacity")
 	}
-
 	vv, ok := v.(float64)
 	if !ok {
 		t.Fatalf("Failed to decode capacity field")
 	}
-
 	return uint64(vv)
 }
 
@@ -390,23 +374,19 @@ func getCapacityInfo(ctx context.Context, t *testing.T, server *rpc.Client) (min
 	if err := server.CallContext(ctx, &res, "les_serverInfo"); err != nil {
 		t.Fatalf("Failed to query server info: %v", err)
 	}
-
 	decode := func(s string) uint64 {
 		v, ok := res[s]
 		if !ok {
 			t.Fatalf("Missing field in server info: %s", s)
 		}
-
 		vv, ok := v.(float64)
 		if !ok {
 			t.Fatalf("Failed to decode server info field: %s", s)
 		}
-
 		return uint64(vv)
 	}
 	minCap = decode("minimumCapacity")
 	totalCap = decode("totalCapacity")
-
 	return
 }
 
@@ -420,7 +400,6 @@ func NewNetwork() (*simulations.Network, func(), error) {
 	if err != nil {
 		return nil, adapterTeardown, err
 	}
-
 	defaultService := "streamer"
 	net := simulations.NewNetwork(adapter, &simulations.NetworkConfig{
 		ID:             "0",
@@ -430,13 +409,11 @@ func NewNetwork() (*simulations.Network, func(), error) {
 		adapterTeardown()
 		net.Shutdown()
 	}
-
 	return net, teardown, nil
 }
 
 func NewAdapter(adapterType string, services adapters.LifecycleConstructors) (adapter adapters.NodeAdapter, teardown func(), err error) {
 	teardown = func() {}
-
 	switch adapterType {
 	case "sim":
 		adapter = adapters.NewSimAdapter(services)
@@ -447,7 +424,6 @@ func NewAdapter(adapterType string, services adapters.LifecycleConstructors) (ad
 		if err0 != nil {
 			return nil, teardown, err0
 		}
-
 		teardown = func() { os.RemoveAll(baseDir) }
 		adapter = adapters.NewExecAdapter(baseDir)
 	/*case "docker":
@@ -458,20 +434,16 @@ func NewAdapter(adapterType string, services adapters.LifecycleConstructors) (ad
 	default:
 		return nil, teardown, errors.New("adapter needs to be one of sim, socket, exec, docker")
 	}
-
 	return adapter, teardown, nil
 }
 
 func testSim(t *testing.T, serverCount, clientCount int, serverDir, clientDir []string, test func(ctx context.Context, net *simulations.Network, servers []*simulations.Node, clients []*simulations.Node) bool) bool {
 	net, teardown, err := NewNetwork()
 	defer teardown()
-
 	if err != nil {
 		t.Fatalf("Failed to create network: %v", err)
 	}
-
 	timeout := 1800 * time.Second
-
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
@@ -481,32 +453,26 @@ func testSim(t *testing.T, serverCount, clientCount int, serverDir, clientDir []
 	for i := range clients {
 		clientconf := adapters.RandomNodeConfig()
 		clientconf.Lifecycles = []string{"lesclient"}
-
 		if len(clientDir) == clientCount {
 			clientconf.DataDir = clientDir[i]
 		}
-
 		client, err := net.NewNodeWithConfig(clientconf)
 		if err != nil {
 			t.Fatalf("Failed to create client: %v", err)
 		}
-
 		clients[i] = client
 	}
 
 	for i := range servers {
 		serverconf := adapters.RandomNodeConfig()
 		serverconf.Lifecycles = []string{"lesserver"}
-
 		if len(serverDir) == serverCount {
 			serverconf.DataDir = serverDir[i]
 		}
-
 		server, err := net.NewNodeWithConfig(serverconf)
 		if err != nil {
 			t.Fatalf("Failed to create server: %v", err)
 		}
-
 		servers[i] = server
 	}
 
@@ -515,7 +481,6 @@ func testSim(t *testing.T, serverCount, clientCount int, serverDir, clientDir []
 			t.Fatalf("Failed to start client node: %v", err)
 		}
 	}
-
 	for _, server := range servers {
 		if err := net.Start(server.ID()); err != nil {
 			t.Fatalf("Failed to start server node: %v", err)
@@ -527,9 +492,7 @@ func testSim(t *testing.T, serverCount, clientCount int, serverDir, clientDir []
 
 func newLesClientService(ctx *adapters.ServiceContext, stack *node.Node) (node.Lifecycle, error) {
 	config := ethconfig.Defaults
-	config.SyncMode = (ethdownloader.SyncMode)(downloader.LightSync)
+	config.SyncMode = downloader.LightSync
-	config.Ethash.PowMode = ethash.ModeFake
-
 	return New(stack, &config)
 }
 
@@ -538,16 +501,13 @@ func newLesServerService(ctx *adapters.ServiceContext, stack *node.Node) (node.L
 	config.SyncMode = downloader.FullSync
 	config.LightServ = testServerCapacity
 	config.LightPeers = testMaxClients
-
 	ethereum, err := eth.New(stack, &config)
 	if err != nil {
 		return nil, err
 	}
-
 	_, err = NewLesServer(stack, ethereum, &config)
 	if err != nil {
 		return nil, err
 	}
-
 	return ethereum, nil
 }

les/benchmark.go

@@ -20,7 +20,6 @@ import (
 	crand "crypto/rand"
 	"encoding/binary"
 	"errors"
-	"fmt"
 	"math/big"
 	"math/rand"
 	"sync"
@@ -59,22 +58,18 @@ func (b *benchmarkBlockHeaders) init(h *serverHandler, count int) error {
 	d := int64(b.amount-1) * int64(b.skip+1)
 	b.offset = 0
 	b.randMax = h.blockchain.CurrentHeader().Number.Int64() + 1 - d
-
 	if b.randMax < 0 {
 		return errors.New("chain is too short")
 	}
-
 	if b.reverse {
 		b.offset = d
 	}
-
 	if b.byHash {
 		b.hashes = make([]common.Hash, count)
 		for i := range b.hashes {
 			b.hashes[i] = rawdb.ReadCanonicalHash(h.chainDb, uint64(b.offset+rand.Int63n(b.randMax)))
 		}
 	}
-
 	return nil
 }
 
@@ -82,7 +77,6 @@ func (b *benchmarkBlockHeaders) request(peer *serverPeer, index int) error {
 	if b.byHash {
 		return peer.requestHeadersByHash(0, b.hashes[index], b.amount, b.skip, b.reverse)
 	}
-
 	return peer.requestHeadersByNumber(0, uint64(b.offset+rand.Int63n(b.randMax)), b.amount, b.skip, b.reverse)
 }
 
@@ -95,11 +89,9 @@ type benchmarkBodiesOrReceipts struct {
 func (b *benchmarkBodiesOrReceipts) init(h *serverHandler, count int) error {
 	randMax := h.blockchain.CurrentHeader().Number.Int64() + 1
 	b.hashes = make([]common.Hash, count)
-
 	for i := range b.hashes {
 		b.hashes[i] = rawdb.ReadCanonicalHash(h.chainDb, uint64(rand.Int63n(randMax)))
 	}
-
 	return nil
 }
 
@@ -107,7 +99,6 @@ func (b *benchmarkBodiesOrReceipts) request(peer *serverPeer, index int) error {
 	if b.receipts {
 		return peer.requestReceipts(0, []common.Hash{b.hashes[index]})
 	}
-
 	return peer.requestBodies(0, []common.Hash{b.hashes[index]})
 }
 
@@ -124,12 +115,10 @@ func (b *benchmarkProofsOrCode) init(h *serverHandler, count int) error {
 
 func (b *benchmarkProofsOrCode) request(peer *serverPeer, index int) error {
 	key := make([]byte, 32)
-	_, _ = crand.Read(key)
+	crand.Read(key)
-
 	if b.code {
 		return peer.requestCode(0, []CodeReq{{BHash: b.headHash, AccountAddress: key}})
 	}
-
 	return peer.requestProofs(0, []ProofReq{{BHash: b.headHash, Key: key}})
 }
 
@@ -147,11 +136,9 @@ func (b *benchmarkHelperTrie) init(h *serverHandler, count int) error {
 		b.sectionCount, _, _ = h.server.chtIndexer.Sections()
 		b.headNum = b.sectionCount*params.CHTFrequency - 1
 	}
-
 	if b.sectionCount == 0 {
 		return errors.New("no processed sections available")
 	}
-
 	return nil
 }
 
@@ -160,7 +147,6 @@ func (b *benchmarkHelperTrie) request(peer *serverPeer, index int) error {
 
 	if b.bloom {
 		bitIdx := uint16(rand.Intn(2048))
-
 		for i := range reqs {
 			key := make([]byte, 10)
 			binary.BigEndian.PutUint16(key[:2], bitIdx)
@@ -191,16 +177,13 @@ func (b *benchmarkTxSend) init(h *serverHandler, count int) error {
 
 	for i := range b.txs {
 		data := make([]byte, txSizeCostLimit)
-		_, _ = crand.Read(data)
+		crand.Read(data)
-
 		tx, err := types.SignTx(types.NewTransaction(0, addr, new(big.Int), 0, new(big.Int), data), signer, key)
 		if err != nil {
 			panic(err)
 		}
-
 		b.txs[i] = tx
 	}
-
 	return nil
 }
 
@@ -218,9 +201,7 @@ func (b *benchmarkTxStatus) init(h *serverHandler, count int) error {
 
 func (b *benchmarkTxStatus) request(peer *serverPeer, index int) error {
 	var hash common.Hash
-
+	crand.Read(hash[:])
-	_, _ = crand.Read(hash[:])
-
 	return peer.requestTxStatus(0, []common.Hash{hash})
 }
 
@@ -240,13 +221,10 @@ func (h *serverHandler) runBenchmark(benchmarks []requestBenchmark, passCount in
 	for i, b := range benchmarks {
 		setup[i] = &benchmarkSetup{req: b}
 	}
-
 	for i := 0; i < passCount; i++ {
 		log.Info("Running benchmark", "pass", i+1, "total", passCount)
-
 		todo := make([]*benchmarkSetup, len(benchmarks))
 		copy(todo, setup)
-
 		for len(todo) > 0 {
 			// select a random element
 			index := rand.Intn(len(todo))
@@ -260,7 +238,6 @@ func (h *serverHandler) runBenchmark(benchmarks []requestBenchmark, passCount in
 				if next.totalTime > 0 {
 					count = int(uint64(next.totalCount) * uint64(targetTime) / uint64(next.totalTime))
 				}
-
 				if err := h.measure(next, count); err != nil {
 					next.err = err
 				}
@@ -274,7 +251,6 @@ func (h *serverHandler) runBenchmark(benchmarks []requestBenchmark, passCount in
 			s.avgTime = s.totalTime / time.Duration(s.totalCount)
 		}
 	}
-
 	return setup
 }
 
@@ -293,7 +269,6 @@ func (m *meteredPipe) WriteMsg(msg p2p.Msg) error {
 	if msg.Size > m.maxSize {
 		m.maxSize = msg.Size
 	}
-
 	return m.rw.WriteMsg(msg)
 }
 
@@ -303,24 +278,19 @@ func (h *serverHandler) measure(setup *benchmarkSetup, count int) error {
 	clientPipe, serverPipe := p2p.MsgPipe()
 	clientMeteredPipe := &meteredPipe{rw: clientPipe}
 	serverMeteredPipe := &meteredPipe{rw: serverPipe}
-
 	var id enode.ID
-
+	crand.Read(id[:])
-	_, _ = crand.Read(id[:])
 
 	peer1 := newServerPeer(lpv2, NetworkId, false, p2p.NewPeer(id, "client", nil), clientMeteredPipe)
 	peer2 := newClientPeer(lpv2, NetworkId, p2p.NewPeer(id, "server", nil), serverMeteredPipe)
 	peer2.announceType = announceTypeNone
 	peer2.fcCosts = make(requestCostTable)
 	c := &requestCosts{}
-
 	for code := range requests {
 		peer2.fcCosts[code] = c
 	}
-
 	peer2.fcParams = flowcontrol.ServerParams{BufLimit: 1, MinRecharge: 1}
 	peer2.fcClient = flowcontrol.NewClientNode(h.server.fcManager, peer2.fcParams)
-
 	defer peer2.fcClient.Disconnect()
 
 	if err := setup.req.init(h, count); err != nil {
@@ -353,9 +323,7 @@ func (h *serverHandler) measure(setup *benchmarkSetup, count int) error {
 				errCh <- err
 				return
 			}
-
 			var i interface{}
-
 			msg.Decode(&i)
 		}
 		// at this point we can be sure that the other two
@@ -370,17 +338,14 @@ func (h *serverHandler) measure(setup *benchmarkSetup, count int) error {
 	case <-h.closeCh:
 		clientPipe.Close()
 		serverPipe.Close()
-
+		return errors.New("Benchmark cancelled")
-		return fmt.Errorf("Benchmark cancelled")
 	}
 
 	setup.totalTime += time.Duration(mclock.Now() - start)
 	setup.totalCount += count
 	setup.maxInSize = clientMeteredPipe.maxSize
 	setup.maxOutSize = serverMeteredPipe.maxSize
-
 	clientPipe.Close()
 	serverPipe.Close()
-
 	return nil
 }

les/bloombits.go

@@ -47,7 +47,6 @@ func (eth *LightEthereum) startBloomHandlers(sectionSize uint64) {
 	for i := 0; i < bloomServiceThreads; i++ {
 		go func() {
 			defer eth.wg.Done()
-
 			for {
 				select {
 				case <-eth.closeCh:
@@ -57,7 +56,6 @@ func (eth *LightEthereum) startBloomHandlers(sectionSize uint64) {
 					task := <-request
 					task.Bitsets = make([][]byte, len(task.Sections))
 					compVectors, err := light.GetBloomBits(task.Context, eth.odr, task.Bit, task.Sections)
-
 					if err == nil {
 						for i := range task.Sections {
 							if blob, err := bitutil.DecompressBytes(compVectors[i], int(sectionSize/8)); err == nil {

les/client.go

@@ -31,7 +31,6 @@ import (
 	"github.com/ethereum/go-ethereum/core/bloombits"
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/eth/downloader/whitelist"
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/eth/gasprice"
 	"github.com/ethereum/go-ethereum/event"
@@ -88,29 +87,27 @@ func New(stack *node.Node, config *ethconfig.Config) (*LightEthereum, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	lesDb, err := stack.OpenDatabase("les.client", 0, 0, "eth/db/lesclient/", false)
 	if err != nil {
 		return nil, err
 	}
-
 	var overrides core.ChainOverrides
-
+	if config.OverrideCancun != nil {
-	if config.OverrideShanghai != nil {
+		overrides.OverrideCancun = config.OverrideCancun
-		overrides.OverrideShanghai = config.OverrideShanghai
+	}
+	if config.OverrideVerkle != nil {
+		overrides.OverrideVerkle = config.OverrideVerkle
 	}
-
 	chainConfig, genesisHash, genesisErr := core.SetupGenesisBlockWithOverride(chainDb, trie.NewDatabase(chainDb), config.Genesis, &overrides)
 	if _, isCompat := genesisErr.(*params.ConfigCompatError); genesisErr != nil && !isCompat {
 		return nil, genesisErr
 	}
+	engine := ethconfig.CreateConsensusEngine(chainConfig, chainDb)
 	log.Info("")
 	log.Info(strings.Repeat("-", 153))
-
 	for _, line := range strings.Split(chainConfig.Description(), "\n") {
 		log.Info(line)
 	}
-
 	log.Info(strings.Repeat("-", 153))
 	log.Info("")
 
@@ -131,7 +128,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*LightEthereum, error) {
 		reqDist:         newRequestDistributor(peers, &mclock.System{}),
 		accountManager:  stack.AccountManager(),
 		merger:          merger,
-		engine:          ethconfig.CreateConsensusEngine(stack, chainConfig, config, &config.Ethash, chainConfig.Clique, nil, false, chainDb, nil),
+		engine:          engine,
 		bloomRequests:   make(chan chan *bloombits.Retrieval),
 		bloomIndexer:    core.NewBloomIndexer(chainDb, params.BloomBitsBlocksClient, params.HelperTrieConfirmations),
 		p2pServer:       stack.Server(),
@@ -144,8 +141,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*LightEthereum, error) {
 	if leth.udpEnabled {
 		prenegQuery = leth.prenegQuery
 	}
-
+	leth.serverPool, leth.serverPoolIterator = vfc.NewServerPool(lesDb, []byte("serverpool:"), time.Second, prenegQuery, &mclock.System{}, nil, requestList)
-	leth.serverPool, leth.serverPoolIterator = vfc.NewServerPool(lesDb, []byte("serverpool:"), time.Second, prenegQuery, &mclock.System{}, config.UltraLightServers, requestList)
 	leth.serverPool.AddMetrics(suggestedTimeoutGauge, totalValueGauge, serverSelectableGauge, serverConnectedGauge, sessionValueMeter, serverDialedMeter)
 
 	leth.retriever = newRetrieveManager(peers, leth.reqDist, leth.serverPool.GetTimeout)
@@ -158,10 +154,9 @@ func New(stack *node.Node, config *ethconfig.Config) (*LightEthereum, error) {
 
 	// Note: NewLightChain adds the trusted checkpoint so it needs an ODR with
 	// indexers already set but not started yet
-	if leth.blockchain, err = light.NewLightChain(leth.odr, leth.chainConfig, leth.engine, checkpoint, whitelist.NewService(10)); err != nil {
+	if leth.blockchain, err = light.NewLightChain(leth.odr, leth.chainConfig, leth.engine); err != nil {
 		return nil, err
 	}
-
 	leth.chainReader = leth.blockchain
 	leth.txPool = light.NewTxPool(leth.chainConfig, leth.blockchain, leth.relay)
 
@@ -173,23 +168,19 @@ func New(stack *node.Node, config *ethconfig.Config) (*LightEthereum, error) {
 	// Rewind the chain in case of an incompatible config upgrade.
 	if compat, ok := genesisErr.(*params.ConfigCompatError); ok {
 		log.Warn("Rewinding chain to upgrade configuration", "err", compat)
-
 		if compat.RewindToTime > 0 {
-			_ = leth.blockchain.SetHeadWithTimestamp(compat.RewindToTime)
+			leth.blockchain.SetHeadWithTimestamp(compat.RewindToTime)
 		} else {
-			_ = leth.blockchain.SetHead(compat.RewindToBlock)
+			leth.blockchain.SetHead(compat.RewindToBlock)
 		}
-
 		rawdb.WriteChainConfig(chainDb, genesisHash, chainConfig)
 	}
 
 	leth.ApiBackend = &LesApiBackend{stack.Config().ExtRPCEnabled(), stack.Config().AllowUnprotectedTxs, leth, nil}
-
 	gpoParams := config.GPO
 	if gpoParams.Default == nil {
 		gpoParams.Default = config.Miner.GasPrice
 	}
-
 	leth.ApiBackend.gpo = gasprice.NewOracle(leth.ApiBackend, gpoParams)
 
 	leth.handler = newClientHandler(leth)
@@ -211,16 +202,12 @@ func (s *LightEthereum) VfluxRequest(n *enode.Node, reqs vflux.Requests) vflux.R
 	if !s.udpEnabled {
 		return nil
 	}
-
 	reqsEnc, _ := rlp.EncodeToBytes(&reqs)
 	repliesEnc, _ := s.p2pServer.DiscV5.TalkRequest(s.serverPool.DialNode(n), "vfx", reqsEnc)
-
 	var replies vflux.Replies
-
 	if len(repliesEnc) == 0 || rlp.DecodeBytes(repliesEnc, &replies) != nil {
 		return nil
 	}
-
 	return replies
 }
 
@@ -229,11 +216,9 @@ func (s *LightEthereum) VfluxRequest(n *enode.Node, reqs vflux.Requests) vflux.R
 func (s *LightEthereum) vfxVersion(n *enode.Node) uint {
 	if n.Seq() == 0 {
 		var err error
-
 		if !s.udpEnabled {
 			return 0
 		}
-
 		if n, err = s.p2pServer.DiscV5.RequestENR(n); n != nil && err == nil && n.Seq() != 0 {
 			s.serverPool.Persist(n)
 		} else {
@@ -245,11 +230,8 @@ func (s *LightEthereum) vfxVersion(n *enode.Node) uint {
 	if err := n.Load(enr.WithEntry("les", &les)); err != nil || len(les) < 1 {
 		return 0
 	}
-
 	var version uint
-
 	rlp.DecodeBytes(les[0], &version) // Ignore additional fields (for forward compatibility).
-
 	return version
 }
 
@@ -262,24 +244,18 @@ func (s *LightEthereum) prenegQuery(n *enode.Node) int {
 	}
 
 	var requests vflux.Requests
-
 	requests.Add("les", vflux.CapacityQueryName, vflux.CapacityQueryReq{
 		Bias:      180,
 		AddTokens: []vflux.IntOrInf{{}},
 	})
-
 	replies := s.VfluxRequest(n, requests)
-
 	var cqr vflux.CapacityQueryReply
-
 	if replies.Get(0, &cqr) != nil || len(cqr) != 1 { // Note: Get returns an error if replies is nil
 		return -1
 	}
-
 	if cqr[0] > 0 {
 		return 1
 	}
-
 	return 0
 }
 
@@ -310,7 +286,6 @@ func (s *LightDummyAPI) Mining() bool {
 func (s *LightEthereum) APIs() []rpc.API {
 	apis := ethapi.GetAPIs(s.ApiBackend)
 	apis = append(apis, s.engine.APIs(s.BlockChain().HeaderChain())...)
-
 	return append(apis, []rpc.API{
 		{
 			Namespace: "eth",
@@ -342,7 +317,6 @@ func (s *LightEthereum) Protocols() []p2p.Protocol {
 		if p := s.peers.peer(id.String()); p != nil {
 			return p.Info()
 		}
-
 		return nil
 	}, s.serverPoolIterator)
 }
@@ -357,15 +331,12 @@ func (s *LightEthereum) Start() error {
 
 	if s.udpEnabled && s.p2pServer.DiscV5 == nil {
 		s.udpEnabled = false
-
 		log.Error("Discovery v5 is not initialized")
 	}
-
 	discovery, err := s.setupDiscovery()
 	if err != nil {
 		return err
 	}
-
 	s.serverPool.AddSource(discovery)
 	s.serverPool.Start()
 	// Start bloom request workers.
@@ -398,6 +369,5 @@ func (s *LightEthereum) Stop() error {
 	s.lesDb.Close()
 	s.wg.Wait()
 	log.Info("Light ethereum stopped")
-
 	return nil
 }

les/costtracker.go

@@ -145,36 +145,28 @@ func newCostTracker(db ethdb.Database, config *ethconfig.Config) (*costTracker,
 		reqInfoCh:  make(chan reqInfo, 100),
 		utilTarget: utilTarget,
 	}
-
 	if config.LightIngress > 0 {
 		ct.inSizeFactor = utilTarget / float64(config.LightIngress)
 	}
-
 	if config.LightEgress > 0 {
 		ct.outSizeFactor = utilTarget / float64(config.LightEgress)
 	}
-
 	if makeCostStats {
 		ct.stats = make(map[uint64][]uint64)
 		for code := range reqAvgTimeCost {
 			ct.stats[code] = make([]uint64, 10)
 		}
 	}
-
 	ct.gfLoop()
-
 	costList := ct.makeCostList(ct.globalFactor() * 1.25)
 	for _, c := range costList {
 		amount := minBufferReqAmount[c.MsgCode]
-
 		cost := c.BaseCost + amount*c.ReqCost
 		if cost > ct.minBufLimit {
 			ct.minBufLimit = cost
 		}
 	}
-
 	ct.minBufLimit *= uint64(minBufferMultiplier)
-
 	return ct, (ct.minBufLimit-1)/bufLimitRatio + 1
 }
 
@@ -183,7 +175,6 @@ func (ct *costTracker) stop() {
 	stopCh := make(chan struct{})
 	ct.stopCh <- stopCh
 	<-stopCh
-
 	if makeCostStats {
 		ct.printStats()
 	}
@@ -195,25 +186,19 @@ func (ct *costTracker) makeCostList(globalFactor float64) RequestCostList {
 	maxCost := func(avgTimeCost, inSize, outSize uint64) uint64 {
 		cost := avgTimeCost * maxCostFactor
 		inSizeCost := uint64(float64(inSize) * ct.inSizeFactor * globalFactor)
-
 		if inSizeCost > cost {
 			cost = inSizeCost
 		}
-
 		outSizeCost := uint64(float64(outSize) * ct.outSizeFactor * globalFactor)
 		if outSizeCost > cost {
 			cost = outSizeCost
 		}
-
 		return cost
 	}
-
 	var list RequestCostList
-
 	for code, data := range reqAvgTimeCost {
 		baseCost := maxCost(data.baseCost, reqMaxInSize[code].baseCost, reqMaxOutSize[code].baseCost)
 		reqCost := maxCost(data.reqCost, reqMaxInSize[code].reqCost, reqMaxOutSize[code].reqCost)
-
 		if ct.minBufLimit != 0 {
 			// if minBufLimit is set then always enforce maximum request cost <= minBufLimit
 			maxCost := baseCost + reqCost*minBufferReqAmount[code]
@@ -230,7 +215,6 @@ func (ct *costTracker) makeCostList(globalFactor float64) RequestCostList {
 			ReqCost:  reqCost,
 		})
 	}
-
 	return list
 }
 
@@ -270,7 +254,6 @@ func (ct *costTracker) gfLoop() {
 	if len(data) == 8 {
 		gfLog = math.Float64frombits(binary.BigEndian.Uint64(data[:]))
 	}
-
 	ct.factor = math.Exp(gfLog)
 	factor, totalRecharge = ct.factor, ct.utilTarget*ct.factor
 
@@ -281,12 +264,10 @@ func (ct *costTracker) gfLoop() {
 	go func() {
 		saveCostFactor := func() {
 			var data [8]byte
-
 			binary.BigEndian.PutUint64(data[:], math.Float64bits(gfLog))
 			ct.db.Put([]byte(gfDbKey), data[:])
 			log.Debug("global cost factor saved", "value", factor)
 		}
-
 		saveTicker := time.NewTicker(time.Minute * 10)
 		defer saveTicker.Stop()
 
@@ -325,7 +306,6 @@ func (ct *costTracker) gfLoop() {
 				if r.msgCode == SendTxV2Msg || r.msgCode == GetTxStatusMsg {
 					continue
 				}
-
 				requestServedMeter.Mark(int64(r.servingTime))
 				requestServedTimer.Update(time.Duration(r.servingTime))
 				requestEstimatedMeter.Mark(int64(r.avgTimeCost / factor))
@@ -339,7 +319,6 @@ func (ct *costTracker) gfLoop() {
 
 				// calculate factor correction until now, based on previous values
 				var gfCorr float64
-
 				max := recentTime
 				if recentAvg > max {
 					max = recentAvg
@@ -376,19 +355,16 @@ func (ct *costTracker) gfLoop() {
 						ct.factor = factor
 						ch := ct.totalRechargeCh
 						ct.gfLock.Unlock()
-
 						if ch != nil {
 							select {
 							case ct.totalRechargeCh <- uint64(totalRecharge):
 							default:
 							}
 						}
-
 						globalFactorGauge.Update(int64(1000 * factor))
 						log.Debug("global cost factor updated", "factor", factor)
 					}
 				}
-
 				recentServedGauge.Update(int64(recentTime))
 				recentEstimatedGauge.Update(int64(recentAvg))
 
@@ -398,7 +374,6 @@ func (ct *costTracker) gfLoop() {
 			case stopCh := <-ct.stopCh:
 				saveCostFactor()
 				close(stopCh)
-
 				return
 			}
 		}
@@ -429,7 +404,6 @@ func (ct *costTracker) subscribeTotalRecharge(ch chan uint64) uint64 {
 	defer ct.gfLock.Unlock()
 
 	ct.totalRechargeCh = ch
-
 	return uint64(ct.factor * ct.utilTarget)
 }
 
@@ -442,11 +416,9 @@ func (ct *costTracker) updateStats(code, amount, servingTime, realCost uint64) {
 	case ct.reqInfoCh <- reqInfo{float64(avgTimeCost), float64(servingTime), code}:
 	default:
 	}
-
 	if makeCostStats {
 		realCost <<= 4
 		l := 0
-
 		for l < 9 && realCost > avgTimeCost {
 			l++
 			realCost >>= 1
@@ -466,16 +438,13 @@ func (ct *costTracker) updateStats(code, amount, servingTime, realCost uint64) {
 func (ct *costTracker) realCost(servingTime uint64, inSize, outSize uint32) uint64 {
 	cost := float64(servingTime)
 	inSizeCost := float64(inSize) * ct.inSizeFactor
-
 	if inSizeCost > cost {
 		cost = inSizeCost
 	}
-
 	outSizeCost := float64(outSize) * ct.outSizeFactor
 	if outSizeCost > cost {
 		cost = outSizeCost
 	}
-
 	return uint64(cost * ct.globalFactor())
 }
 
@@ -484,7 +453,6 @@ func (ct *costTracker) printStats() {
 	if ct.stats == nil {
 		return
 	}
-
 	for code, arr := range ct.stats {
 		log.Info("Request cost statistics", "code", code, "1/16", arr[0], "1/8", arr[1], "1/4", arr[2], "1/2", arr[3], "1", arr[4], "2", arr[5], "4", arr[6], "8", arr[7], "16", arr[8], ">16", arr[9])
 	}
@@ -516,7 +484,6 @@ func (table requestCostTable) getMaxCost(code, amount uint64) uint64 {
 // decode converts a cost list to a cost table
 func (list RequestCostList) decode(protocolLength uint64) requestCostTable {
 	table := make(requestCostTable)
-
 	for _, e := range list {
 		if e.MsgCode < protocolLength {
 			table[e.MsgCode] = &requestCosts{
@@ -525,23 +492,19 @@ func (list RequestCostList) decode(protocolLength uint64) requestCostTable {
 			}
 		}
 	}
-
 	return table
 }
 
 // testCostList returns a dummy request cost list used by tests
 func testCostList(testCost uint64) RequestCostList {
 	cl := make(RequestCostList, len(reqAvgTimeCost))
-
 	var max uint64
 	for code := range reqAvgTimeCost {
 		if code > max {
 			max = code
 		}
 	}
-
 	i := 0
-
 	for code := uint64(0); code <= max; code++ {
 		if _, ok := reqAvgTimeCost[code]; ok {
 			cl[i].MsgCode = code
@@ -550,6 +513,5 @@ func testCostList(testCost uint64) RequestCostList {
 			i++
 		}
 	}
-
 	return cl
 }

les/distributor.go

@@ -85,11 +85,8 @@ func newRequestDistributor(peers *serverPeerSet, clock mclock.Clock) *requestDis
 	if peers != nil {
 		peers.subscribe(d)
 	}
-
 	d.wg.Add(1)
-
 	go d.loop()
-
 	return d
 }
 
@@ -127,12 +124,10 @@ var (
 // main event loop
 func (d *requestDistributor) loop() {
 	defer d.wg.Done()
-
 	for {
 		select {
 		case <-d.closeCh:
 			d.lock.Lock()
-
 			elem := d.reqQueue.Front()
 			for elem != nil {
 				req := elem.Value.(*distReq)
@@ -141,7 +136,6 @@ func (d *requestDistributor) loop() {
 				elem = elem.Next()
 			}
 			d.lock.Unlock()
-
 			return
 		case <-d.loopChn:
 			d.lock.Lock()
@@ -198,7 +192,6 @@ func selectPeerWeight(i interface{}) uint64 {
 func (d *requestDistributor) nextRequest() (distPeer, *distReq, time.Duration) {
 	checkedPeers := make(map[distPeer]struct{})
 	elem := d.reqQueue.Front()
-
 	var (
 		bestWait time.Duration
 		sel      *utils.WeightedRandomSelect
@@ -212,45 +205,36 @@ func (d *requestDistributor) nextRequest() (distPeer, *distReq, time.Duration) {
 		req := elem.Value.(*distReq)
 		canSend := false
 		now := d.clock.Now()
-
 		if req.waitForPeers > now {
 			canSend = true
-
 			wait := time.Duration(req.waitForPeers - now)
 			if bestWait == 0 || wait < bestWait {
 				bestWait = wait
 			}
 		}
-
 		for peer := range d.peers {
 			if _, ok := checkedPeers[peer]; !ok && peer.canQueue() && req.canSend(peer) {
 				canSend = true
 				cost := req.getCost(peer)
-
 				wait, bufRemain := peer.waitBefore(cost)
 				if wait == 0 {
 					if sel == nil {
 						sel = utils.NewWeightedRandomSelect(selectPeerWeight)
 					}
-
 					sel.Update(selectPeerItem{peer: peer, req: req, weight: uint64(bufRemain*1000000) + 1})
 				} else {
 					if bestWait == 0 || wait < bestWait {
 						bestWait = wait
 					}
 				}
-
 				checkedPeers[peer] = struct{}{}
 			}
 		}
-
 		next := elem.Next()
-
 		if !canSend && elem == d.reqQueue.Front() {
 			close(req.sentChn)
 			d.remove(req)
 		}
-
 		elem = next
 	}
 
@@ -258,7 +242,6 @@ func (d *requestDistributor) nextRequest() (distPeer, *distReq, time.Duration) {
 		c := sel.Choose().(selectPeerItem)
 		return c.peer, c.req, 0
 	}
-
 	return nil, nil, bestWait
 }
 
@@ -287,7 +270,6 @@ func (d *requestDistributor) queue(r *distReq) chan distPeer {
 		for before.Value.(*distReq).reqOrder < r.reqOrder {
 			before = before.Next()
 		}
-
 		r.element = d.reqQueue.InsertBefore(r, before)
 	}
 
@@ -297,7 +279,6 @@ func (d *requestDistributor) queue(r *distReq) chan distPeer {
 	}
 
 	r.sentChn = make(chan distPeer, 1)
-
 	return r.sentChn
 }
 
@@ -314,7 +295,6 @@ func (d *requestDistributor) cancel(r *distReq) bool {
 
 	close(r.sentChn)
 	d.remove(r)
-
 	return true
 }
 

les/distributor_test.go

@@ -59,24 +59,19 @@ func (p *testDistPeer) send(r *testDistReq) {
 
 func (p *testDistPeer) worker(t *testing.T, checkOrder bool, stop chan struct{}) {
 	var last uint64
-
 	for {
 		wait := time.Millisecond
-
 		p.lock.Lock()
 		if len(p.sent) > 0 {
 			rq := p.sent[0]
 			wait = time.Duration(rq.procTime)
 			p.sumCost -= rq.cost
-
 			if checkOrder {
 				if rq.order <= last {
 					t.Errorf("Requests processed in wrong order")
 				}
-
 				last = rq.order
 			}
-
 			p.sent = p.sent[1:]
 		}
 		p.lock.Unlock()
@@ -100,11 +95,9 @@ func (p *testDistPeer) waitBefore(cost uint64) (time.Duration, float64) {
 	p.lock.RLock()
 	sumCost := p.sumCost + cost
 	p.lock.RUnlock()
-
 	if sumCost < testDistBufLimit {
 		return 0, float64(testDistBufLimit-sumCost) / float64(testDistBufLimit)
 	}
-
 	return time.Duration(sumCost - testDistBufLimit), 0
 }
 
@@ -130,7 +123,6 @@ func testRequestDistributor(t *testing.T, resend bool) {
 	defer close(stop)
 
 	dist := newRequestDistributor(nil, &mclock.System{})
-
 	var peers [testDistPeerCount]*testDistPeer
 	for i := range peers {
 		peers[i] = &testDistPeer{}
@@ -152,7 +144,6 @@ func testRequestDistributor(t *testing.T, resend bool) {
 			order:     uint64(i),
 			canSendTo: make(map[*testDistPeer]struct{}),
 		}
-
 		for _, peer := range peers {
 			if rand.Intn(2) != 0 {
 				rq.canSendTo[peer] = struct{}{}
@@ -160,25 +151,21 @@ func testRequestDistributor(t *testing.T, resend bool) {
 		}
 
 		wg.Add(1)
-
 		req := &distReq{
 			getCost: rq.getCost,
 			canSend: rq.canSend,
 			request: rq.request,
 		}
 		chn := dist.queue(req)
-
 		go func() {
 			cnt := 1
 			if resend && len(rq.canSendTo) != 0 {
 				cnt = rand.Intn(testDistMaxResendCount) + 1
 			}
-
 			for i := 0; i < cnt; i++ {
 				if i != 0 {
 					chn = dist.queue(req)
 				}
-
 				p := <-chn
 				if p == nil {
 					if len(rq.canSendTo) != 0 {
@@ -193,7 +180,6 @@ func testRequestDistributor(t *testing.T, resend bool) {
 			}
 			wg.Done()
 		}()
-
 		if rand.Intn(1000) == 0 {
 			time.Sleep(time.Duration(rand.Intn(5000000)))
 		}

les/enr_entry.go

@@ -47,12 +47,10 @@ func (eth *LightEthereum) setupDiscovery() (enode.Iterator, error) {
 	// Enable DNS discovery.
 	if len(eth.config.EthDiscoveryURLs) != 0 {
 		client := dnsdisc.NewClient(dnsdisc.Config{})
-
 		dns, err := client.NewIterator(eth.config.EthDiscoveryURLs...)
 		if err != nil {
 			return nil, err
 		}
-
 		it.AddSource(dns)
 	}
 
@@ -63,15 +61,12 @@ func (eth *LightEthereum) setupDiscovery() (enode.Iterator, error) {
 
 	forkFilter := forkid.NewFilter(eth.blockchain)
 	iterator := enode.Filter(it, func(n *enode.Node) bool { return nodeIsServer(forkFilter, n) })
-
 	return iterator, nil
 }
 
 // nodeIsServer checks whether n is an LES server node.
 func nodeIsServer(forkFilter forkid.Filter, n *enode.Node) bool {
 	var les lesEntry
-
 	var eth ethEntry
-
 	return n.Load(&les) == nil && n.Load(&eth) == nil && forkFilter(eth.ForkID) == nil
 }

les/flowcontrol/control.go

@@ -82,9 +82,7 @@ func NewClientNode(cm *ClientManager, params ServerParams) *ClientNode {
 	if keepLogs > 0 {
 		node.log = newLogger(keepLogs)
 	}
-
 	cm.connect(node)
-
 	return node
 }
 
@@ -105,16 +103,13 @@ func (node *ClientNode) BufferStatus() (uint64, uint64) {
 	if !node.connected {
 		return 0, 0
 	}
-
 	now := node.cm.clock.Now()
 	node.update(now)
 	node.cm.updateBuffer(node, 0, now)
-
 	bv := node.bufValue
 	if bv < 0 {
 		bv = 0
 	}
-
 	return uint64(bv), node.params.BufLimit
 }
 
@@ -159,16 +154,13 @@ func (node *ClientNode) recalcBV(now mclock.AbsTime) {
 	if now < node.lastTime {
 		dt = 0
 	}
-
 	node.bufValue += int64(node.params.MinRecharge * dt / uint64(fcTimeConst))
 	if node.bufValue > int64(node.params.BufLimit) {
 		node.bufValue = int64(node.params.BufLimit)
 	}
-
 	if node.log != nil {
 		node.log.add(now, fmt.Sprintf("updated  bv=%d  MRR=%d  BufLimit=%d", node.bufValue, node.params.MinRecharge, node.params.BufLimit))
 	}
-
 	node.lastTime = now
 }
 
@@ -179,7 +171,6 @@ func (node *ClientNode) UpdateParams(params ServerParams) {
 
 	now := node.cm.clock.Now()
 	node.update(now)
-
 	if params.MinRecharge >= node.params.MinRecharge {
 		node.updateSchedule = nil
 		node.updateParams(params, now)
@@ -188,11 +179,9 @@ func (node *ClientNode) UpdateParams(params ServerParams) {
 			if params.MinRecharge >= s.params.MinRecharge {
 				s.params = params
 				node.updateSchedule = node.updateSchedule[:i+1]
-
 				return
 			}
 		}
-
 		node.updateSchedule = append(node.updateSchedule, scheduledUpdate{time: now.Add(DecParamDelay), params: params})
 	}
 }
@@ -205,7 +194,6 @@ func (node *ClientNode) updateParams(params ServerParams, now mclock.AbsTime) {
 	} else if node.bufValue > int64(params.BufLimit) {
 		node.bufValue = int64(params.BufLimit)
 	}
-
 	node.cm.updateParams(node, params, now)
 }
 
@@ -218,25 +206,19 @@ func (node *ClientNode) AcceptRequest(reqID, index, maxCost uint64) (accepted bo
 
 	now := node.cm.clock.Now()
 	node.update(now)
-
 	if int64(maxCost) > node.bufValue {
 		if node.log != nil {
 			node.log.add(now, fmt.Sprintf("rejected  reqID=%d  bv=%d  maxCost=%d", reqID, node.bufValue, maxCost))
 			node.log.dump(now)
 		}
-
 		return false, maxCost - uint64(node.bufValue), 0
 	}
-
 	node.bufValue -= int64(maxCost)
 	node.sumCost += maxCost
-
 	if node.log != nil {
 		node.log.add(now, fmt.Sprintf("accepted  reqID=%d  bv=%d  maxCost=%d  sumCost=%d", reqID, node.bufValue, maxCost, node.sumCost))
 	}
-
 	node.accepted[index] = node.sumCost
-
 	return true, 0, node.cm.accepted(node, maxCost, now)
 }
 
@@ -248,18 +230,14 @@ func (node *ClientNode) RequestProcessed(reqID, index, maxCost, realCost uint64)
 	now := node.cm.clock.Now()
 	node.update(now)
 	node.cm.processed(node, maxCost, realCost, now)
-
 	bv := node.bufValue + int64(node.sumCost-node.accepted[index])
 	if node.log != nil {
 		node.log.add(now, fmt.Sprintf("processed  reqID=%d  bv=%d  maxCost=%d  realCost=%d  sumCost=%d  oldSumCost=%d  reportedBV=%d", reqID, node.bufValue, maxCost, realCost, node.sumCost, node.accepted[index], bv))
 	}
-
 	delete(node.accepted, index)
-
 	if bv < 0 {
 		return 0
 	}
-
 	return uint64(bv)
 }
 
@@ -290,7 +268,6 @@ func NewServerNode(params ServerParams, clock mclock.Clock) *ServerNode {
 	if keepLogs > 0 {
 		node.log = newLogger(keepLogs)
 	}
-
 	return node
 }
 
@@ -300,7 +277,6 @@ func (node *ServerNode) UpdateParams(params ServerParams) {
 	defer node.lock.Unlock()
 
 	node.recalcBLE(mclock.Now())
-
 	if params.BufLimit > node.params.BufLimit {
 		node.bufEstimate += params.BufLimit - node.params.BufLimit
 	} else {
@@ -308,7 +284,6 @@ func (node *ServerNode) UpdateParams(params ServerParams) {
 			node.bufEstimate = params.BufLimit
 		}
 	}
-
 	node.params = params
 }
 
@@ -318,17 +293,14 @@ func (node *ServerNode) recalcBLE(now mclock.AbsTime) {
 	if now < node.lastTime {
 		return
 	}
-
 	if node.bufRecharge {
 		dt := uint64(now - node.lastTime)
-
 		node.bufEstimate += node.params.MinRecharge * dt / uint64(fcTimeConst)
 		if node.bufEstimate >= node.params.BufLimit {
 			node.bufEstimate = node.params.BufLimit
 			node.bufRecharge = false
 		}
 	}
-
 	node.lastTime = now
 	if node.log != nil {
 		node.log.add(now, fmt.Sprintf("updated  bufEst=%d  MRR=%d  BufLimit=%d", node.bufEstimate, node.params.MinRecharge, node.params.BufLimit))
@@ -348,29 +320,23 @@ func (node *ServerNode) CanSend(maxCost uint64) (time.Duration, float64) {
 	if node.params.BufLimit == 0 {
 		return time.Duration(math.MaxInt64), 0
 	}
-
 	now := node.clock.Now()
 	node.recalcBLE(now)
-
 	maxCost += uint64(safetyMargin) * node.params.MinRecharge / uint64(fcTimeConst)
 	if maxCost > node.params.BufLimit {
 		maxCost = node.params.BufLimit
 	}
-
 	if node.bufEstimate >= maxCost {
 		relBuf := float64(node.bufEstimate-maxCost) / float64(node.params.BufLimit)
 		if node.log != nil {
 			node.log.add(now, fmt.Sprintf("canSend  bufEst=%d  maxCost=%d  true  relBuf=%f", node.bufEstimate, maxCost, relBuf))
 		}
-
 		return 0, relBuf
 	}
-
 	timeLeft := time.Duration((maxCost - node.bufEstimate) * uint64(fcTimeConst) / node.params.MinRecharge)
 	if node.log != nil {
 		node.log.add(now, fmt.Sprintf("canSend  bufEst=%d  maxCost=%d  false  timeLeft=%v", node.bufEstimate, maxCost, timeLeft))
 	}
-
 	return timeLeft, 0
 }
 
@@ -390,13 +356,10 @@ func (node *ServerNode) QueuedRequest(reqID, maxCost uint64) {
 		node.bufEstimate -= maxCost
 	} else {
 		log.Error("Queued request with insufficient buffer estimate")
-
 		node.bufEstimate = 0
 	}
-
 	node.sumCost += maxCost
 	node.pending[reqID] = node.sumCost
-
 	if node.log != nil {
 		node.log.add(now, fmt.Sprintf("queued  reqID=%d  bufEst=%d  maxCost=%d  sumCost=%d", reqID, node.bufEstimate, maxCost, node.sumCost))
 	}
@@ -410,24 +373,19 @@ func (node *ServerNode) ReceivedReply(reqID, bv uint64) {
 
 	now := node.clock.Now()
 	node.recalcBLE(now)
-
 	if bv > node.params.BufLimit {
 		bv = node.params.BufLimit
 	}
-
 	sc, ok := node.pending[reqID]
 	if !ok {
 		return
 	}
-
 	delete(node.pending, reqID)
 	cc := node.sumCost - sc
 	newEstimate := uint64(0)
-
 	if bv > cc {
 		newEstimate = bv - cc
 	}
-
 	if newEstimate > node.bufEstimate {
 		// Note: we never reduce the buffer estimate based on the reported value because
 		// this can only happen because of the delayed delivery of the latest reply.
@@ -437,7 +395,6 @@ func (node *ServerNode) ReceivedReply(reqID, bv uint64) {
 
 	node.bufRecharge = node.bufEstimate < node.params.BufLimit
 	node.lastTime = now
-
 	if node.log != nil {
 		node.log.add(now, fmt.Sprintf("received  reqID=%d  bufEst=%d  reportedBv=%d  sumCost=%d  oldSumCost=%d", reqID, node.bufEstimate, bv, node.sumCost, sc))
 	}
@@ -452,18 +409,14 @@ func (node *ServerNode) ResumeFreeze(bv uint64) {
 	for reqID := range node.pending {
 		delete(node.pending, reqID)
 	}
-
 	now := node.clock.Now()
 	node.recalcBLE(now)
-
 	if bv > node.params.BufLimit {
 		bv = node.params.BufLimit
 	}
-
 	node.bufEstimate = bv
 	node.bufRecharge = node.bufEstimate < node.params.BufLimit
 	node.lastTime = now
-
 	if node.log != nil {
 		node.log.add(now, fmt.Sprintf("unfreeze  bv=%d  sumCost=%d", bv, node.sumCost))
 	}

les/flowcontrol/logger.go

@@ -50,10 +50,8 @@ func (l *logger) add(now mclock.AbsTime, event string) {
 	keepAfter := now - mclock.AbsTime(l.keep)
 	for l.delPtr < l.writePtr && l.events[l.delPtr].time <= keepAfter {
 		delete(l.events, l.delPtr)
-
 		l.delPtr++
 	}
-
 	l.events[l.writePtr] = logEvent{now, event}
 	l.writePtr++
 }

les/flowcontrol/manager.go

@@ -115,7 +115,6 @@ func NewClientManager(curve PieceWiseLinear, clock mclock.Clock) *ClientManager
 	if curve != nil {
 		cm.SetRechargeCurve(curve)
 	}
-
 	go func() {
 		// regularly recalculate and update total capacity
 		for {
@@ -130,7 +129,6 @@ func NewClientManager(curve PieceWiseLinear, clock mclock.Clock) *ClientManager
 			}
 		}
 	}()
-
 	return cm
 }
 
@@ -148,7 +146,6 @@ func (cm *ClientManager) SetRechargeCurve(curve PieceWiseLinear) {
 
 	now := cm.clock.Now()
 	cm.updateRecharge(now)
-
 	cm.curve = curve
 	if len(curve) > 0 {
 		cm.totalRecharge = curve[len(curve)-1].Y
@@ -165,13 +162,10 @@ func (cm *ClientManager) SetCapacityLimits(min, max, raiseThreshold uint64) {
 	if min < 1 {
 		min = 1
 	}
-
 	cm.minLogTotalCap = math.Log(float64(min))
-
 	if max < 1 {
 		max = 1
 	}
-
 	cm.maxLogTotalCap = math.Log(float64(max))
 	cm.logTotalCap = cm.maxLogTotalCap
 	cm.capacityRaiseThreshold = raiseThreshold
@@ -186,11 +180,9 @@ func (cm *ClientManager) connect(node *ClientNode) {
 
 	now := cm.clock.Now()
 	cm.updateRecharge(now)
-
 	node.corrBufValue = int64(node.params.BufLimit)
 	node.rcLastIntValue = cm.rcLastIntValue
 	node.queueIndex = -1
-
 	cm.updateTotalCapacity(now, true)
 	cm.totalConnected += node.params.MinRecharge
 	cm.updateRaiseLimit()
@@ -218,7 +210,6 @@ func (cm *ClientManager) accepted(node *ClientNode, maxCost uint64, now mclock.A
 
 	cm.updateNodeRc(node, -int64(maxCost), &node.params, now)
 	rcTime := (node.params.BufLimit - uint64(node.corrBufValue)) * FixedPointMultiplier / node.params.MinRecharge
-
 	return -int64(now) - int64(rcTime)
 }
 
@@ -230,7 +221,6 @@ func (cm *ClientManager) processed(node *ClientNode, maxCost, realCost uint64, n
 	if realCost > maxCost {
 		realCost = maxCost
 	}
-
 	cm.updateBuffer(node, int64(maxCost-realCost), now)
 }
 
@@ -241,12 +231,10 @@ func (cm *ClientManager) updateBuffer(node *ClientNode, add int64, now mclock.Ab
 	defer cm.lock.Unlock()
 
 	cm.updateNodeRc(node, add, &node.params, now)
-
 	if node.corrBufValue > node.bufValue {
 		if node.log != nil {
 			node.log.add(now, fmt.Sprintf("corrected  bv=%d  oldBv=%d", node.corrBufValue, node.bufValue))
 		}
-
 		node.bufValue = node.corrBufValue
 	}
 }
@@ -270,18 +258,14 @@ func (cm *ClientManager) updateRaiseLimit() {
 		cm.logTotalCapRaiseLimit = 0
 		return
 	}
-
 	limit := float64(cm.totalConnected + cm.capacityRaiseThreshold)
 	limit2 := float64(cm.totalConnected) * capacityRaiseThresholdRatio
-
 	if limit2 > limit {
 		limit = limit2
 	}
-
 	if limit < 1 {
 		limit = 1
 	}
-
 	cm.logTotalCapRaiseLimit = math.Log(limit)
 }
 
@@ -297,15 +281,12 @@ func (cm *ClientManager) updateRecharge(now mclock.AbsTime) {
 		if sumRecharge > cm.totalRecharge {
 			sumRecharge = cm.totalRecharge
 		}
-
 		bonusRatio := float64(1)
 		v := cm.curve.ValueAt(sumRecharge)
 		s := float64(sumRecharge)
-
 		if v > s && s > 0 {
 			bonusRatio = v / s
 		}
-
 		dt := now - lastUpdate
 		// fetch the client that finishes first
 		rcqNode := cm.rcQueue.PopItem() // if sumRecharge > 0 then the queue cannot be empty
@@ -316,17 +297,14 @@ func (cm *ClientManager) updateRecharge(now mclock.AbsTime) {
 			// to current bonusRatio and return
 			cm.addToQueue(rcqNode)
 			cm.rcLastIntValue += int64(bonusRatio * float64(dt))
-
 			return
 		}
-
 		lastUpdate += dtNext
 		// finished recharging, update corrBufValue and sumRecharge if necessary and do next step
 		if rcqNode.corrBufValue < int64(rcqNode.params.BufLimit) {
 			rcqNode.corrBufValue = int64(rcqNode.params.BufLimit)
 			cm.sumRecharge -= rcqNode.params.MinRecharge
 		}
-
 		cm.rcLastIntValue = rcqNode.rcFullIntValue
 	}
 }
@@ -336,15 +314,12 @@ func (cm *ClientManager) addToQueue(node *ClientNode) {
 		cm.priorityOffset += 0x4000000000000000
 		// recreate priority queue with new offset to avoid overflow; should happen very rarely
 		newRcQueue := prque.New[int64, *ClientNode](func(a *ClientNode, i int) { a.queueIndex = i })
-
 		for cm.rcQueue.Size() > 0 {
 			n := cm.rcQueue.PopItem()
 			newRcQueue.Push(n, cm.priorityOffset-n.rcFullIntValue)
 		}
-
 		cm.rcQueue = newRcQueue
 	}
-
 	cm.rcQueue.Push(node, cm.priorityOffset-node.rcFullIntValue)
 }
 
@@ -352,47 +327,36 @@ func (cm *ClientManager) addToQueue(node *ClientNode) {
 // It also adds or removes the rcQueue entry and updates ServerParams and sumRecharge if necessary.
 func (cm *ClientManager) updateNodeRc(node *ClientNode, bvc int64, params *ServerParams, now mclock.AbsTime) {
 	cm.updateRecharge(now)
-
 	wasFull := true
 	if node.corrBufValue != int64(node.params.BufLimit) {
 		wasFull = false
-
 		node.corrBufValue += (cm.rcLastIntValue - node.rcLastIntValue) * int64(node.params.MinRecharge) / FixedPointMultiplier
 		if node.corrBufValue > int64(node.params.BufLimit) {
 			node.corrBufValue = int64(node.params.BufLimit)
 		}
-
 		node.rcLastIntValue = cm.rcLastIntValue
 	}
-
 	node.corrBufValue += bvc
 	diff := int64(params.BufLimit - node.params.BufLimit)
-
 	if diff > 0 {
 		node.corrBufValue += diff
 	}
-
 	isFull := false
-
 	if node.corrBufValue >= int64(params.BufLimit) {
 		node.corrBufValue = int64(params.BufLimit)
 		isFull = true
 	}
-
 	if !wasFull {
 		cm.sumRecharge -= node.params.MinRecharge
 	}
-
 	if params != &node.params {
 		node.params = *params
 	}
-
 	if !isFull {
 		cm.sumRecharge += node.params.MinRecharge
 		if node.queueIndex != -1 {
 			cm.rcQueue.Remove(node.queueIndex)
 		}
-
 		node.rcLastIntValue = cm.rcLastIntValue
 		node.rcFullIntValue = cm.rcLastIntValue + (int64(node.params.BufLimit)-node.corrBufValue)*FixedPointMultiplier/int64(node.params.MinRecharge)
 		cm.addToQueue(node)
@@ -408,15 +372,12 @@ func (cm *ClientManager) reduceTotalCapacity(frozenCap uint64) {
 	if frozenCap < cm.totalConnected {
 		ratio = float64(frozenCap) / float64(cm.totalConnected)
 	}
-
 	now := cm.clock.Now()
 	cm.updateTotalCapacity(now, false)
-
 	cm.logTotalCap -= capacityDropFactor * ratio
 	if cm.logTotalCap < cm.minLogTotalCap {
 		cm.logTotalCap = cm.minLogTotalCap
 	}
-
 	cm.updateTotalCapacity(now, true)
 }
 
@@ -436,11 +397,9 @@ func (cm *ClientManager) updateTotalCapacity(now mclock.AbsTime, refresh bool) {
 			cm.logTotalCap = cm.logTotalCapRaiseLimit
 		}
 	}
-
 	if cm.logTotalCap > cm.maxLogTotalCap {
 		cm.logTotalCap = cm.maxLogTotalCap
 	}
-
 	if refresh {
 		cm.refreshCapacity()
 	}
@@ -453,7 +412,6 @@ func (cm *ClientManager) refreshCapacity() {
 	if totalCapacity >= cm.totalCapacity*0.999 && totalCapacity <= cm.totalCapacity*1.001 {
 		return
 	}
-
 	cm.totalCapacity = totalCapacity
 	if cm.totalCapacityCh != nil {
 		select {
@@ -470,7 +428,6 @@ func (cm *ClientManager) SubscribeTotalCapacity(ch chan uint64) uint64 {
 	defer cm.lock.Unlock()
 
 	cm.totalCapacityCh = ch
-
 	return uint64(cm.totalCapacity)
 }
 
@@ -480,12 +437,10 @@ type PieceWiseLinear []struct{ X, Y uint64 }
 // ValueAt returns the curve's value at a given point
 func (pwl PieceWiseLinear) ValueAt(x uint64) float64 {
 	l := 0
-
 	h := len(pwl)
 	if h == 0 {
 		return 0
 	}
-
 	for h != l {
 		m := (l + h) / 2
 		if x > pwl[m].X {
@@ -494,21 +449,17 @@ func (pwl PieceWiseLinear) ValueAt(x uint64) float64 {
 			h = m
 		}
 	}
-
 	if l == 0 {
 		return float64(pwl[0].Y)
 	}
-
 	l--
 	if h == len(pwl) {
 		return float64(pwl[l].Y)
 	}
-
 	dx := pwl[h].X - pwl[l].X
 	if dx < 1 {
 		return float64(pwl[l].Y)
 	}
-
 	return float64(pwl[l].Y) + float64(pwl[h].Y-pwl[l].Y)*float64(x-pwl[l].X)/float64(dx)
 }
 
@@ -519,9 +470,7 @@ func (pwl PieceWiseLinear) Valid() bool {
 		if i.X < lastX {
 			return false
 		}
-
 		lastX = i.X
 	}
-
 	return true
 }

les/flowcontrol/manager_test.go

@@ -56,29 +56,22 @@ func TestConstantTotalCapacity(t *testing.T) {
 }
 
 func testConstantTotalCapacity(t *testing.T, nodeCount, maxCapacityNodes, randomSend int, priorityOverflow bool) {
-	t.Helper()
-
 	clock := &mclock.Simulated{}
 	nodes := make([]*testNode, nodeCount)
-
 	var totalCapacity uint64
-
 	for i := range nodes {
 		nodes[i] = &testNode{capacity: uint64(50000 + rand.Intn(100000))}
 		totalCapacity += nodes[i].capacity
 	}
-
 	m := NewClientManager(PieceWiseLinear{{0, totalCapacity}}, clock)
 	if priorityOverflow {
 		// provoke a situation where rcLastUpdate overflow needs to be handled
 		m.rcLastIntValue = math.MaxInt64 - 10000000000
 	}
-
 	for _, n := range nodes {
 		n.bufLimit = n.capacity * 6000
 		n.node = NewClientNode(m, ServerParams{BufLimit: n.bufLimit, MinRecharge: n.capacity})
 	}
-
 	maxNodes := make([]int, maxCapacityNodes)
 	for i := range maxNodes {
 		// we don't care if some indexes are selected multiple times
@@ -87,21 +80,18 @@ func testConstantTotalCapacity(t *testing.T, nodeCount, maxCapacityNodes, random
 	}
 
 	var sendCount int
-
 	for i := 0; i < testLength; i++ {
 		now := clock.Now()
 		for _, idx := range maxNodes {
 			for nodes[idx].send(t, now) {
 			}
 		}
-
 		if rand.Intn(testLength) < maxCapacityNodes*3 {
 			maxNodes[rand.Intn(maxCapacityNodes)] = rand.Intn(nodeCount)
 		}
 
 		sendCount += randomSend
 		failCount := randomSend * 10
-
 		for sendCount > 0 && failCount > 0 {
 			if nodes[rand.Intn(nodeCount)].send(t, now) {
 				sendCount--
@@ -116,7 +106,6 @@ func testConstantTotalCapacity(t *testing.T, nodeCount, maxCapacityNodes, random
 	for _, n := range nodes {
 		totalCost += n.totalCost
 	}
-
 	ratio := float64(totalCost) / float64(totalCapacity) / testLength
 	if ratio < 0.98 || ratio > 1.02 {
 		t.Errorf("totalCost/totalCapacity/testLength ratio incorrect (expected: 1, got: %f)", ratio)
@@ -127,20 +116,15 @@ func (n *testNode) send(t *testing.T, now mclock.AbsTime) bool {
 	if now < n.waitUntil {
 		return false
 	}
-
 	n.index++
 	if ok, _, _ := n.node.AcceptRequest(0, n.index, testMaxCost); !ok {
 		t.Fatalf("Rejected request after expected waiting time has passed")
 	}
-
 	rcost := uint64(rand.Int63n(testMaxCost))
-
 	bv := n.node.RequestProcessed(0, n.index, testMaxCost, rcost)
 	if bv < testMaxCost {
 		n.waitUntil = now + mclock.AbsTime((testMaxCost-bv)*1001000/n.capacity)
 	}
-
 	n.totalCost += rcost
-
 	return true
 }

les/handler_test.go

@@ -44,7 +44,6 @@ func expectResponse(r p2p.MsgReader, msgcode, reqID, bv uint64, data interface{}
 		ReqID, BV uint64
 		Data      interface{}
 	}
-
 	return p2p.ExpectMsg(r, msgcode, resp{reqID, bv, data})
 }
 
@@ -59,13 +58,11 @@ func testGetBlockHeaders(t *testing.T, protocol int) {
 		protocol:  protocol,
 		nopruning: true,
 	}
-
 	server, _, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
 	rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
 	defer closePeer()
-
 	bc := server.handler.blockchain
 
 	// Create a "random" unknown hash for testing
@@ -171,7 +168,6 @@ func testGetBlockHeaders(t *testing.T, protocol int) {
 	}
 	// Run each of the tests and verify the results against the chain
 	var reqID uint64
-
 	for i, tt := range tests {
 		// Collect the headers to expect in the response
 		var headers []*types.Header
@@ -182,7 +178,6 @@ func testGetBlockHeaders(t *testing.T, protocol int) {
 		reqID++
 
 		sendRequest(rawPeer.app, GetBlockHeadersMsg, reqID, tt.query)
-
 		if err := expectResponse(rawPeer.app, BlockHeadersMsg, reqID, testBufLimit, headers); err != nil {
 			t.Errorf("test %d: headers mismatch: %v", i, err)
 		}
@@ -200,7 +195,6 @@ func testGetBlockBodies(t *testing.T, protocol int) {
 		protocol:  protocol,
 		nopruning: true,
 	}
-
 	server, _, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -238,13 +232,10 @@ func testGetBlockBodies(t *testing.T, protocol int) {
 	}
 	// Run each of the tests and verify the results against the chain
 	var reqID uint64
-
 	for i, tt := range tests {
 		// Collect the hashes to request, and the response to expect
 		var hashes []common.Hash
-
 		seen := make(map[int64]bool)
-
 		var bodies []*types.Body
 
 		for j := 0; j < tt.random; j++ {
@@ -255,30 +246,24 @@ func testGetBlockBodies(t *testing.T, protocol int) {
 
 					block := bc.GetBlockByNumber(uint64(num))
 					hashes = append(hashes, block.Hash())
-
 					if len(bodies) < tt.expected {
 						bodies = append(bodies, &types.Body{Transactions: block.Transactions(), Uncles: block.Uncles()})
 					}
-
 					break
 				}
 			}
 		}
-
 		for j, hash := range tt.explicit {
 			hashes = append(hashes, hash)
-
 			if tt.available[j] && len(bodies) < tt.expected {
 				block := bc.GetBlockByHash(hash)
 				bodies = append(bodies, &types.Body{Transactions: block.Transactions(), Uncles: block.Uncles()})
 			}
 		}
-
 		reqID++
 
 		// Send the hash request and verify the response
 		sendRequest(rawPeer.app, GetBlockBodiesMsg, reqID, hashes)
-
 		if err := expectResponse(rawPeer.app, BlockBodiesMsg, reqID, testBufLimit, bodies); err != nil {
 			t.Errorf("test %d: bodies mismatch: %v", i, err)
 		}
@@ -297,7 +282,6 @@ func testGetCode(t *testing.T, protocol int) {
 		protocol:  protocol,
 		nopruning: true,
 	}
-
 	server, _, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -307,9 +291,7 @@ func testGetCode(t *testing.T, protocol int) {
 	bc := server.handler.blockchain
 
 	var codereqs []*CodeReq
-
 	var codes [][]byte
-
 	for i := uint64(0); i <= bc.CurrentBlock().Number.Uint64(); i++ {
 		header := bc.GetHeaderByNumber(i)
 		req := &CodeReq{
@@ -317,14 +299,12 @@ func testGetCode(t *testing.T, protocol int) {
 			AccountAddress: testContractAddr[:],
 		}
 		codereqs = append(codereqs, req)
-
 		if i >= testContractDeployed {
 			codes = append(codes, testContractCodeDeployed)
 		}
 	}
 
 	sendRequest(rawPeer.app, GetCodeMsg, 42, codereqs)
-
 	if err := expectResponse(rawPeer.app, CodeMsg, 42, testBufLimit, codes); err != nil {
 		t.Errorf("codes mismatch: %v", err)
 	}
@@ -341,7 +321,6 @@ func testGetStaleCode(t *testing.T, protocol int) {
 		protocol:  protocol,
 		nopruning: true,
 	}
-
 	server, _, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -356,7 +335,6 @@ func testGetStaleCode(t *testing.T, protocol int) {
 			AccountAddress: testContractAddr[:],
 		}
 		sendRequest(rawPeer.app, GetCodeMsg, 42, []*CodeReq{req})
-
 		if err := expectResponse(rawPeer.app, CodeMsg, 42, testBufLimit, expected); err != nil {
 			t.Errorf("codes mismatch: %v", err)
 		}
@@ -378,7 +356,6 @@ func testGetReceipt(t *testing.T, protocol int) {
 		protocol:  protocol,
 		nopruning: true,
 	}
-
 	server, _, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -389,9 +366,7 @@ func testGetReceipt(t *testing.T, protocol int) {
 
 	// Collect the hashes to request, and the response to expect
 	var receipts []types.Receipts
-
 	var hashes []common.Hash
-
 	for i := uint64(0); i <= bc.CurrentBlock().Number.Uint64(); i++ {
 		block := bc.GetBlockByNumber(i)
 
@@ -400,7 +375,6 @@ func testGetReceipt(t *testing.T, protocol int) {
 	}
 	// Send the hash request and verify the response
 	sendRequest(rawPeer.app, GetReceiptsMsg, 42, hashes)
-
 	if err := expectResponse(rawPeer.app, ReceiptsMsg, 42, testBufLimit, receipts); err != nil {
 		t.Errorf("receipts mismatch: %v", err)
 	}
@@ -418,7 +392,6 @@ func testGetProofs(t *testing.T, protocol int) {
 		protocol:  protocol,
 		nopruning: true,
 	}
-
 	server, _, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -428,11 +401,9 @@ func testGetProofs(t *testing.T, protocol int) {
 	bc := server.handler.blockchain
 
 	var proofreqs []ProofReq
-
 	proofsV2 := light.NewNodeSet()
 
 	accounts := []common.Address{bankAddr, userAddr1, userAddr2, signerAddr, {}}
-
 	for i := uint64(0); i <= bc.CurrentBlock().Number.Uint64(); i++ {
 		header := bc.GetHeaderByNumber(i)
 		trie, _ := trie.New(trie.StateTrieID(header.Root), trie.NewDatabase(server.db))
@@ -443,13 +414,11 @@ func testGetProofs(t *testing.T, protocol int) {
 				Key:   crypto.Keccak256(acc[:]),
 			}
 			proofreqs = append(proofreqs, req)
-
+			trie.Prove(crypto.Keccak256(acc[:]), proofsV2)
-			trie.Prove(crypto.Keccak256(acc[:]), 0, proofsV2)
 		}
 	}
 	// Send the proof request and verify the response
 	sendRequest(rawPeer.app, GetProofsV2Msg, 42, proofreqs)
-
 	if err := expectResponse(rawPeer.app, ProofsV2Msg, 42, testBufLimit, proofsV2.NodeList()); err != nil {
 		t.Errorf("proofs mismatch: %v", err)
 	}
@@ -466,7 +435,6 @@ func testGetStaleProof(t *testing.T, protocol int) {
 		protocol:  protocol,
 		nopruning: true,
 	}
-
 	server, _, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -480,7 +448,6 @@ func testGetStaleProof(t *testing.T, protocol int) {
 			header  = bc.GetHeaderByNumber(number)
 			account = crypto.Keccak256(userAddr1.Bytes())
 		)
-
 		req := &ProofReq{
 			BHash: header.Hash(),
 			Key:   account,
@@ -488,14 +455,12 @@ func testGetStaleProof(t *testing.T, protocol int) {
 		sendRequest(rawPeer.app, GetProofsV2Msg, 42, []*ProofReq{req})
 
 		var expected []rlp.RawValue
-
 		if wantOK {
 			proofsV2 := light.NewNodeSet()
 			t, _ := trie.New(trie.StateTrieID(header.Root), trie.NewDatabase(server.db))
 			t.Prove(account, proofsV2)
 			expected = proofsV2.NodeList()
 		}
-
 		if err := expectResponse(rawPeer.app, ProofsV2Msg, 42, testBufLimit, expected); err != nil {
 			t.Errorf("codes mismatch: %v", err)
 		}
@@ -529,7 +494,6 @@ func testGetCHTProofs(t *testing.T, protocol int) {
 			nopruning: true,
 		}
 	)
-
 	server, _, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -560,7 +524,6 @@ func testGetCHTProofs(t *testing.T, protocol int) {
 	}}
 	// Send the proof request and verify the response
 	sendRequest(rawPeer.app, GetHelperTrieProofsMsg, 42, requestsV2)
-
 	if err := expectResponse(rawPeer.app, HelperTrieProofsMsg, 42, testBufLimit, proofsV2); err != nil {
 		t.Errorf("proofs mismatch: %v", err)
 	}
@@ -590,7 +553,6 @@ func testGetBloombitsProofs(t *testing.T, protocol int) {
 			nopruning: true,
 		}
 	)
-
 	server, _, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -613,7 +575,6 @@ func testGetBloombitsProofs(t *testing.T, protocol int) {
 			TrieIdx: 0,
 			Key:     key,
 		}}
-
 		var proofs HelperTrieResps
 
 		root := light.GetBloomTrieRoot(server.db, 0, bc.GetHeaderByNumber(config.BloomTrieSize-1).Hash())
@@ -622,7 +583,6 @@ func testGetBloombitsProofs(t *testing.T, protocol int) {
 
 		// Send the proof request and verify the response
 		sendRequest(rawPeer.app, GetHelperTrieProofsMsg, 42, requests)
-
 		if err := expectResponse(rawPeer.app, HelperTrieProofsMsg, 42, testBufLimit, proofs); err != nil {
 			t.Errorf("bit %d: proofs mismatch: %v", bit, err)
 		}
@@ -638,7 +598,6 @@ func testTransactionStatus(t *testing.T, protocol int) {
 		protocol:  protocol,
 		nopruning: true,
 	}
-
 	server, _, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -660,9 +619,8 @@ func testTransactionStatus(t *testing.T, protocol int) {
 		} else {
 			sendRequest(rawPeer.app, GetTxStatusMsg, reqID, []common.Hash{tx.Hash()})
 		}
-
 		if err := expectResponse(rawPeer.app, TxStatusMsg, reqID, testBufLimit, []light.TxStatus{expStatus}); err != nil {
-			t.Error("transaction status mismatch", err)
+			t.Errorf("transaction status mismatch: %v", err)
 		}
 	}
 	signer := types.HomesteadSigner{}
@@ -697,10 +655,8 @@ func testTransactionStatus(t *testing.T, protocol int) {
 		if pending, _ := server.handler.txpool.Stats(); pending == 1 {
 			break
 		}
-
 		time.Sleep(100 * time.Millisecond)
 	}
-
 	if pending, _ := server.handler.txpool.Stats(); pending != 1 {
 		t.Fatalf("pending count mismatch: have %d, want 1", pending)
 	}
@@ -710,7 +666,6 @@ func testTransactionStatus(t *testing.T, protocol int) {
 
 	// check if their status is included now
 	block1hash := rawdb.ReadCanonicalHash(server.db, 1)
-
 	test(tx1, false, light.TxStatus{Status: txpool.TxStatusIncluded, Lookup: &rawdb.LegacyTxLookupEntry{BlockHash: block1hash, BlockIndex: 1, Index: 0}})
 
 	test(tx2, false, light.TxStatus{Status: txpool.TxStatusIncluded, Lookup: &rawdb.LegacyTxLookupEntry{BlockHash: block1hash, BlockIndex: 1, Index: 1}})
@@ -725,10 +680,8 @@ func testTransactionStatus(t *testing.T, protocol int) {
 		if pending, _ := server.handler.txpool.Stats(); pending == 3 {
 			break
 		}
-
 		time.Sleep(100 * time.Millisecond)
 	}
-
 	if pending, _ := server.handler.txpool.Stats(); pending != 3 {
 		t.Fatalf("pending count mismatch: have %d, want 3", pending)
 	}
@@ -750,7 +703,6 @@ func testStopResume(t *testing.T, protocol int) {
 		simClock:  true,
 		nopruning: true,
 	}
-
 	server, _, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -765,18 +717,15 @@ func testStopResume(t *testing.T, protocol int) {
 		expBuf   = testBufLimit
 		testCost = testBufLimit / 10
 	)
-
 	header := server.handler.blockchain.CurrentHeader()
 	req := func() {
 		reqID++
 		sendRequest(rawPeer.app, GetBlockHeadersMsg, reqID, &GetBlockHeadersData{Origin: hashOrNumber{Hash: header.Hash()}, Amount: 1})
 	}
-
 	for i := 1; i <= 5; i++ {
 		// send requests while we still have enough buffer and expect a response
 		for expBuf >= testCost {
 			req()
-
 			expBuf -= testCost
 			if err := expectResponse(rawPeer.app, BlockHeadersMsg, reqID, expBuf, []*types.Header{header}); err != nil {
 				t.Errorf("expected response and failed: %v", err)
@@ -786,10 +735,8 @@ func testStopResume(t *testing.T, protocol int) {
 		c := i
 		for c > 0 {
 			req()
-
 			c--
 		}
-
 		if err := p2p.ExpectMsg(rawPeer.app, StopMsg, nil); err != nil {
 			t.Errorf("expected StopMsg and failed: %v", err)
 		}

les/metrics.go

@@ -123,7 +123,6 @@ func newMeteredMsgWriter(rw p2p.MsgReadWriter, version int) p2p.MsgReadWriter {
 	if !metrics.Enabled {
 		return rw
 	}
-
 	return &meteredMsgReadWriter{MsgReadWriter: rw, version: version}
 }
 

les/odr.go

@@ -112,11 +112,9 @@ func (h peerByTxHistory) Less(i, j int) bool {
 	if h[i].txHistory == txIndexUnlimited {
 		return false
 	}
-
 	if h[j].txHistory == txIndexUnlimited {
 		return true
 	}
-
 	return h[i].txHistory < h[j].txHistory
 }
 func (h peerByTxHistory) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
@@ -142,17 +140,13 @@ func (odr *LesOdr) RetrieveTxStatus(ctx context.Context, req *light.TxStatusRequ
 		result  = make([]light.TxStatus, len(req.Hashes))
 		canSend = make(map[string]bool)
 	)
-
 	for _, peer := range odr.peers.allPeers() {
 		if peer.txHistory == txIndexDisabled {
 			continue
 		}
-
 		peers = append(peers, peer)
 	}
-
 	sort.Sort(sort.Reverse(peerByTxHistory(peers)))
-
 	for i := 0; i < maxTxStatusCandidates && i < len(peers); i++ {
 		canSend[peers[i].id] = true
 	}
@@ -161,7 +155,6 @@ func (odr *LesOdr) RetrieveTxStatus(ctx context.Context, req *light.TxStatusRequ
 		if retries >= maxTxStatusRetry || len(canSend) == 0 {
 			break
 		}
-
 		var (
 			// Deep copy the request, so that the partial result won't be mixed.
 			req     = &TxStatusRequest{Hashes: req.Hashes}
@@ -177,7 +170,6 @@ func (odr *LesOdr) RetrieveTxStatus(ctx context.Context, req *light.TxStatusRequ
 				},
 			}
 		)
-
 		if err := odr.retriever.retrieve(ctx, id, distreq, func(p distPeer, msg *Msg) error { return req.Validate(odr.db, msg) }, odr.stop); err != nil {
 			return err
 		}
@@ -188,23 +180,18 @@ func (odr *LesOdr) RetrieveTxStatus(ctx context.Context, req *light.TxStatusRequ
 			if result[index].Status != txpool.TxStatusUnknown {
 				continue
 			}
-
 			if status.Status == txpool.TxStatusUnknown {
 				continue
 			}
-
 			result[index], missing = status, missing-1
 		}
 		// Abort the procedure if all the status are retrieved
 		if missing == 0 {
 			break
 		}
-
 		retries += 1
 	}
-
 	req.Status = result
-
 	return nil
 }
 
@@ -239,15 +226,12 @@ func (odr *LesOdr) Retrieve(ctx context.Context, req light.OdrRequest) (err erro
 		if err != nil {
 			return
 		}
-
 		requestRTT.Update(time.Duration(mclock.Now() - sent))
 	}(mclock.Now())
 
 	if err := odr.retriever.retrieve(ctx, reqID, rq, func(p distPeer, msg *Msg) error { return lreq.Validate(odr.db, msg) }, odr.stop); err != nil {
 		return err
 	}
-
 	req.StoreResult(odr.db)
-
 	return nil
 }

les/odr_requests.go

@@ -103,27 +103,22 @@ func (r *BlockRequest) Validate(db ethdb.Database, msg *Msg) error {
 	if msg.MsgType != MsgBlockBodies {
 		return errInvalidMessageType
 	}
-
 	bodies := msg.Obj.([]*types.Body)
 	if len(bodies) != 1 {
 		return errInvalidEntryCount
 	}
-
 	body := bodies[0]
 
 	// Retrieve our stored header and validate block content against it
 	if r.Header == nil {
 		r.Header = rawdb.ReadHeader(db, r.Hash, r.Number)
 	}
-
 	if r.Header == nil {
 		return errHeaderUnavailable
 	}
-
 	if r.Header.TxHash != types.DeriveSha(types.Transactions(body.Transactions), trie.NewStackTrie(nil)) {
 		return errTxHashMismatch
 	}
-
 	if r.Header.UncleHash != types.CalcUncleHash(body.Uncles) {
 		return errUncleHashMismatch
 	}
@@ -132,9 +127,7 @@ func (r *BlockRequest) Validate(db ethdb.Database, msg *Msg) error {
 	if err != nil {
 		return err
 	}
-
 	r.Rlp = data
-
 	return nil
 }
 
@@ -168,29 +161,24 @@ func (r *ReceiptsRequest) Validate(db ethdb.Database, msg *Msg) error {
 	if msg.MsgType != MsgReceipts {
 		return errInvalidMessageType
 	}
-
 	receipts := msg.Obj.([]types.Receipts)
 	if len(receipts) != 1 {
 		return errInvalidEntryCount
 	}
-
 	receipt := receipts[0]
 
 	// Retrieve our stored header and validate receipt content against it
 	if r.Header == nil {
 		r.Header = rawdb.ReadHeader(db, r.Hash, r.Number)
 	}
-
 	if r.Header == nil {
 		return errHeaderUnavailable
 	}
-
 	if r.Header.ReceiptHash != types.DeriveSha(receipt, trie.NewStackTrie(nil)) {
 		return errReceiptHashMismatch
 	}
 	// Validations passed, store and return
 	r.Receipts = receipt
-
 	return nil
 }
 
@@ -222,7 +210,6 @@ func (r *TrieRequest) Request(reqID uint64, peer *serverPeer) error {
 		AccountAddress: r.Id.AccountAddress,
 		Key:            r.Key,
 	}
-
 	return peer.requestProofs(reqID, []ProofReq{req})
 }
 
@@ -235,11 +222,9 @@ func (r *TrieRequest) Validate(db ethdb.Database, msg *Msg) error {
 	if msg.MsgType != MsgProofsV2 {
 		return errInvalidMessageType
 	}
-
 	proofs := msg.Obj.(light.NodeList)
 	// Verify the proof and store if checks out
 	nodeSet := proofs.NodeSet()
-
 	reads := &readTraceDB{db: nodeSet}
 	if _, err := trie.VerifyProof(r.Id.Root, r.Key, reads); err != nil {
 		return fmt.Errorf("merkle proof verification failed: %v", err)
@@ -248,9 +233,7 @@ func (r *TrieRequest) Validate(db ethdb.Database, msg *Msg) error {
 	if len(reads.reads) != nodeSet.KeyCount() {
 		return errUselessNodes
 	}
-
 	r.Proof = nodeSet
-
 	return nil
 }
 
@@ -280,7 +263,6 @@ func (r *CodeRequest) Request(reqID uint64, peer *serverPeer) error {
 		BHash:          r.Id.BlockHash,
 		AccountAddress: r.Id.AccountAddress,
 	}
-
 	return peer.requestCode(reqID, []CodeReq{req})
 }
 
@@ -294,21 +276,17 @@ func (r *CodeRequest) Validate(db ethdb.Database, msg *Msg) error {
 	if msg.MsgType != MsgCode {
 		return errInvalidMessageType
 	}
-
 	reply := msg.Obj.([][]byte)
 	if len(reply) != 1 {
 		return errInvalidEntryCount
 	}
-
 	data := reply[0]
 
 	// Verify the data and store if checks out
 	if hash := crypto.Keccak256Hash(data); r.Hash != hash {
 		return errDataHashMismatch
 	}
-
 	r.Data = data
-
 	return nil
 }
 
@@ -354,9 +332,7 @@ func (r *ChtRequest) CanSend(peer *serverPeer) bool {
 // Request sends an ODR request to the LES network (implementation of LesOdrRequest)
 func (r *ChtRequest) Request(reqID uint64, peer *serverPeer) error {
 	peer.Log().Debug("Requesting CHT", "cht", r.ChtNum, "block", r.BlockNum)
-
 	var encNum [8]byte
-
 	binary.BigEndian.PutUint64(encNum[:], r.BlockNum)
 	req := HelperTrieReq{
 		Type:    htCanonical,
@@ -364,7 +340,6 @@ func (r *ChtRequest) Request(reqID uint64, peer *serverPeer) error {
 		Key:     encNum[:],
 		AuxReq:  htAuxHeader,
 	}
-
 	return peer.requestHelperTrieProofs(reqID, []HelperTrieReq{req})
 }
 
@@ -377,19 +352,15 @@ func (r *ChtRequest) Validate(db ethdb.Database, msg *Msg) error {
 	if msg.MsgType != MsgHelperTrieProofs {
 		return errInvalidMessageType
 	}
-
 	resp := msg.Obj.(HelperTrieResps)
 	if len(resp.AuxData) != 1 {
 		return errInvalidEntryCount
 	}
-
 	nodeSet := resp.Proofs.NodeSet()
-
 	headerEnc := resp.AuxData[0]
 	if len(headerEnc) == 0 {
 		return errHeaderUnavailable
 	}
-
 	header := new(types.Header)
 	if err := rlp.DecodeBytes(headerEnc, header); err != nil {
 		return errHeaderUnavailable
@@ -399,28 +370,22 @@ func (r *ChtRequest) Validate(db ethdb.Database, msg *Msg) error {
 		node      light.ChtNode
 		encNumber [8]byte
 	)
-
 	binary.BigEndian.PutUint64(encNumber[:], r.BlockNum)
 
 	reads := &readTraceDB{db: nodeSet}
-
 	value, err := trie.VerifyProof(r.ChtRoot, encNumber[:], reads)
 	if err != nil {
 		return fmt.Errorf("merkle proof verification failed: %v", err)
 	}
-
 	if len(reads.reads) != nodeSet.KeyCount() {
 		return errUselessNodes
 	}
-
 	if err := rlp.DecodeBytes(value, &node); err != nil {
 		return err
 	}
-
 	if node.Hash != header.Hash() {
 		return errCHTHashMismatch
 	}
-
 	if r.BlockNum != header.Number.Uint64() {
 		return errCHTNumberMismatch
 	}
@@ -428,7 +393,6 @@ func (r *ChtRequest) Validate(db ethdb.Database, msg *Msg) error {
 	r.Header = header
 	r.Proof = nodeSet
 	r.Td = node.Td
-
 	return nil
 }
 
@@ -453,7 +417,6 @@ func (r *BloomRequest) CanSend(peer *serverPeer) bool {
 	if peer.version < lpv2 {
 		return false
 	}
-
 	return peer.headInfo.Number >= r.Config.BloomTrieConfirms && r.BloomTrieNum <= (peer.headInfo.Number-r.Config.BloomTrieConfirms)/r.Config.BloomTrieSize
 }
 
@@ -463,7 +426,6 @@ func (r *BloomRequest) Request(reqID uint64, peer *serverPeer) error {
 	reqs := make([]HelperTrieReq, len(r.SectionIndexList))
 
 	var encNumber [10]byte
-
 	binary.BigEndian.PutUint16(encNumber[:2], uint16(r.BitIdx))
 
 	for i, sectionIdx := range r.SectionIndexList {
@@ -474,7 +436,6 @@ func (r *BloomRequest) Request(reqID uint64, peer *serverPeer) error {
 			Key:     common.CopyBytes(encNumber[:]),
 		}
 	}
-
 	return peer.requestHelperTrieProofs(reqID, reqs)
 }
 
@@ -488,7 +449,6 @@ func (r *BloomRequest) Validate(db ethdb.Database, msg *Msg) error {
 	if msg.MsgType != MsgHelperTrieProofs {
 		return errInvalidMessageType
 	}
-
 	resps := msg.Obj.(HelperTrieResps)
 	proofs := resps.Proofs
 	nodeSet := proofs.NodeSet()
@@ -498,26 +458,21 @@ func (r *BloomRequest) Validate(db ethdb.Database, msg *Msg) error {
 
 	// Verify the proofs
 	var encNumber [10]byte
-
 	binary.BigEndian.PutUint16(encNumber[:2], uint16(r.BitIdx))
 
 	for i, idx := range r.SectionIndexList {
 		binary.BigEndian.PutUint64(encNumber[2:], idx)
-
 		value, err := trie.VerifyProof(r.BloomTrieRoot, encNumber[:], reads)
 		if err != nil {
 			return err
 		}
-
 		r.BloomBits[i] = value
 	}
 
 	if len(reads.reads) != nodeSet.KeyCount() {
 		return errUselessNodes
 	}
-
 	r.Proofs = nodeSet
-
 	return nil
 }
 
@@ -550,14 +505,11 @@ func (r *TxStatusRequest) Validate(db ethdb.Database, msg *Msg) error {
 	if msg.MsgType != MsgTxStatus {
 		return errInvalidMessageType
 	}
-
 	status := msg.Obj.([]light.TxStatus)
 	if len(status) != len(r.Hashes) {
 		return errInvalidEntryCount
 	}
-
 	r.Status = status
-
 	return nil
 }
 
@@ -573,9 +525,7 @@ func (db *readTraceDB) Get(k []byte) ([]byte, error) {
 	if db.reads == nil {
 		db.reads = make(map[string]struct{})
 	}
-
 	db.reads[string(k)] = struct{}{}
-
 	return db.db.Get(k)
 }
 

les/odr_test.go

@@ -57,13 +57,10 @@ func odrGetBlock(ctx context.Context, db ethdb.Database, config *params.ChainCon
 	} else {
 		block, _ = lc.GetBlockByHash(ctx, bhash)
 	}
-
 	if block == nil {
 		return nil
 	}
-
 	rlp, _ := rlp.EncodeToBytes(block)
-
 	return rlp
 }
 
@@ -73,7 +70,6 @@ func TestOdrGetReceiptsLes4(t *testing.T) { testOdr(t, 4, 1, true, odrGetReceipt
 
 func odrGetReceipts(ctx context.Context, db ethdb.Database, config *params.ChainConfig, bc *core.BlockChain, lc *light.LightChain, bhash common.Hash) []byte {
 	var receipts types.Receipts
-
 	if bc != nil {
 		if number := rawdb.ReadHeaderNumber(db, bhash); number != nil {
 			if header := rawdb.ReadHeader(db, bhash, *number); header != nil {
@@ -85,13 +81,10 @@ func odrGetReceipts(ctx context.Context, db ethdb.Database, config *params.Chain
 			receipts, _ = light.GetBlockReceipts(ctx, lc.Odr(), bhash, *number)
 		}
 	}
-
 	if receipts == nil {
 		return nil
 	}
-
 	rlp, _ := rlp.EncodeToBytes(receipts)
-
 	return rlp
 }
 
@@ -108,7 +101,6 @@ func odrAccounts(ctx context.Context, db ethdb.Database, config *params.ChainCon
 		st  *state.StateDB
 		err error
 	)
-
 	for _, addr := range acc {
 		if bc != nil {
 			header := bc.GetHeaderByHash(bhash)
@@ -117,14 +109,12 @@ func odrAccounts(ctx context.Context, db ethdb.Database, config *params.ChainCon
 			header := lc.GetHeaderByHash(bhash)
 			st = light.NewState(ctx, header, lc.Odr())
 		}
-
 		if err == nil {
 			bal := st.GetBalance(addr)
 			rlp, _ := rlp.EncodeToBytes(bal)
 			res = append(res, rlp...)
 		}
 	}
-
 	return res
 }
 
@@ -136,10 +126,8 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai
 	data := common.Hex2Bytes("60CD26850000000000000000000000000000000000000000000000000000000000000000")
 
 	var res []byte
-
 	for i := 0; i < 3; i++ {
 		data[35] = byte(i)
-
 		if bc != nil {
 			header := bc.GetHeaderByHash(bhash)
 			statedb, err := state.New(header.Root, bc.StateCache(), nil)
@@ -160,14 +148,13 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai
 					SkipAccountChecks: true,
 				}
 
-				blockContext := core.NewEVMBlockContext(header, bc, nil)
+				context := core.NewEVMBlockContext(header, bc, nil)
 				txContext := core.NewEVMTxContext(msg)
-				vmenv := vm.NewEVM(blockContext, txContext, statedb, config, vm.Config{NoBaseFee: true})
+				vmenv := vm.NewEVM(context, txContext, statedb, config, vm.Config{NoBaseFee: true})
 
 				//vmenv := core.NewEnv(statedb, config, bc, msg, header, vm.Config{})
 				gp := new(core.GasPool).AddGas(math.MaxUint64)
-				// nolint : contextcheck
+				result, _ := core.ApplyMessage(vmenv, msg, gp)
-				result, _ := core.ApplyMessage(vmenv, msg, gp, context.Background())
 				res = append(res, result.Return()...)
 			}
 		} else {
@@ -185,18 +172,16 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai
 				Data:              data,
 				SkipAccountChecks: true,
 			}
-			blockContext := core.NewEVMBlockContext(header, lc, nil)
+			context := core.NewEVMBlockContext(header, lc, nil)
 			txContext := core.NewEVMTxContext(msg)
-			vmenv := vm.NewEVM(blockContext, txContext, state, config, vm.Config{NoBaseFee: true})
+			vmenv := vm.NewEVM(context, txContext, state, config, vm.Config{NoBaseFee: true})
 			gp := new(core.GasPool).AddGas(math.MaxUint64)
-			// nolint : contextcheck
+			result, _ := core.ApplyMessage(vmenv, msg, gp)
-			result, _ := core.ApplyMessage(vmenv, msg, gp, context.Background())
 			if state.Error() == nil {
 				res = append(res, result.Return()...)
 			}
 		}
 	}
-
 	return res
 }
 
@@ -206,7 +191,6 @@ func TestOdrTxStatusLes4(t *testing.T) { testOdr(t, 4, 1, false, odrTxStatus) }
 
 func odrTxStatus(ctx context.Context, db ethdb.Database, config *params.ChainConfig, bc *core.BlockChain, lc *light.LightChain, bhash common.Hash) []byte {
 	var txs types.Transactions
-
 	if bc != nil {
 		block := bc.GetBlockByHash(bhash)
 		txs = block.Transactions()
@@ -214,10 +198,8 @@ func odrTxStatus(ctx context.Context, db ethdb.Database, config *params.ChainCon
 		if block, _ := lc.GetBlockByHash(ctx, bhash); block != nil {
 			btxs := block.Transactions()
 			txs = make(types.Transactions, len(btxs))
-
 			for i, tx := range btxs {
 				var err error
-
 				txs[i], _, _, _, err = light.GetTransaction(ctx, lc.Odr(), tx.Hash())
 				if err != nil {
 					return nil
@@ -225,9 +207,7 @@ func odrTxStatus(ctx context.Context, db ethdb.Database, config *params.ChainCon
 			}
 		}
 	}
-
 	rlp, _ := rlp.EncodeToBytes(txs)
-
 	return rlp
 }
 
@@ -240,7 +220,6 @@ func testOdr(t *testing.T, protocol int, expFail uint64, checkCached bool, fn od
 		connect:   true,
 		nopruning: true,
 	}
-
 	server, client, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -265,16 +244,13 @@ func testOdr(t *testing.T, protocol int, expFail uint64, checkCached bool, fn od
 			// for travis to make the action.
 			ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 			b2 := fn(ctx, client.db, client.handler.backend.chainConfig, nil, client.handler.backend.blockchain, bhash)
-
 			cancel()
 
 			eq := bytes.Equal(b1, b2)
 			exp := i < expFail
-
 			if exp && !eq {
 				t.Fatalf("odr mismatch: have %x, want %x", b2, b1)
 			}
-
 			if !exp && eq {
 				t.Fatalf("unexpected odr match")
 			}
@@ -312,7 +288,6 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
 			nopruning: true,
 		}
 	)
-
 	server, client, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -326,13 +301,11 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
 		blockHashes  = make(map[common.Hash]common.Hash)        // Transaction hash to block hash mappings
 		intraIndex   = make(map[common.Hash]uint64)             // Transaction intra-index in block
 	)
-
 	for number := uint64(1); number < server.backend.Blockchain().CurrentBlock().Number.Uint64(); number++ {
 		block := server.backend.Blockchain().GetBlockByNumber(number)
 		if block == nil {
 			t.Fatalf("Failed to retrieve block %d", number)
 		}
-
 		for index, tx := range block.Transactions() {
 			txs[tx.Hash()] = tx
 			blockNumbers[tx.Hash()] = number
@@ -358,29 +331,23 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
 		if err != nil {
 			return err
 		}
-
 		if msg.Code != GetTxStatusMsg {
 			return fmt.Errorf("message code mismatch: got %d, expected %d", msg.Code, GetTxStatusMsg)
 		}
-
 		var r GetTxStatusPacket
 		if err := msg.Decode(&r); err != nil {
 			return err
 		}
-
 		stats := make([]light.TxStatus, len(r.Hashes))
-
 		for i, hash := range r.Hashes {
 			number, exist := blockNumbers[hash]
 			if !exist {
 				continue // Filter out unknown transactions
 			}
-
 			min := uint64(blocks) - txLookup
 			if txLookup != txIndexUnlimited && (txLookup == txIndexDisabled || number < min) {
 				continue // Filter out unindexed transactions
 			}
-
 			stats[i].Status = txpool.TxStatusIncluded
 			stats[i].Lookup = &rawdb.LegacyTxLookupEntry{
 				BlockHash:  blockHashes[hash],
@@ -388,11 +355,9 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
 				Index:      intraIndex[hash],
 			}
 		}
-
 		data, _ := rlp.EncodeToBytes(stats)
 		reply := &reply{peer.app, TxStatusMsg, r.ReqID, data}
 		reply.send(testBufLimit)
-
 		return nil
 	}
 
@@ -445,13 +410,11 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
 			results:   []light.TxStatus{{}, {}},
 		},
 	}
-
 	for _, testspec := range testspecs {
 		// Create a bunch of server peers with different tx history
 		var (
 			closeFns []func()
 		)
-
 		for i := 0; i < testspec.peers; i++ {
 			peer, closePeer, _ := client.newRawPeer(t, fmt.Sprintf("server-%d", i), protocol, testspec.txLookups[i])
 			closeFns = append(closeFns, closePeer)
@@ -465,7 +428,6 @@ func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
 		// Send out the GetTxStatus requests, compare the result with
 		// expected value.
 		r := &light.TxStatusRequest{Hashes: testspec.txs}
-
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 		defer cancel()
 
@@ -491,7 +453,6 @@ func randomHash() common.Hash {
 	if n, err := rand.Read(hash[:]); n != common.HashLength || err != nil {
 		panic(err)
 	}
-
 	return hash
 }
 */

les/peer.go

@@ -85,29 +85,23 @@ type keyValueMap map[string]rlp.RawValue
 func (l keyValueList) add(key string, val interface{}) keyValueList {
 	var entry keyValueEntry
 	entry.Key = key
-
 	if val == nil {
 		val = uint64(0)
 	}
-
 	enc, err := rlp.EncodeToBytes(val)
 	if err == nil {
 		entry.Value = enc
 	}
-
 	return append(l, entry)
 }
 
 func (l keyValueList) decode() (keyValueMap, uint64) {
 	m := make(keyValueMap)
-
 	var size uint64
-
 	for _, entry := range l {
 		m[entry.Key] = entry.Value
 		size += uint64(len(entry.Key)) + uint64(len(entry.Value)) + 8
 	}
-
 	return m, size
 }
 
@@ -116,11 +110,9 @@ func (m keyValueMap) get(key string, val interface{}) error {
 	if !ok {
 		return errResp(ErrMissingKey, "%s", key)
 	}
-
 	if val == nil {
 		return nil
 	}
-
 	return rlp.DecodeBytes(enc, val)
 }
 
@@ -229,12 +221,10 @@ func (p *peerCommons) sendReceiveHandshake(sendList keyValueList) (keyValueList,
 			errc <- err
 			return
 		}
-
 		if msg.Code != StatusMsg {
 			errc <- errResp(ErrNoStatusMsg, "first msg has code %x (!= %x)", msg.Code, StatusMsg)
 			return
 		}
-
 		if msg.Size > ProtocolMaxMsgSize {
 			errc <- errResp(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize)
 			return
@@ -246,10 +236,8 @@ func (p *peerCommons) sendReceiveHandshake(sendList keyValueList) (keyValueList,
 		}
 		errc <- nil
 	}()
-
 	timeout := time.NewTimer(handshakeTimeout)
 	defer timeout.Stop()
-
 	for i := 0; i < 2; i++ {
 		select {
 		case err := <-errc:
@@ -260,7 +248,6 @@ func (p *peerCommons) sendReceiveHandshake(sendList keyValueList) (keyValueList,
 			return nil, p2p.DiscReadTimeout
 		}
 	}
-
 	return recvList, nil
 }
 
@@ -299,35 +286,27 @@ func (p *peerCommons) handshake(td *big.Int, head common.Hash, headNum uint64, g
 	if err != nil {
 		return err
 	}
-
 	recv, size := recvList.decode()
 	if size > allowedUpdateBytes {
 		return errResp(ErrRequestRejected, "")
 	}
-
 	var rGenesis common.Hash
-
 	var rVersion, rNetwork uint64
 	if err := recv.get("protocolVersion", &rVersion); err != nil {
 		return err
 	}
-
 	if err := recv.get("networkId", &rNetwork); err != nil {
 		return err
 	}
-
 	if err := recv.get("genesisHash", &rGenesis); err != nil {
 		return err
 	}
-
 	if rGenesis != genesis {
 		return errResp(ErrGenesisBlockMismatch, "%x (!= %x)", rGenesis[:8], genesis[:8])
 	}
-
 	if rNetwork != p.network {
 		return errResp(ErrNetworkIdMismatch, "%d (!= %d)", rNetwork, p.network)
 	}
-
 	if int(rVersion) != p.version {
 		return errResp(ErrProtocolVersionMismatch, "%d (!= %d)", rVersion, p.version)
 	}
@@ -337,16 +316,13 @@ func (p *peerCommons) handshake(td *big.Int, head common.Hash, headNum uint64, g
 		if err := recv.get("forkID", &forkID); err != nil {
 			return err
 		}
-
 		if err := forkFilter(forkID); err != nil {
 			return errResp(ErrForkIDRejected, "%v", err)
 		}
 	}
-
 	if recvCallback != nil {
 		return recvCallback(recv)
 	}
-
 	return nil
 }
 
@@ -415,9 +391,7 @@ func (p *serverPeer) rejectUpdate(size uint64) bool {
 			p.updateCount = 0
 		}
 	}
-
 	p.updateCount += size
-
 	return p.updateCount > allowedUpdateBytes
 }
 
@@ -442,7 +416,6 @@ func sendRequest(w p2p.MsgWriter, msgcode, reqID uint64, data interface{}) error
 		ReqID uint64
 		Data  interface{}
 	}
-
 	return p2p.Send(w, msgcode, &req{reqID, data})
 }
 
@@ -506,12 +479,10 @@ func (p *serverPeer) requestTxStatus(reqID uint64, txHashes []common.Hash) error
 // sendTxs creates a reply with a batch of transactions to be added to the remote transaction pool.
 func (p *serverPeer) sendTxs(reqID uint64, amount int, txs rlp.RawValue) error {
 	p.Log().Debug("Sending batch of transactions", "amount", amount, "size", len(txs))
-
 	sizeFactor := (len(txs) + txSizeCostLimit/2) / txSizeCostLimit
 	if sizeFactor > amount {
 		amount = sizeFactor
 	}
-
 	return p.sendRequest(SendTxV2Msg, reqID, txs, amount)
 }
 
@@ -530,12 +501,10 @@ func (p *serverPeer) getRequestCost(msgcode uint64, amount int) uint64 {
 	if costs == nil {
 		return 0
 	}
-
 	cost := costs.baseCost + costs.reqCost*uint64(amount)
 	if cost > p.fcParams.BufLimit {
 		cost = p.fcParams.BufLimit
 	}
-
 	return cost
 }
 
@@ -549,18 +518,14 @@ func (p *serverPeer) getTxRelayCost(amount, size int) uint64 {
 	if costs == nil {
 		return 0
 	}
-
 	cost := costs.baseCost + costs.reqCost*uint64(amount)
 	sizeCost := costs.baseCost + costs.reqCost*uint64(size)/txSizeCostLimit
-
 	if sizeCost > cost {
 		cost = sizeCost
 	}
-
 	if cost > p.fcParams.BufLimit {
 		cost = p.fcParams.BufLimit
 	}
-
 	return cost
 }
 
@@ -572,9 +537,7 @@ func (p *serverPeer) HasBlock(hash common.Hash, number uint64, hasState bool) bo
 	if p.hasBlockHook != nil {
 		return p.hasBlockHook(hash, number, hasState)
 	}
-
 	head := p.headInfo.Number
-
 	var since, recent uint64
 	if hasState {
 		since = p.stateSince
@@ -583,7 +546,6 @@ func (p *serverPeer) HasBlock(hash common.Hash, number uint64, hasState bool) bo
 		since = p.chainSince
 		recent = p.chainRecent
 	}
-
 	return head >= number && number >= since && (recent == 0 || number+recent+4 > head)
 }
 
@@ -600,7 +562,6 @@ func (p *serverPeer) updateFlowControl(update keyValueMap) {
 		p.fcParams = params
 		p.fcServer.UpdateParams(params)
 	}
-
 	var MRC RequestCostList
 	if update.get("flowControl/MRC", &MRC) == nil {
 		costUpdate := MRC.decode(ProtocolLengths[uint(p.version)])
@@ -632,7 +593,6 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
 		if p.trusted {
 			p.announceType = announceTypeSigned
 		}
-
 		*lists = (*lists).add("announceType", p.announceType)
 	}, func(recv keyValueMap) error {
 		var (
@@ -640,46 +600,36 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
 			rNum  uint64
 			rTd   *big.Int
 		)
-
 		if err := recv.get("headTd", &rTd); err != nil {
 			return err
 		}
-
 		if err := recv.get("headHash", &rHash); err != nil {
 			return err
 		}
-
 		if err := recv.get("headNum", &rNum); err != nil {
 			return err
 		}
-
 		p.headInfo = blockInfo{Hash: rHash, Number: rNum, Td: rTd}
 		if recv.get("serveChainSince", &p.chainSince) != nil {
 			p.onlyAnnounce = true
 		}
-
 		if recv.get("serveRecentChain", &p.chainRecent) != nil {
 			p.chainRecent = 0
 		}
-
 		if recv.get("serveStateSince", &p.stateSince) != nil {
 			p.onlyAnnounce = true
 		}
-
 		if recv.get("serveRecentState", &p.stateRecent) != nil {
 			p.stateRecent = 0
 		}
-
 		if recv.get("txRelay", nil) != nil {
 			p.onlyAnnounce = true
 		}
-
 		if p.version >= lpv4 {
 			var recentTx uint
 			if err := recv.get("recentTxLookup", &recentTx); err != nil {
 				return err
 			}
-
 			p.txHistory = uint64(recentTx)
 		} else {
 			// The weak assumption is held here that legacy les server(les2,3)
@@ -687,7 +637,6 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
 			// versions is disabled if the transaction is unindexed.
 			p.txHistory = txIndexUnlimited
 		}
-
 		if p.onlyAnnounce && !p.trusted {
 			return errResp(ErrUselessPeer, "peer cannot serve requests")
 		}
@@ -696,16 +645,13 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
 		if err := recv.get("flowControl/BL", &sParams.BufLimit); err != nil {
 			return err
 		}
-
 		if err := recv.get("flowControl/MRR", &sParams.MinRecharge); err != nil {
 			return err
 		}
-
 		var MRC RequestCostList
 		if err := recv.get("flowControl/MRC", &MRC); err != nil {
 			return err
 		}
-
 		p.fcParams = sParams
 		p.fcServer = flowcontrol.NewServerNode(sParams, &mclock.System{})
 		p.fcCosts = MRC.decode(ProtocolLengths[uint(p.version)])
@@ -717,7 +663,6 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
 				}
 			}
 		}
-
 		return nil
 	})
 }
@@ -726,7 +671,6 @@ func (p *serverPeer) Handshake(genesis common.Hash, forkid forkid.ID, forkFilter
 // references should be removed upon disconnection by setValueTracker(nil, nil).
 func (p *serverPeer) setValueTracker(nvt *vfc.NodeValueTracker) {
 	p.vtLock.Lock()
-
 	p.nodeValueTracker = nvt
 	if nvt != nil {
 		p.sentReqs = make(map[uint64]sentReqEntry)
@@ -744,9 +688,7 @@ func (p *serverPeer) updateVtParams() {
 	if p.nodeValueTracker == nil {
 		return
 	}
-
 	reqCosts := make([]uint64, len(requestList))
-
 	for code, costs := range p.fcCosts {
 		if m, ok := requestMapping[uint32(code)]; ok {
 			reqCosts[m.first] = costs.baseCost + costs.reqCost
@@ -755,7 +697,6 @@ func (p *serverPeer) updateVtParams() {
 			}
 		}
 	}
-
 	p.nodeValueTracker.UpdateCosts(reqCosts)
 }
 
@@ -781,21 +722,17 @@ func (p *serverPeer) answeredRequest(id uint64) {
 		p.vtLock.Unlock()
 		return
 	}
-
 	e, ok := p.sentReqs[id]
 	delete(p.sentReqs, id)
 	nvt := p.nodeValueTracker
 	p.vtLock.Unlock()
-
 	if !ok {
 		return
 	}
-
 	var (
 		vtReqs   [2]vfc.ServedRequest
 		reqCount int
 	)
-
 	m := requestMapping[e.reqType]
 	if m.rest == -1 || e.amount <= 1 {
 		reqCount = 1
@@ -805,7 +742,6 @@ func (p *serverPeer) answeredRequest(id uint64) {
 		vtReqs[0] = vfc.ServedRequest{ReqType: uint32(m.first), Amount: 1}
 		vtReqs[1] = vfc.ServedRequest{ReqType: uint32(m.rest), Amount: e.amount - 1}
 	}
-
 	dt := time.Duration(mclock.Now() - e.at)
 	nvt.Served(vtReqs[:reqCount], dt)
 }
@@ -866,7 +802,6 @@ func (p *clientPeer) FreeClientId() string {
 			return addr.IP.String()
 		}
 	}
-
 	return p.id
 }
 
@@ -890,29 +825,23 @@ func (p *clientPeer) freeze() {
 		// its frozen status permanently
 		p.frozen.Store(true)
 		p.Peer.Disconnect(p2p.DiscUselessPeer)
-
 		return
 	}
-
+	if !p.frozen.Swap(true) {
-	if atomic.SwapUint32(&p.frozen, 1) == 0 {
 		go func() {
 			p.sendStop()
 			time.Sleep(freezeTimeBase + time.Duration(rand.Int63n(int64(freezeTimeRandom))))
-
 			for {
 				bufValue, bufLimit := p.fcClient.BufferStatus()
 				if bufLimit == 0 {
 					return
 				}
-
 				if bufValue <= bufLimit/8 {
 					time.Sleep(freezeCheckPeriod)
 					continue
 				}
-
+				p.frozen.Store(false)
-				atomic.StoreUint32(&p.frozen, 0)
 				p.sendResume(bufValue)
-
 				return
 			}
 		}()
@@ -934,7 +863,6 @@ func (r *reply) send(bv uint64) error {
 		ReqID, BV uint64
 		Data      rlp.RawValue
 	}
-
 	return p2p.Send(r.w, r.msgcode, &resp{r.reqID, bv, r.data})
 }
 
@@ -1018,18 +946,15 @@ func (p *clientPeer) UpdateCapacity(newCap uint64, requested bool) {
 	if newCap != p.fcParams.MinRecharge {
 		p.fcParams = flowcontrol.ServerParams{MinRecharge: newCap, BufLimit: newCap * bufLimitRatio}
 		p.fcClient.UpdateParams(p.fcParams)
-
 		var kvList keyValueList
 		kvList = kvList.add("flowControl/MRR", newCap)
 		kvList = kvList.add("flowControl/BL", newCap*bufLimitRatio)
-
 		p.queueSend(func() { p.sendAnnounce(announceData{Update: kvList}) })
 	}
 
 	if p.capacity == 0 && newCap != 0 {
 		p.sendLastAnnounce()
 	}
-
 	p.capacity = newCap
 }
 
@@ -1052,14 +977,12 @@ func (p *clientPeer) sendLastAnnounce() {
 	if p.lastAnnounce.Td == nil {
 		return
 	}
-
 	if p.headInfo.Td == nil || p.lastAnnounce.Td.Cmp(p.headInfo.Td) > 0 {
 		if !p.queueSend(func() { p.sendAnnounce(p.lastAnnounce) }) {
 			p.Log().Debug("Dropped announcement because queue is full", "number", p.lastAnnounce.Number, "hash", p.lastAnnounce.Hash)
 		} else {
 			p.Log().Debug("Sent announcement", "number", p.lastAnnounce.Number, "hash", p.lastAnnounce.Hash)
 		}
-
 		p.headInfo = blockInfo{Hash: p.lastAnnounce.Hash, Number: p.lastAnnounce.Number, Td: p.lastAnnounce.Td}
 	}
 }
@@ -1075,18 +998,12 @@ func (p *clientPeer) Handshake(td *big.Int, head common.Hash, headNum uint64, ge
 			recentTx -= blockSafetyMargin - txIndexRecentOffset
 		}
 	}
-
-	if server.config.UltraLightOnlyAnnounce {
-		recentTx = txIndexDisabled
-	}
-
 	if recentTx != txIndexUnlimited && p.version < lpv4 {
 		return errors.New("Cannot serve old clients without a complete tx index")
 	}
 	// Note: clientPeer.headInfo should contain the last head announced to the client by us.
 	// The values announced in the handshake are dummy values for compatibility reasons and should be ignored.
 	p.headInfo = blockInfo{Hash: head, Number: headNum, Td: td}
-
 	return p.handshake(td, head, headNum, genesis, forkID, forkFilter, func(lists *keyValueList) {
 		// Add some information which services server can offer.
 		*lists = (*lists).add("serveHeaders", nil)
@@ -1095,19 +1012,15 @@ func (p *clientPeer) Handshake(td *big.Int, head common.Hash, headNum uint64, ge
 
 		// If local ethereum node is running in archive mode, advertise ourselves we have
 		// all version state data. Otherwise only recent state is available.
-			stateRecent := core.DefaultCacheConfig.TriesInMemory - blockSafetyMargin
+		stateRecent := uint64(core.DefaultCacheConfig.TriesInMemory - blockSafetyMargin)
 		if server.archiveMode {
 			stateRecent = 0
 		}
-
 		*lists = (*lists).add("serveRecentState", stateRecent)
 		*lists = (*lists).add("txRelay", nil)
-		}
-
 		if p.version >= lpv4 {
 			*lists = (*lists).add("recentTxLookup", recentTx)
 		}
-
 		*lists = (*lists).add("flowControl/BL", server.defParams.BufLimit)
 		*lists = (*lists).add("flowControl/MRR", server.defParams.MinRecharge)
 
@@ -1117,7 +1030,6 @@ func (p *clientPeer) Handshake(td *big.Int, head common.Hash, headNum uint64, ge
 		} else {
 			costList = server.costTracker.makeCostList(server.costTracker.globalFactor())
 		}
-
 		*lists = (*lists).add("flowControl/MRC", costList)
 		p.fcCosts = costList.decode(ProtocolLengths[uint(p.version)])
 		p.fcParams = server.defParams
@@ -1131,7 +1043,6 @@ func (p *clientPeer) Handshake(td *big.Int, head common.Hash, headNum uint64, ge
 				p.announceType = announceTypeSimple
 			}
 		}
-
 		return nil
 	})
 }
@@ -1145,7 +1056,6 @@ func (p *clientPeer) bumpInvalid() {
 func (p *clientPeer) getInvalid() uint64 {
 	p.invalidLock.RLock()
 	defer p.invalidLock.RUnlock()
-
 	return p.invalidCount.Value(mclock.Now())
 }
 
@@ -1199,16 +1109,13 @@ func (ps *serverPeerSet) register(peer *serverPeer) error {
 	if ps.closed {
 		return errClosed
 	}
-
 	if _, exist := ps.peers[peer.id]; exist {
 		return errAlreadyRegistered
 	}
-
 	ps.peers[peer.id] = peer
 	for _, sub := range ps.subscribers {
 		sub.registerPeer(peer)
 	}
-
 	return nil
 }
 
@@ -1223,15 +1130,11 @@ func (ps *serverPeerSet) unregister(id string) error {
 	if !ok {
 		return errNotRegistered
 	}
-
 	delete(ps.peers, id)
-
 	for _, sub := range ps.subscribers {
 		sub.unregisterPeer(p)
 	}
-
 	p.Peer.Disconnect(p2p.DiscRequested)
-
 	return nil
 }
 
@@ -1244,7 +1147,6 @@ func (ps *serverPeerSet) ids() []string {
 	for id := range ps.peers {
 		ids = append(ids, id)
 	}
-
 	return ids
 }
 
@@ -1273,7 +1175,6 @@ func (ps *serverPeerSet) allPeers() []*serverPeer {
 	for _, p := range ps.peers {
 		list = append(list, p)
 	}
-
 	return list
 }
 
@@ -1286,7 +1187,6 @@ func (ps *serverPeerSet) close() {
 	for _, p := range ps.peers {
 		p.Disconnect(p2p.DiscQuitting)
 	}
-
 	ps.closed = true
 }
 
@@ -1315,14 +1215,11 @@ func (ps *clientPeerSet) register(peer *clientPeer) error {
 	if ps.closed {
 		return errClosed
 	}
-
 	if _, exist := ps.peers[peer.ID()]; exist {
 		return errAlreadyRegistered
 	}
-
 	ps.peers[peer.ID()] = peer
 	ps.announceOrStore(peer)
-
 	return nil
 }
 
@@ -1337,10 +1234,8 @@ func (ps *clientPeerSet) unregister(id enode.ID) error {
 	if !ok {
 		return errNotRegistered
 	}
-
 	delete(ps.peers, id)
 	p.Peer.Disconnect(p2p.DiscRequested)
-
 	return nil
 }
 
@@ -1353,7 +1248,6 @@ func (ps *clientPeerSet) ids() []enode.ID {
 	for id := range ps.peers {
 		ids = append(ids, id)
 	}
-
 	return ids
 }
 
@@ -1388,7 +1282,6 @@ func (ps *clientPeerSet) announceOrStore(p *clientPeer) {
 	if ps.lastAnnounce.Td == nil {
 		return
 	}
-
 	switch p.announceType {
 	case announceTypeSimple:
 		p.announceOrStore(ps.lastAnnounce)
@@ -1397,7 +1290,6 @@ func (ps *clientPeerSet) announceOrStore(p *clientPeer) {
 			ps.signedAnnounce = ps.lastAnnounce
 			ps.signedAnnounce.sign(ps.privateKey)
 		}
-
 		p.announceOrStore(ps.signedAnnounce)
 	}
 }
@@ -1411,7 +1303,6 @@ func (ps *clientPeerSet) close() {
 	for _, p := range ps.peers {
 		p.Peer.Disconnect(p2p.DiscQuitting)
 	}
-
 	ps.closed = true
 }
 
@@ -1437,13 +1328,10 @@ func (s *serverSet) register(peer *clientPeer) error {
 	if s.closed {
 		return errClosed
 	}
-
 	if _, exist := s.set[peer.id]; exist {
 		return errAlreadyRegistered
 	}
-
 	s.set[peer.id] = peer
-
 	return nil
 }
 
@@ -1454,14 +1342,11 @@ func (s *serverSet) unregister(peer *clientPeer) error {
 	if s.closed {
 		return errClosed
 	}
-
 	if _, exist := s.set[peer.id]; !exist {
 		return errNotRegistered
 	}
-
 	delete(s.set, peer.id)
 	peer.Peer.Disconnect(p2p.DiscQuitting)
-
 	return nil
 }
 
@@ -1472,6 +1357,5 @@ func (s *serverSet) close() {
 	for _, p := range s.set {
 		p.Peer.Disconnect(p2p.DiscQuitting)
 	}
-
 	s.closed = true
 }

les/peer_test.go

@@ -58,10 +58,8 @@ func TestPeerSubscription(t *testing.T) {
 		if len(given) == 0 && len(expect) == 0 {
 			return
 		}
-
 		sort.Strings(given)
 		sort.Strings(expect)
-
 		if !reflect.DeepEqual(given, expect) {
 			t.Fatalf("all peer ids mismatch, want %v, given %v", expect, given)
 		}
@@ -78,7 +76,6 @@ func TestPeerSubscription(t *testing.T) {
 		case <-time.NewTimer(10 * time.Millisecond).C:
 		}
 	}
-
 	checkIds([]string{})
 
 	sub := newTestServerPeerSub()
@@ -86,7 +83,6 @@ func TestPeerSubscription(t *testing.T) {
 
 	// Generate a random id and create the peer
 	var id enode.ID
-
 	rand.Read(id[:])
 	peer := newServerPeer(2, NetworkId, false, p2p.NewPeer(id, "name", nil), nil)
 	peers.register(peer)
@@ -113,7 +109,6 @@ func TestHandshake(t *testing.T) {
 
 	// Generate a random id and create the peer
 	var id enode.ID
-
 	rand.Read(id[:])
 
 	peer1 := newClientPeer(2, NetworkId, p2p.NewPeer(id, "name", nil), net)

les/protocol.go

@@ -174,7 +174,6 @@ var (
 // service vector indices.
 func init() {
 	requestMapping = make(map[uint32]reqMapping)
-
 	for code, req := range requests {
 		cost := reqAvgTimeCost[code]
 		rm := reqMapping{len(requestList), -1}
@@ -183,7 +182,6 @@ func init() {
 			InitAmount: req.refBasketFirst,
 			InitValue:  float64(cost.baseCost + cost.reqCost),
 		})
-
 		if req.refBasketRest != 0 {
 			rm.rest = len(requestList)
 			requestList = append(requestList, vfc.RequestInfo{
@@ -192,7 +190,6 @@ func init() {
 				InitValue:  float64(cost.reqCost),
 			})
 		}
-
 		requestMapping[uint32(code)] = rm
 	}
 }
@@ -255,7 +252,6 @@ func (a *announceData) sanityCheck() error {
 	if tdlen := a.Td.BitLen(); tdlen > 100 {
 		return fmt.Errorf("too large block TD: bitlen %d", tdlen)
 	}
-
 	return nil
 }
 
@@ -272,18 +268,14 @@ func (a *announceData) checkSignature(id enode.ID, update keyValueMap) error {
 	if err := update.get("sign", &sig); err != nil {
 		return err
 	}
-
 	rlp, _ := rlp.EncodeToBytes(blockInfo{a.Hash, a.Number, a.Td})
-
 	recPubkey, err := crypto.SigToPub(crypto.Keccak256(rlp), sig)
 	if err != nil {
 		return err
 	}
-
 	if id == enode.PubkeyToIDV4(recPubkey) {
 		return nil
 	}
-
 	return errors.New("wrong signature")
 }
 
@@ -305,11 +297,9 @@ func (hn *hashOrNumber) EncodeRLP(w io.Writer) error {
 	if hn.Hash == (common.Hash{}) {
 		return rlp.Encode(w, hn.Number)
 	}
-
 	if hn.Number != 0 {
 		return fmt.Errorf("both origin hash (%x) and number (%d) provided", hn.Hash, hn.Number)
 	}
-
 	return rlp.Encode(w, hn.Hash)
 }
 
@@ -317,7 +307,6 @@ func (hn *hashOrNumber) EncodeRLP(w io.Writer) error {
 // into either a block hash or a block number.
 func (hn *hashOrNumber) DecodeRLP(s *rlp.Stream) error {
 	_, size, err := s.Kind()
-
 	switch {
 	case err != nil:
 		return err

les/request_test.go

@@ -65,7 +65,6 @@ func tfTrieEntryAccess(db ethdb.Database, bhash common.Hash, number uint64) ligh
 	if number := rawdb.ReadHeaderNumber(db, bhash); number != nil {
 		return &light.TrieRequest{Id: light.StateTrieID(rawdb.ReadHeader(db, bhash, *number)), Key: testBankSecureTrieKey}
 	}
-
 	return nil
 }
 
@@ -78,15 +77,12 @@ func tfCodeAccess(db ethdb.Database, bhash common.Hash, num uint64) light.OdrReq
 	if number != nil {
 		return nil
 	}
-
 	header := rawdb.ReadHeader(db, bhash, *number)
 	if header.Number.Uint64() < testContractDeployed {
 		return nil
 	}
-
 	sti := light.StateTrieID(header)
-	ci := light.StorageTrieID(sti, crypto.Keccak256Hash(testContractAddr[:]), common.Hash{})
+	ci := light.StorageTrieID(sti, testContractAddr, types.EmptyRootHash)
-
 	return &light.CodeRequest{Id: ci, Hash: crypto.Keccak256Hash(testContractCodeDeployed)}
 }
 
@@ -99,7 +95,6 @@ func testAccess(t *testing.T, protocol int, fn accessTestFn) {
 		connect:   true,
 		nopruning: true,
 	}
-
 	server, client, tearDown := newClientServerEnv(t, netconfig)
 	defer tearDown()
 
@@ -116,16 +111,13 @@ func testAccess(t *testing.T, protocol int, fn accessTestFn) {
 				ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
 
 				err := client.handler.backend.odr.Retrieve(ctx, req)
-
 				cancel()
 
 				got := err == nil
 				exp := i < expFail
-
 				if exp && !got {
 					t.Errorf("object retrieval failed")
 				}
-
 				if !exp && got {
 					t.Errorf("unexpected object retrieval success")
 				}

les/retrieve.go

@@ -112,7 +112,6 @@ func (rm *retrieveManager) retrieve(ctx context.Context, reqID uint64, req *dist
 	case <-shutdown:
 		sentReq.stop(errors.New("client is shutting down"))
 	}
-
 	return sentReq.getError()
 }
 
@@ -135,7 +134,6 @@ func (rm *retrieveManager) sendReq(reqID uint64, req *distReq, val validatorFunc
 		r.lock.RLock()
 		_, sent := r.sentTo[p]
 		r.lock.RUnlock()
-
 		return !sent && canSend(p)
 	}
 
@@ -145,29 +143,16 @@ func (rm *retrieveManager) sendReq(reqID uint64, req *distReq, val validatorFunc
 		r.lock.Lock()
 		r.sentTo[p] = sentReqToPeer{delivered: false, frozen: false, event: make(chan int, 1)}
 		r.lock.Unlock()
-
 		return request(p)
 	}
-
 	rm.lock.Lock()
 	rm.sentReqs[reqID] = r
 	rm.lock.Unlock()
 
 	go r.retrieveLoop()
-
 	return r
 }
 
-// requested reports whether the request with given reqid is sent by the retriever.
-func (rm *retrieveManager) requested(reqId uint64) bool {
-	rm.lock.RLock()
-	defer rm.lock.RUnlock()
-
-	_, ok := rm.sentReqs[reqId]
-
-	return ok
-}
-
 // deliver is called by the LES protocol manager to deliver reply messages to waiting requests
 func (rm *retrieveManager) deliver(peer distPeer, msg *Msg) error {
 	rm.lock.RLock()
@@ -177,7 +162,6 @@ func (rm *retrieveManager) deliver(peer distPeer, msg *Msg) error {
 	if ok {
 		return req.deliver(peer, msg)
 	}
-
 	return errResp(ErrUnexpectedResponse, "reqID = %v", msg.ReqID)
 }
 
@@ -216,7 +200,6 @@ func (r *sentReq) stateRequesting() reqStateFn {
 	select {
 	case ev := <-r.eventsCh:
 		r.update(ev)
-
 		switch ev.event {
 		case rpSent:
 			if ev.peer == nil {
@@ -234,7 +217,6 @@ func (r *sentReq) stateRequesting() reqStateFn {
 			// last request timed out, try asking a new peer
 			go r.tryRequest()
 			r.lastReqQueued = true
-
 			return r.stateRequesting
 		case rpDeliveredInvalid, rpNotDelivered:
 			// if it was the last sent request (set to nil by update) then start a new one
@@ -242,13 +224,11 @@ func (r *sentReq) stateRequesting() reqStateFn {
 				go r.tryRequest()
 				r.lastReqQueued = true
 			}
-
 			return r.stateRequesting
 		case rpDeliveredValid:
 			r.stop(nil)
 			return r.stateStopped
 		}
-
 		return r.stateRequesting
 	case <-r.stopCh:
 		return r.stateStopped
@@ -263,22 +243,17 @@ func (r *sentReq) stateNoMorePeers() reqStateFn {
 	case <-time.After(retryQueue):
 		go r.tryRequest()
 		r.lastReqQueued = true
-
 		return r.stateRequesting
 	case ev := <-r.eventsCh:
 		r.update(ev)
-
 		if ev.event == rpDeliveredValid {
 			r.stop(nil)
 			return r.stateStopped
 		}
-
 		if r.waiting() {
 			return r.stateNoMorePeers
 		}
-
 		r.stop(light.ErrNoPeers)
-
 		return nil
 	case <-r.stopCh:
 		return r.stateStopped
@@ -291,7 +266,6 @@ func (r *sentReq) stateStopped() reqStateFn {
 	for r.waiting() {
 		r.update(<-r.eventsCh)
 	}
-
 	return nil
 }
 
@@ -326,7 +300,6 @@ func (r *sentReq) waiting() bool {
 // messages to the request's event channel.
 func (r *sentReq) tryRequest() {
 	sent := r.rm.dist.queue(r.req)
-
 	var p distPeer
 	select {
 	case p = <-sent:
@@ -339,7 +312,6 @@ func (r *sentReq) tryRequest() {
 	}
 
 	r.eventsCh <- reqPeerEvent{rpSent, p}
-
 	if p == nil {
 		return
 	}
@@ -349,7 +321,6 @@ func (r *sentReq) tryRequest() {
 	r.lock.RLock()
 	s, ok := r.sentTo[p]
 	r.lock.RUnlock()
-
 	if !ok {
 		panic(nil)
 	}
@@ -358,7 +329,6 @@ func (r *sentReq) tryRequest() {
 		pp, ok := p.(*serverPeer)
 		if hrto && ok {
 			pp.Log().Debug("Request timed out hard")
-
 			if r.rm.peers != nil {
 				r.rm.peers.unregister(pp.id)
 			}
@@ -373,7 +343,6 @@ func (r *sentReq) tryRequest() {
 			r.lock.Unlock()
 		}
 		r.eventsCh <- reqPeerEvent{event, p}
-
 		return
 	case <-time.After(r.rm.softRequestTimeout()):
 		r.eventsCh <- reqPeerEvent{rpSoftTimeout, p}
@@ -402,24 +371,19 @@ func (r *sentReq) deliver(peer distPeer, msg *Msg) error {
 	if !ok || s.delivered {
 		return errResp(ErrUnexpectedResponse, "reqID = %v", msg.ReqID)
 	}
-
 	if s.frozen {
 		return nil
 	}
-
 	valid := r.validate(peer, msg) == nil
 	r.sentTo[peer] = sentReqToPeer{delivered: true, frozen: false, event: s.event}
-
 	if valid {
 		s.event <- rpDeliveredValid
 	} else {
 		s.event <- rpDeliveredInvalid
 	}
-
 	if !valid {
 		return errResp(ErrInvalidResponse, "reqID = %v", msg.ReqID)
 	}
-
 	return nil
 }
 

les/server.go

@@ -88,7 +88,6 @@ func NewLesServer(node *node.Node, e ethBackend, config *ethconfig.Config) (*Les
 	if threads < 4 {
 		threads = 4
 	}
-
 	srv := &LesServer{
 		lesCommons: lesCommons{
 			genesis:          e.BlockChain().Genesis().Hash(),
@@ -112,12 +111,10 @@ func NewLesServer(node *node.Node, e ethBackend, config *ethconfig.Config) (*Les
 		threadsIdle:  threads,
 		p2pSrv:       node.Server(),
 	}
-
 	issync := e.Synced
 	if config.LightNoSyncServe {
 		issync = func() bool { return true }
 	}
-
 	srv.handler = newServerHandler(srv, e.BlockChain(), e.ChainDb(), e.TxPool(), issync)
 	srv.costTracker, srv.minCapacity = newCostTracker(e.ChainDb(), config)
 
@@ -136,29 +133,19 @@ func NewLesServer(node *node.Node, e ethBackend, config *ethconfig.Config) (*Les
 	// possible while the actually used server capacity does not exceed the limits
 	totalRecharge := srv.costTracker.totalRecharge()
 	srv.maxCapacity = srv.minCapacity * uint64(srv.config.LightPeers)
-
 	if totalRecharge > srv.maxCapacity {
 		srv.maxCapacity = totalRecharge
 	}
-
 	srv.fcManager.SetCapacityLimits(srv.minCapacity, srv.maxCapacity, srv.minCapacity*2)
 	srv.clientPool = vfs.NewClientPool(lesDb, srv.minCapacity, defaultConnectedBias, mclock.System{}, issync)
 	srv.clientPool.Start()
 	srv.clientPool.SetDefaultFactors(defaultPosFactors, defaultNegFactors)
 	srv.vfluxServer.Register(srv.clientPool, "les", "Ethereum light client service")
-
-	checkpoint := srv.latestLocalCheckpoint()
-	if !checkpoint.Empty() {
-		log.Info("Loaded latest checkpoint", "section", checkpoint.SectionIndex, "head", checkpoint.SectionHead,
-			"chtroot", checkpoint.CHTRoot, "bloomroot", checkpoint.BloomRoot)
-	}
-
 	srv.chtIndexer.Start(e.BlockChain())
 
 	node.RegisterProtocols(srv.Protocols())
 	node.RegisterAPIs(srv.APIs())
 	node.RegisterLifecycle(srv)
-
 	return srv, nil
 }
 
@@ -180,7 +167,6 @@ func (s *LesServer) Protocols() []p2p.Protocol {
 		if p := s.peers.peer(id); p != nil {
 			return p.Info()
 		}
-
 		return nil
 	}, nil)
 	// Add "les" ENR entries.
@@ -189,7 +175,6 @@ func (s *LesServer) Protocols() []p2p.Protocol {
 			VfxVersion: 1,
 		}}
 	}
-
 	return ps
 }
 
@@ -199,13 +184,10 @@ func (s *LesServer) Start() error {
 	s.peers.setSignerKey(s.privateKey)
 	s.handler.start()
 	s.wg.Add(1)
-
 	go s.capacityManagement()
-
 	if s.p2pSrv.DiscV5 != nil {
 		s.p2pSrv.DiscV5.RegisterTalkHandler("vfx", s.vfluxServer.ServeEncoded)
 	}
-
 	return nil
 }
 
@@ -214,17 +196,14 @@ func (s *LesServer) Stop() error {
 	close(s.closeCh)
 
 	s.clientPool.Stop()
-
 	if s.serverset != nil {
 		s.serverset.close()
 	}
-
 	s.peers.close()
 	s.fcManager.Stop()
 	s.costTracker.stop()
 	s.handler.stop()
 	s.servingQueue.stop()
-
 	if s.vfluxServer != nil {
 		s.vfluxServer.Stop()
 	}
@@ -233,11 +212,9 @@ func (s *LesServer) Stop() error {
 	if s.chtIndexer != nil {
 		s.chtIndexer.Close()
 	}
-
 	if s.lesDb != nil {
 		s.lesDb.Close()
 	}
-
 	s.wg.Wait()
 	log.Info("Les server stopped")
 
@@ -251,7 +228,6 @@ func (s *LesServer) capacityManagement() {
 	defer s.wg.Done()
 
 	processCh := make(chan bool, 100)
-
 	sub := s.handler.blockchain.SubscribeBlockProcessingEvent(processCh)
 	defer sub.Unsubscribe()
 
@@ -267,7 +243,6 @@ func (s *LesServer) capacityManagement() {
 		freePeers    uint64
 		blockProcess mclock.AbsTime
 	)
-
 	updateRecharge := func() {
 		if busy {
 			s.servingQueue.setThreads(s.threadsBusy)
@@ -287,21 +262,17 @@ func (s *LesServer) capacityManagement() {
 			} else {
 				blockProcessingTimer.Update(time.Duration(mclock.Now() - blockProcess))
 			}
-
 			updateRecharge()
 		case totalRecharge = <-totalRechargeCh:
 			totalRechargeGauge.Update(int64(totalRecharge))
 			updateRecharge()
 		case totalCapacity = <-totalCapacityCh:
 			totalCapacityGauge.Update(int64(totalCapacity))
-
 			newFreePeers := totalCapacity / s.minCapacity
 			if newFreePeers < freePeers && newFreePeers < uint64(s.config.LightPeers) {
 				log.Warn("Reduced free peer connections", "from", freePeers, "to", newFreePeers)
 			}
-
 			freePeers = newFreePeers
-
 			s.clientPool.SetLimits(uint64(s.config.LightPeers), totalCapacity)
 		case <-s.closeCh:
 			return

les/server_handler.go

@@ -18,6 +18,7 @@ package les
 
 import (
 	"errors"
+	"fmt"
 	"sync"
 	"time"
 
@@ -34,7 +35,6 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/trie"
 )
 
@@ -83,7 +83,6 @@ func newServerHandler(server *LesServer, blockchain *core.BlockChain, chainDb et
 		closeCh:    make(chan struct{}),
 		synced:     synced,
 	}
-
 	return handler
 }
 
@@ -104,9 +103,7 @@ func (h *serverHandler) runPeer(version uint, p *p2p.Peer, rw p2p.MsgReadWriter)
 	peer := newClientPeer(int(version), h.server.config.NetworkId, p, newMeteredMsgWriter(rw, int(version)))
 	defer peer.close()
 	h.wg.Add(1)
-
 	defer h.wg.Done()
-
 	return h.handle(peer)
 }
 
@@ -121,7 +118,6 @@ func (h *serverHandler) handle(p *clientPeer) error {
 		td     = h.blockchain.GetTd(hash, number)
 		forkID = forkid.NewID(h.blockchain.Config(), h.blockchain.Genesis().Hash(), number, head.Time)
 	)
-
 	if err := p.Handshake(td, hash, number, h.blockchain.Genesis().Hash(), forkID, h.forkFilter, h.server); err != nil {
 		p.Log().Debug("Light Ethereum handshake failed", "err", err)
 		return err
@@ -131,10 +127,8 @@ func (h *serverHandler) handle(p *clientPeer) error {
 		if err := h.server.serverset.register(p); err != nil {
 			return err
 		}
-
 		_, err := p.rw.ReadMsg()
 		h.server.serverset.unregister(p)
-
 		return err
 	}
 	// Setup flow control mechanism for the peer
@@ -152,14 +146,11 @@ func (h *serverHandler) handle(p *clientPeer) error {
 	if err := h.server.peers.register(p); err != nil {
 		return err
 	}
-
 	if p.balance = h.server.clientPool.Register(p); p.balance == nil {
 		h.server.peers.unregister(p.ID())
 		p.Log().Debug("Client pool already closed")
-
 		return p2p.DiscRequested
 	}
-
 	p.connectedAt = mclock.Now()
 
 	var wg sync.WaitGroup // Wait group used to track all in-flight task routines.
@@ -183,7 +174,6 @@ func (h *serverHandler) handle(p *clientPeer) error {
 			return err
 		default:
 		}
-
 		if err := h.handleMsg(p, &wg); err != nil {
 			p.Log().Debug("Light Ethereum message handling failed", "err", err)
 			return err
@@ -205,15 +195,12 @@ func (h *serverHandler) beforeHandle(p *clientPeer, reqID, responseCount uint64,
 		p.fcClient.OneTimeCost(inSizeCost)
 		return nil, 0
 	}
-
 	maxCost := p.fcCosts.getMaxCost(msg.Code, reqCnt)
-
 	accepted, bufShort, priority := p.fcClient.AcceptRequest(reqID, responseCount, maxCost)
 	if !accepted {
 		p.freeze()
 		p.Log().Error("Request came too early", "remaining", common.PrettyDuration(time.Duration(bufShort*1000000/p.fcParams.MinRecharge)))
 		p.fcClient.OneTimeCost(inSizeCost)
-
 		return nil, 0
 	}
 	// Create a multi-stage task, estimate the time it takes for the task to
@@ -223,15 +210,12 @@ func (h *serverHandler) beforeHandle(p *clientPeer, reqID, responseCount uint64,
 		factor = 1
 		p.Log().Error("Invalid global cost factor", "factor", factor)
 	}
-
 	maxTime := uint64(float64(maxCost) / factor)
-
 	task := h.server.servingQueue.newTask(p, maxTime, priority)
 	if !task.start() {
 		p.fcClient.RequestProcessed(reqID, responseCount, maxCost, inSizeCost)
 		return nil, 0
 	}
-
 	return task, maxCost
 }
 
@@ -241,7 +225,6 @@ func (h *serverHandler) afterHandle(p *clientPeer, reqID, responseCount uint64,
 	if reply != nil {
 		task.done()
 	}
-
 	p.responseLock.Lock()
 	defer p.responseLock.Unlock()
 
@@ -249,7 +232,6 @@ func (h *serverHandler) afterHandle(p *clientPeer, reqID, responseCount uint64,
 	if p.isFrozen() {
 		realCost := h.server.costTracker.realCost(task.servingTime, msg.Size, 0)
 		p.fcClient.RequestProcessed(reqID, responseCount, maxCost, realCost)
-
 		return
 	}
 	// Positive correction buffer value with real cost.
@@ -257,7 +239,6 @@ func (h *serverHandler) afterHandle(p *clientPeer, reqID, responseCount uint64,
 	if reply != nil {
 		replySize = reply.size()
 	}
-
 	var realCost uint64
 	if h.server.costTracker.testing {
 		realCost = maxCost // Assign a fake cost for testing purpose
@@ -267,9 +248,7 @@ func (h *serverHandler) afterHandle(p *clientPeer, reqID, responseCount uint64,
 			realCost = maxCost
 		}
 	}
-
 	bv := p.fcClient.RequestProcessed(reqID, responseCount, maxCost, realCost)
-
 	if reply != nil {
 		// Feed cost tracker request serving statistic.
 		h.server.costTracker.updateStats(msg.Code, reqCnt, task.servingTime, realCost)
@@ -294,7 +273,6 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
 	if err != nil {
 		return err
 	}
-
 	p.Log().Trace("Light Ethereum message arrived", "code", msg.Code, "bytes", msg.Size)
 
 	// Discard large message which exceeds the limitation.
@@ -310,10 +288,8 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
 	if !ok {
 		p.Log().Trace("Received invalid message", "code", msg.Code)
 		clientErrorMeter.Mark(1)
-
 		return errResp(ErrInvalidMsgCode, "%v", msg.Code)
 	}
-
 	p.Log().Trace("Received " + req.Name)
 
 	// Decode the p2p message, resolve the concrete handler for it.
@@ -322,12 +298,10 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
 		clientErrorMeter.Mark(1)
 		return errResp(ErrDecode, "%v: %v", msg, err)
 	}
-
 	if metrics.EnabledExpensive {
 		req.InPacketsMeter.Mark(1)
 		req.InTrafficMeter.Mark(int64(msg.Size))
 	}
-
 	p.responseCount++
 	responseCount := p.responseCount
 
@@ -337,9 +311,7 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
 	if task == nil {
 		return nil
 	}
-
 	wg.Add(1)
-
 	go func() {
 		defer wg.Done()
 
@@ -351,7 +323,6 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
 			if reply != nil {
 				size = reply.size()
 			}
-
 			req.OutPacketsMeter.Mark(1)
 			req.OutTrafficMeter.Mark(int64(size))
 			req.ServingTimeMeter.Update(time.Duration(task.servingTime))
@@ -363,7 +334,6 @@ func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
 		clientErrorMeter.Mark(1)
 		return errTooManyInvalidRequest
 	}
-
 	return nil
 }
 
@@ -393,18 +363,14 @@ func getAccount(triedb *trie.Database, root common.Hash, addr common.Address) (t
 	if err != nil {
 		return types.StateAccount{}, err
 	}
-
+	acc, err := trie.GetAccount(addr)
-	blob, err := trie.Get(hash[:])
 	if err != nil {
 		return types.StateAccount{}, err
 	}
-
+	if acc == nil {
-	var acc types.StateAccount
+		return types.StateAccount{}, fmt.Errorf("account %#x is not present", addr)
-	if err = rlp.DecodeBytes(blob, &acc); err != nil {
-		return types.StateAccount{}, err
 	}
-
+	return *acc, nil
-	return acc, nil
 }
 
 // GetHelperTrie returns the post-processed trie root for the given trie ID and section index
@@ -413,7 +379,6 @@ func (h *serverHandler) GetHelperTrie(typ uint, index uint64) *trie.Trie {
 		root   common.Hash
 		prefix string
 	)
-
 	switch typ {
 	case htCanonical:
 		sectionHead := rawdb.ReadCanonicalHash(h.chainDb, (index+1)*h.server.iConfig.ChtSize-1)
@@ -422,13 +387,10 @@ func (h *serverHandler) GetHelperTrie(typ uint, index uint64) *trie.Trie {
 		sectionHead := rawdb.ReadCanonicalHash(h.chainDb, (index+1)*h.server.iConfig.BloomTrieSize-1)
 		root, prefix = light.GetBloomTrieRoot(h.chainDb, index, sectionHead), string(rawdb.BloomTrieTablePrefix)
 	}
-
 	if root == (common.Hash{}) {
 		return nil
 	}
-
 	trie, _ := trie.New(trie.TrieID(root), trie.NewDatabase(rawdb.NewTable(h.chainDb, prefix)))
-
 	return trie
 }
 
@@ -440,7 +402,6 @@ func (h *serverHandler) broadcastLoop() {
 	defer h.wg.Done()
 
 	headCh := make(chan core.ChainHeadEvent, 10)
-
 	headSub := h.blockchain.SubscribeChainHeadEvent(headCh)
 	defer headSub.Unsubscribe()
 
@@ -448,27 +409,22 @@ func (h *serverHandler) broadcastLoop() {
 		lastHead = h.blockchain.CurrentHeader()
 		lastTd   = common.Big0
 	)
-
 	for {
 		select {
 		case ev := <-headCh:
 			header := ev.Block.Header()
 			hash, number := header.Hash(), header.Number.Uint64()
-
 			td := h.blockchain.GetTd(hash, number)
 			if td == nil || td.Cmp(lastTd) <= 0 {
 				continue
 			}
-
 			var reorg uint64
-
 			if lastHead != nil {
 				// If a setHead has been performed, the common ancestor can be nil.
 				if ancestor := rawdb.FindCommonAncestor(h.chainDb, header, lastHead); ancestor != nil {
 					reorg = lastHead.Number.Uint64() - ancestor.Number.Uint64()
 				}
 			}
-
 			lastHead, lastTd = header, td
 			log.Debug("Announcing block to peers", "number", number, "hash", hash, "td", td, "reorg", reorg)
 			h.server.peers.broadcast(announceData{Hash: hash, Number: number, Td: td, ReorgDepth: reorg})

les/server_requests.go

@@ -154,7 +154,6 @@ func handleGetBlockHeaders(msg Decoder) (serveRequestFn, uint64, uint64, error)
 	if err := msg.Decode(&r); err != nil {
 		return nil, 0, 0, err
 	}
-
 	return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
 		// Gather headers until the fetch or network limits is reached
 		var (
@@ -166,14 +165,12 @@ func handleGetBlockHeaders(msg Decoder) (serveRequestFn, uint64, uint64, error)
 			headers         []*types.Header
 			unknown         bool
 		)
-
 		for !unknown && len(headers) < int(r.Query.Amount) && bytes < softResponseLimit {
 			if !first && !waitOrStop() {
 				return nil
 			}
 			// Retrieve the next header satisfying the r
 			var origin *types.Header
-
 			if hashMode {
 				if first {
 					origin = bc.GetHeaderByHash(r.Query.Origin.Hash)
@@ -186,11 +183,9 @@ func handleGetBlockHeaders(msg Decoder) (serveRequestFn, uint64, uint64, error)
 			} else {
 				origin = bc.GetHeaderByNumber(r.Query.Origin.Number)
 			}
-
 			if origin == nil {
 				break
 			}
-
 			headers = append(headers, origin)
 			bytes += estHeaderRlpSize
 
@@ -211,17 +206,14 @@ func handleGetBlockHeaders(msg Decoder) (serveRequestFn, uint64, uint64, error)
 					current = origin.Number.Uint64()
 					next    = current + r.Query.Skip + 1
 				)
-
 				if next <= current {
 					infos, _ := json.Marshal(p.Peer.Info())
 					p.Log().Warn("GetBlockHeaders skip overflow attack", "current", current, "skip", r.Query.Skip, "next", next, "attacker", string(infos))
-
 					unknown = true
 				} else {
 					if header := bc.GetHeaderByNumber(next); header != nil {
 						nextHash := header.Hash()
 						expOldHash, _ := bc.GetAncestor(nextHash, next, r.Query.Skip+1, &maxNonCanonical)
-
 						if expOldHash == r.Query.Origin.Hash {
 							r.Query.Origin.Hash, r.Query.Origin.Number = nextHash, next
 						} else {
@@ -243,10 +235,8 @@ func handleGetBlockHeaders(msg Decoder) (serveRequestFn, uint64, uint64, error)
 				// Number based traversal towards the leaf block
 				r.Query.Origin.Number += r.Query.Skip + 1
 			}
-
 			first = false
 		}
-
 		return p.replyBlockHeaders(r.ReqID, headers)
 	}, r.ReqID, r.Query.Amount, nil
 }
@@ -257,34 +247,27 @@ func handleGetBlockBodies(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 	if err := msg.Decode(&r); err != nil {
 		return nil, 0, 0, err
 	}
-
 	return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
 		var (
 			bytes  int
 			bodies []rlp.RawValue
 		)
-
 		bc := backend.BlockChain()
-
 		for i, hash := range r.Hashes {
 			if i != 0 && !waitOrStop() {
 				return nil
 			}
-
 			if bytes >= softResponseLimit {
 				break
 			}
-
 			body := bc.GetBodyRLP(hash)
 			if body == nil {
 				p.bumpInvalid()
 				continue
 			}
-
 			bodies = append(bodies, body)
 			bytes += len(body)
 		}
-
 		return p.replyBlockBodiesRLP(r.ReqID, bodies)
 	}, r.ReqID, uint64(len(r.Hashes)), nil
 }
@@ -295,15 +278,12 @@ func handleGetCode(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 	if err := msg.Decode(&r); err != nil {
 		return nil, 0, 0, err
 	}
-
 	return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
 		var (
 			bytes int
 			data  [][]byte
 		)
-
 		bc := backend.BlockChain()
-
 		for i, request := range r.Reqs {
 			if i != 0 && !waitOrStop() {
 				return nil
@@ -313,7 +293,6 @@ func handleGetCode(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 			if header == nil {
 				p.Log().Warn("Failed to retrieve associate header for code", "hash", request.BHash)
 				p.bumpInvalid()
-
 				continue
 			}
 			// Refuse to search stale state data in the database since looking for
@@ -322,33 +301,27 @@ func handleGetCode(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 			if !backend.ArchiveMode() && header.Number.Uint64()+core.DefaultCacheConfig.TriesInMemory <= local {
 				p.Log().Debug("Reject stale code request", "number", header.Number.Uint64(), "head", local)
 				p.bumpInvalid()
-
 				continue
 			}
-
 			triedb := bc.StateCache().TrieDB()
 			address := common.BytesToAddress(request.AccountAddress)
 			account, err := getAccount(triedb, header.Root, address)
 			if err != nil {
 				p.Log().Warn("Failed to retrieve account for code", "block", header.Number, "hash", header.Hash(), "account", address, "err", err)
 				p.bumpInvalid()
-
 				continue
 			}
-
+			code, err := bc.StateCache().ContractCode(address, common.BytesToHash(account.CodeHash))
-			code, err := bc.StateCache().ContractCode(common.BytesToHash(request.AccKey), common.BytesToHash(account.CodeHash))
 			if err != nil {
 				p.Log().Warn("Failed to retrieve account code", "block", header.Number, "hash", header.Hash(), "account", address, "codehash", common.BytesToHash(account.CodeHash), "err", err)
 				continue
 			}
 			// Accumulate the code and abort if enough data was retrieved
 			data = append(data, code)
-
 			if bytes += len(code); bytes >= softResponseLimit {
 				break
 			}
 		}
-
 		return p.replyCode(r.ReqID, data)
 	}, r.ReqID, uint64(len(r.Reqs)), nil
 }
@@ -359,20 +332,16 @@ func handleGetReceipts(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 	if err := msg.Decode(&r); err != nil {
 		return nil, 0, 0, err
 	}
-
 	return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
 		var (
 			bytes    int
 			receipts []rlp.RawValue
 		)
-
 		bc := backend.BlockChain()
-
 		for i, hash := range r.Hashes {
 			if i != 0 && !waitOrStop() {
 				return nil
 			}
-
 			if bytes >= softResponseLimit {
 				break
 			}
@@ -392,7 +361,6 @@ func handleGetReceipts(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 				bytes += len(encoded)
 			}
 		}
-
 		return p.replyReceiptsRLP(r.ReqID, receipts)
 	}, r.ReqID, uint64(len(r.Hashes)), nil
 }
@@ -403,7 +371,6 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 	if err := msg.Decode(&r); err != nil {
 		return nil, 0, 0, err
 	}
-
 	return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
 		var (
 			lastBHash common.Hash
@@ -411,7 +378,6 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 			header    *types.Header
 			err       error
 		)
-
 		bc := backend.BlockChain()
 		nodes := light.NewNodeSet()
 
@@ -426,7 +392,6 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 				if header = bc.GetHeaderByHash(request.BHash); header == nil {
 					p.Log().Warn("Failed to retrieve header for proof", "hash", request.BHash)
 					p.bumpInvalid()
-
 					continue
 				}
 				// Refuse to search stale state data in the database since looking for
@@ -435,10 +400,8 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 				if !backend.ArchiveMode() && header.Number.Uint64()+core.DefaultCacheConfig.TriesInMemory <= local {
 					p.Log().Debug("Reject stale trie request", "number", header.Number.Uint64(), "head", local)
 					p.bumpInvalid()
-
 					continue
 				}
-
 				root = header.Root
 			}
 			// If a header lookup failed (non existent), ignore subsequent requests for the same header
@@ -450,8 +413,7 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 			statedb := bc.StateCache()
 
 			var trie state.Trie
-
+			switch len(request.AccountAddress) {
-			switch len(request.AccKey) {
 			case 0:
 				// No account key specified, open an account trie
 				trie, err = statedb.OpenTrie(root)
@@ -466,11 +428,9 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 				if err != nil {
 					p.Log().Warn("Failed to retrieve account for proof", "block", header.Number, "hash", header.Hash(), "account", address, "err", err)
 					p.bumpInvalid()
-
 					continue
 				}
-
+				trie, err = statedb.OpenStorageTrie(root, address, account.Root)
-				trie, err = statedb.OpenStorageTrie(root, common.BytesToHash(request.AccKey), account.Root)
 				if trie == nil || err != nil {
 					p.Log().Warn("Failed to open storage trie for proof", "block", header.Number, "hash", header.Hash(), "account", address, "root", account.Root, "err", err)
 					continue
@@ -481,12 +441,10 @@ func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 				p.Log().Warn("Failed to prove state request", "block", header.Number, "hash", header.Hash(), "err", err)
 				continue
 			}
-
 			if nodes.DataSize() >= softResponseLimit {
 				break
 			}
 		}
-
 		return p.replyProofsV2(r.ReqID, nodes.NodeList())
 	}, r.ReqID, uint64(len(r.Reqs)), nil
 }
@@ -497,7 +455,6 @@ func handleGetHelperTrieProofs(msg Decoder) (serveRequestFn, uint64, uint64, err
 	if err := msg.Decode(&r); err != nil {
 		return nil, 0, 0, err
 	}
-
 	return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
 		var (
 			lastIdx  uint64
@@ -506,20 +463,16 @@ func handleGetHelperTrieProofs(msg Decoder) (serveRequestFn, uint64, uint64, err
 			auxBytes int
 			auxData  [][]byte
 		)
-
 		bc := backend.BlockChain()
 		nodes := light.NewNodeSet()
-
 		for i, request := range r.Reqs {
 			if i != 0 && !waitOrStop() {
 				return nil
 			}
-
 			if auxTrie == nil || request.Type != lastType || request.TrieIdx != lastIdx {
 				lastType, lastIdx = request.Type, request.TrieIdx
 				auxTrie = backend.GetHelperTrie(request.Type, request.TrieIdx)
 			}
-
 			if auxTrie == nil {
 				return nil
 			}
@@ -532,25 +485,20 @@ func handleGetHelperTrieProofs(msg Decoder) (serveRequestFn, uint64, uint64, err
 			if p.version >= lpv4 && err != nil {
 				return nil
 			}
-
 			if request.Type == htCanonical && request.AuxReq == htAuxHeader && len(request.Key) == 8 {
 				header := bc.GetHeaderByNumber(binary.BigEndian.Uint64(request.Key))
-
 				data, err := rlp.EncodeToBytes(header)
 				if err != nil {
 					log.Error("Failed to encode header", "err", err)
 					return nil
 				}
-
 				auxData = append(auxData, data)
 				auxBytes += len(data)
 			}
-
 			if nodes.DataSize()+auxBytes >= softResponseLimit {
 				break
 			}
 		}
-
 		return p.replyHelperTrieProofs(r.ReqID, HelperTrieResps{Proofs: nodes.NodeList(), AuxData: auxData})
 	}, r.ReqID, uint64(len(r.Reqs)), nil
 }
@@ -561,36 +509,23 @@ func handleSendTx(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 	if err := msg.Decode(&r); err != nil {
 		return nil, 0, 0, err
 	}
-
 	amount := uint64(len(r.Txs))
-
 	return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
 		stats := make([]light.TxStatus, len(r.Txs))
-
 		for i, tx := range r.Txs {
 			if i != 0 && !waitOrStop() {
 				return nil
 			}
-
 			hash := tx.Hash()
 			stats[i] = txStatus(backend, hash)
-
 			if stats[i].Status == txpool.TxStatusUnknown {
-				addFn := backend.TxPool().AddRemotes
+				if errs := backend.TxPool().Add([]*txpool.Transaction{{Tx: tx}}, false, backend.AddTxsSync()); errs[0] != nil {
-				// Add txs synchronously for testing purpose
-				if backend.AddTxsSync() {
-					addFn = backend.TxPool().AddRemotesSync
-				}
-
-				if errs := addFn([]*types.Transaction{tx}); errs[0] != nil {
 					stats[i].Error = errs[0].Error()
 					continue
 				}
-
 				stats[i] = txStatus(backend, hash)
 			}
 		}
-
 		return p.replyTxStatus(r.ReqID, stats)
 	}, r.ReqID, amount, nil
 }
@@ -601,18 +536,14 @@ func handleGetTxStatus(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 	if err := msg.Decode(&r); err != nil {
 		return nil, 0, 0, err
 	}
-
 	return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
 		stats := make([]light.TxStatus, len(r.Hashes))
-
 		for i, hash := range r.Hashes {
 			if i != 0 && !waitOrStop() {
 				return nil
 			}
-
 			stats[i] = txStatus(backend, hash)
 		}
-
 		return p.replyTxStatus(r.ReqID, stats)
 	}, r.ReqID, uint64(len(r.Hashes)), nil
 }
@@ -631,6 +562,5 @@ func txStatus(b serverBackend, hash common.Hash) light.TxStatus {
 			stat.Lookup = lookup
 		}
 	}
-
 	return stat
 }

les/servingqueue.go

@@ -17,12 +17,12 @@
 package les
 
 import (
-	"sort"
 	"sync"
 	"sync/atomic"
 
 	"github.com/ethereum/go-ethereum/common/mclock"
 	"github.com/ethereum/go-ethereum/common/prque"
+	"golang.org/x/exp/slices"
 )
 
 // servingQueue allows running tasks in a limited number of threads and puts the
@@ -73,7 +73,6 @@ func (t *servingTask) start() bool {
 	if t.peer.isFrozen() {
 		return false
 	}
-
 	t.tokenCh = make(chan runToken, 1)
 	select {
 	case t.sq.queueAddCh <- t:
@@ -85,13 +84,10 @@ func (t *servingTask) start() bool {
 	case <-t.sq.quit:
 		return false
 	}
-
 	if t.token == nil {
 		return false
 	}
-
 	t.servingTime -= uint64(mclock.Now())
-
 	return true
 }
 
@@ -102,14 +98,12 @@ func (t *servingTask) done() uint64 {
 	close(t.token)
 	diff := t.servingTime - t.timeAdded
 	t.timeAdded = t.servingTime
-
 	if t.expTime > diff {
 		t.expTime -= diff
 		atomic.AddUint64(&t.sq.servingTimeDiff, t.expTime)
 	} else {
 		t.expTime = 0
 	}
-
 	return t.servingTime
 }
 
@@ -119,12 +113,10 @@ func (t *servingTask) done() uint64 {
 // means the task should be cancelled.
 func (t *servingTask) waitOrStop() bool {
 	t.done()
-
 	if !t.biasAdded {
 		t.priority += t.sq.suspendBias
 		t.biasAdded = true
 	}
-
 	return t.start()
 }
 
@@ -144,10 +136,8 @@ func newServingQueue(suspendBias int64, utilTarget float64) *servingQueue {
 		lastUpdate:     mclock.Now(),
 	}
 	sq.wg.Add(2)
-
 	go sq.queueLoop()
 	go sq.threadCountLoop()
-
 	return sq
 }
 
@@ -170,7 +160,6 @@ func (sq *servingQueue) newTask(peer *clientPeer, maxTime uint64, priority int64
 // without entering the priority queue.
 func (sq *servingQueue) threadController() {
 	defer sq.wg.Done()
-
 	for {
 		token := make(runToken)
 		select {
@@ -203,24 +192,19 @@ type peerTasks struct {
 // them until burstTime goes under burstDropLimit or all peers are frozen
 func (sq *servingQueue) freezePeers() {
 	peerMap := make(map[*clientPeer]*peerTasks)
-
+	var peerList []*peerTasks
-	var peerList peerList
-
 	if sq.best != nil {
 		sq.queue.Push(sq.best, sq.best.priority)
 	}
-
 	sq.best = nil
 	for sq.queue.Size() > 0 {
 		task := sq.queue.PopItem()
 		tasks := peerMap[task.peer]
-
 		if tasks == nil {
 			bufValue, bufLimit := task.peer.fcClient.BufferStatus()
 			if bufLimit < 1 {
 				bufLimit = 1
 			}
-
 			tasks = &peerTasks{
 				peer:     task.peer,
 				priority: float64(bufValue) / float64(bufLimit), // lower value comes first
@@ -228,12 +212,18 @@ func (sq *servingQueue) freezePeers() {
 			peerMap[task.peer] = tasks
 			peerList = append(peerList, tasks)
 		}
-
 		tasks.list = append(tasks.list, task)
 		tasks.sumTime += task.expTime
 	}
-	sort.Sort(peerList)
+	slices.SortFunc(peerList, func(a, b *peerTasks) int {
-
+		if a.priority < b.priority {
+			return -1
+		}
+		if a.priority > b.priority {
+			return 1
+		}
+		return 0
+	})
 	drop := true
 	for _, tasks := range peerList {
 		if drop {
@@ -242,9 +232,7 @@ func (sq *servingQueue) freezePeers() {
 			sq.queuedTime -= tasks.sumTime
 			sqQueuedGauge.Update(int64(sq.queuedTime))
 			clientFreezeMeter.Mark(1)
-
 			drop = sq.recentTime+sq.queuedTime > sq.burstDropLimit
-
 			for _, task := range tasks.list {
 				task.tokenCh <- nil
 			}
@@ -254,7 +242,6 @@ func (sq *servingQueue) freezePeers() {
 			}
 		}
 	}
-
 	if sq.queue.Size() > 0 {
 		sq.best = sq.queue.PopItem()
 	}
@@ -266,11 +253,9 @@ func (sq *servingQueue) updateRecentTime() {
 	now := mclock.Now()
 	dt := now - sq.lastUpdate
 	sq.lastUpdate = now
-
 	if dt > 0 {
 		subTime += uint64(float64(dt) * sq.burstDecRate)
 	}
-
 	if sq.recentTime > subTime {
 		sq.recentTime -= subTime
 	} else {
@@ -288,12 +273,10 @@ func (sq *servingQueue) addTask(task *servingTask) {
 	} else {
 		sq.queue.Push(task, task.priority)
 	}
-
 	sq.updateRecentTime()
 	sq.queuedTime += task.expTime
 	sqServedGauge.Update(int64(sq.recentTime))
 	sqQueuedGauge.Update(int64(sq.queuedTime))
-
 	if sq.recentTime+sq.queuedTime > sq.burstLimit {
 		sq.freezePeers()
 	}
@@ -304,7 +287,6 @@ func (sq *servingQueue) addTask(task *servingTask) {
 // tasks are removed from the queue.
 func (sq *servingQueue) queueLoop() {
 	defer sq.wg.Done()
-
 	for {
 		if sq.best != nil {
 			expTime := sq.best.expTime
@@ -317,7 +299,6 @@ func (sq *servingQueue) queueLoop() {
 				sq.recentTime += expTime
 				sqServedGauge.Update(int64(sq.recentTime))
 				sqQueuedGauge.Update(int64(sq.queuedTime))
-
 				if sq.queue.Size() == 0 {
 					sq.best = nil
 				} else {
@@ -341,17 +322,13 @@ func (sq *servingQueue) queueLoop() {
 // of active thread controller goroutines.
 func (sq *servingQueue) threadCountLoop() {
 	var threadCountTarget int
-
 	defer sq.wg.Done()
-
 	for {
 		for threadCountTarget > sq.threadCount {
 			sq.wg.Add(1)
 			go sq.threadController()
-
 			sq.threadCount++
 		}
-
 		if threadCountTarget < sq.threadCount {
 			select {
 			case threadCountTarget = <-sq.setThreadsCh:

les/state_accessor.go

@@ -17,7 +17,7 @@
 package les
 
 import (
-	"context"
+	contextLib "context"
 	"errors"
 	"fmt"
 
@@ -34,12 +34,12 @@ import (
 var noopReleaser = tracers.StateReleaseFunc(func() {})
 
 // stateAtBlock retrieves the state database associated with a certain block.
-func (leth *LightEthereum) stateAtBlock(ctx context.Context, block *types.Block, _ uint64) (*state.StateDB, tracers.StateReleaseFunc, error) {
+func (leth *LightEthereum) stateAtBlock(ctx contextLib.Context, block *types.Block, reexec uint64) (*state.StateDB, tracers.StateReleaseFunc, error) {
 	return light.NewState(ctx, block.Header(), leth.odr), noopReleaser, nil
 }
 
 // stateAtTransaction returns the execution environment of a certain transaction.
-func (leth *LightEthereum) stateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) {
+func (leth *LightEthereum) stateAtTransaction(ctx contextLib.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) {
 	// Short circuit if it's genesis block.
 	if block.NumberU64() == 0 {
 		return nil, vm.BlockContext{}, nil, nil, errors.New("no transaction in genesis")
@@ -49,12 +49,10 @@ func (leth *LightEthereum) stateAtTransaction(ctx context.Context, block *types.
 	if err != nil {
 		return nil, vm.BlockContext{}, nil, nil, err
 	}
-
 	statedb, release, err := leth.stateAtBlock(ctx, parent, reexec)
 	if err != nil {
 		return nil, vm.BlockContext{}, nil, nil, err
 	}
-
 	if txIndex == 0 && len(block.Transactions()) == 0 {
 		return nil, vm.BlockContext{}, statedb, release, nil
 	}
@@ -64,23 +62,19 @@ func (leth *LightEthereum) stateAtTransaction(ctx context.Context, block *types.
 		// Assemble the transaction call message and return if the requested offset
 		msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
 		txContext := core.NewEVMTxContext(msg)
-		blockContext := core.NewEVMBlockContext(block.Header(), leth.blockchain, nil)
+		context := core.NewEVMBlockContext(block.Header(), leth.blockchain, nil)
-
 		statedb.SetTxContext(tx.Hash(), idx)
-
 		if idx == txIndex {
-			return msg, blockContext, statedb, release, nil
+			return msg, context, statedb, release, nil
 		}
 		// Not yet the searched for transaction, execute on top of the current state
-		vmenv := vm.NewEVM(blockContext, txContext, statedb, leth.blockchain.Config(), vm.Config{})
+		vmenv := vm.NewEVM(context, txContext, statedb, leth.blockchain.Config(), vm.Config{})
-		// nolint : contextcheck
+		if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas()), contextLib.Background()); err != nil {
-		if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas()), context.Background()); err != nil {
 			return nil, vm.BlockContext{}, nil, nil, fmt.Errorf("transaction %#x failed: %v", tx.Hash(), err)
 		}
 		// Ensure any modifications are committed to the state
 		// Only delete empty objects if EIP158/161 (a.k.a Spurious Dragon) is in effect
 		statedb.Finalise(vmenv.ChainConfig().IsEIP158(block.Number()))
 	}
-
 	return nil, vm.BlockContext{}, nil, nil, fmt.Errorf("transaction index %d out of range for block %#x", txIndex, block.Hash())
 }

les/test_helper.go

@@ -189,7 +189,7 @@ func newTestClientHandler(backend *backends.SimulatedBackend, odr *LesOdr, index
 		}
 	)
 	genesis := gspec.MustCommit(db)
-	chain, _ := light.NewLightChain(odr, gspec.Config, engine)
+	chain, _ := light.NewLightChain(odr, gspec.Config, engine, nil)
 
 	client := &LightEthereum{
 		lesCommons: lesCommons{

les/txrelay.go

@@ -45,7 +45,6 @@ func newLesTxRelay(ps *serverPeerSet, retriever *retrieveManager) *lesTxRelay {
 		stop:      make(chan struct{}),
 	}
 	ps.subscribe(r)
-
 	return r
 }
 
@@ -61,7 +60,6 @@ func (ltrx *lesTxRelay) registerPeer(p *serverPeer) {
 	if p.onlyAnnounce {
 		return
 	}
-
 	ltrx.peerList = append(ltrx.peerList, p)
 }
 
@@ -89,31 +87,25 @@ func (ltrx *lesTxRelay) send(txs types.Transactions, count int) {
 
 	for _, tx := range txs {
 		hash := tx.Hash()
-
 		_, ok := ltrx.txSent[hash]
 		if !ok {
 			ltrx.txSent[hash] = tx
 			ltrx.txPending[hash] = struct{}{}
 		}
-
 		if len(ltrx.peerList) > 0 {
 			cnt := count
 			pos := ltrx.peerStartPos
-
 			for {
 				peer := ltrx.peerList[pos]
 				sendTo[peer] = append(sendTo[peer], tx)
-
 				cnt--
 				if cnt == 0 {
 					break // sent it to the desired number of peers
 				}
-
 				pos++
 				if pos == len(ltrx.peerList) {
 					pos = 0
 				}
-
 				if pos == ltrx.peerStartPos {
 					break // tried all available peers
 				}
@@ -142,7 +134,6 @@ func (ltrx *lesTxRelay) send(txs types.Transactions, count int) {
 				return func() { peer.sendTxs(reqID, len(ll), enc) }
 			},
 		}
-
 		go ltrx.retriever.retrieve(context.Background(), reqID, rq, func(p distPeer, msg *Msg) error { return nil }, ltrx.stop)
 	}
 }
@@ -169,12 +160,10 @@ func (ltrx *lesTxRelay) NewHead(head common.Hash, mined []common.Hash, rollback
 	if len(ltrx.txPending) > 0 {
 		txs := make(types.Transactions, len(ltrx.txPending))
 		i := 0
-
 		for hash := range ltrx.txPending {
 			txs[i] = ltrx.txSent[hash]
 			i++
 		}
-
 		ltrx.send(txs, 1)
 	}
 }

les/utils/exec_queue.go

@@ -31,9 +31,7 @@ type ExecQueue struct {
 func NewExecQueue(capacity int) *ExecQueue {
 	q := &ExecQueue{funcs: make([]func(), 0, capacity)}
 	q.cond = sync.NewCond(&q.mu)
-
 	go q.loop()
-
 	return q
 }
 
@@ -51,17 +49,14 @@ func (q *ExecQueue) waitNext(drop bool) (f func()) {
 		// dequeuing so len(q.funcs) includes the function that is running.
 		q.funcs = append(q.funcs[:0], q.funcs[1:]...)
 	}
-
 	for !q.isClosed() {
 		if len(q.funcs) > 0 {
 			f = q.funcs[0]
 			break
 		}
-
 		q.cond.Wait()
 	}
 	q.mu.Unlock()
-
 	return f
 }
 
@@ -74,21 +69,18 @@ func (q *ExecQueue) CanQueue() bool {
 	q.mu.Lock()
 	ok := !q.isClosed() && len(q.funcs) < cap(q.funcs)
 	q.mu.Unlock()
-
 	return ok
 }
 
 // Queue adds a function call to the execution Queue. Returns true if successful.
 func (q *ExecQueue) Queue(f func()) bool {
 	q.mu.Lock()
-
 	ok := !q.isClosed() && len(q.funcs) < cap(q.funcs)
 	if ok {
 		q.funcs = append(q.funcs, f)
 		q.cond.Signal()
 	}
 	q.mu.Unlock()
-
 	return ok
 }
 

les/utils/exec_queue_test.go

@@ -26,7 +26,6 @@ func TestExecQueue(t *testing.T) {
 		execd    = make(chan int)
 		testexit = make(chan struct{})
 	)
-
 	defer q.Quit()
 	defer close(testexit)
 
@@ -39,11 +38,9 @@ func TestExecQueue(t *testing.T) {
 			case <-testexit:
 			}
 		}
-
 		if q.CanQueue() != wantOK {
 			t.Fatalf("CanQueue() == %t for %s", !wantOK, state)
 		}
-
 		if q.Queue(qf) != wantOK {
 			t.Fatalf("Queue() == %t for %s", !wantOK, state)
 		}
@@ -53,7 +50,6 @@ func TestExecQueue(t *testing.T) {
 		check("queue below cap", true)
 	}
 	check("full queue", false)
-
 	for i := 0; i < N; i++ {
 		if c := <-execd; c != i {
 			t.Fatal("execution out of order")

les/utils/expiredvalue.go

@@ -77,17 +77,14 @@ func (e ExpiredValue) Value(logOffset Fixed64) uint64 {
 func (e *ExpiredValue) Add(amount int64, logOffset Fixed64) int64 {
 	integer, frac := logOffset.ToUint64(), logOffset.Fraction()
 	factor := frac.Pow2()
-
 	base := factor * float64(amount)
 	if integer < e.Exp {
 		base /= math.Pow(2, float64(e.Exp-integer))
 	}
-
 	if integer > e.Exp {
 		e.Base >>= (integer - e.Exp)
 		e.Exp = integer
 	}
-
 	if base >= 0 || uint64(-base) <= e.Base {
 		// The conversion from negative float64 to
 		// uint64 is undefined in golang, and doesn't
@@ -98,13 +95,10 @@ func (e *ExpiredValue) Add(amount int64, logOffset Fixed64) int64 {
 		} else {
 			e.Base -= uint64(-base)
 		}
-
 		return amount
 	}
-
 	net := int64(-float64(e.Base) / factor)
 	e.Base = 0
-
 	return net
 }
 
@@ -113,12 +107,10 @@ func (e *ExpiredValue) AddExp(a ExpiredValue) {
 	if e.Exp > a.Exp {
 		a.Base >>= (e.Exp - a.Exp)
 	}
-
 	if e.Exp < a.Exp {
 		e.Base >>= (a.Exp - e.Exp)
 		e.Exp = a.Exp
 	}
-
 	e.Base += a.Base
 }
 
@@ -127,12 +119,10 @@ func (e *ExpiredValue) SubExp(a ExpiredValue) {
 	if e.Exp > a.Exp {
 		a.Base >>= (e.Exp - a.Exp)
 	}
-
 	if e.Exp < a.Exp {
 		e.Base >>= (a.Exp - e.Exp)
 		e.Exp = a.Exp
 	}
-
 	if e.Base > a.Base {
 		e.Base -= a.Base
 	} else {
@@ -165,7 +155,6 @@ func (e LinearExpiredValue) Value(now mclock.AbsTime) uint64 {
 			e.Val = 0
 		}
 	}
-
 	return e.Val
 }
 
@@ -180,16 +169,13 @@ func (e *LinearExpiredValue) Add(amount int64, now mclock.AbsTime) uint64 {
 		} else {
 			e.Val = 0
 		}
-
 		e.Offset = offset
 	}
-
 	if amount < 0 && uint64(-amount) > e.Val {
 		e.Val = 0
 	} else {
 		e.Val = uint64(int64(e.Val) + amount)
 	}
-
 	return e.Val
 }
 
@@ -222,7 +208,6 @@ func (e *Expirer) SetRate(now mclock.AbsTime, rate float64) {
 	if dt > 0 {
 		e.logOffset += Fixed64(logToFixedFactor * float64(dt) * e.rate)
 	}
-
 	e.lastUpdate = now
 	e.rate = rate
 }
@@ -245,7 +230,6 @@ func (e *Expirer) LogOffset(now mclock.AbsTime) Fixed64 {
 	if dt <= 0 {
 		return e.logOffset
 	}
-
 	return e.logOffset + Fixed64(logToFixedFactor*float64(dt)*e.rate)
 }
 

les/utils/expiredvalue_test.go

@@ -34,7 +34,6 @@ func TestValueExpiration(t *testing.T) {
 		{ExpiredValue{Base: 128, Exp: 2}, Uint64ToFixed64(2), 128},
 		{ExpiredValue{Base: 128, Exp: 2}, Uint64ToFixed64(3), 64},
 	}
-
 	for _, c := range cases {
 		if got := c.input.Value(c.timeOffset); got != c.expect {
 			t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, got)
@@ -70,12 +69,10 @@ func TestValueAddition(t *testing.T) {
 		{ExpiredValue{Base: 128, Exp: 2}, -128, Uint64ToFixed64(1), 128, -128},
 		{ExpiredValue{Base: 128, Exp: 2}, -128, Uint64ToFixed64(2), 0, -128},
 	}
-
 	for _, c := range cases {
 		if net := c.input.Add(c.addend, c.timeOffset); net != c.expectNet {
 			t.Fatalf("Net amount mismatch, want=%d, got=%d", c.expectNet, net)
 		}
-
 		if got := c.input.Value(c.timeOffset); got != c.expect {
 			t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, got)
 		}
@@ -94,10 +91,8 @@ func TestExpiredValueAddition(t *testing.T) {
 		{ExpiredValue{Base: 128, Exp: 0}, ExpiredValue{Base: 128, Exp: 1}, Uint64ToFixed64(0), 384},
 		{ExpiredValue{Base: 128, Exp: 0}, ExpiredValue{Base: 128, Exp: 0}, Uint64ToFixed64(1), 128},
 	}
-
 	for _, c := range cases {
 		c.input.AddExp(c.another)
-
 		if got := c.input.Value(c.timeOffset); got != c.expect {
 			t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, got)
 		}
@@ -116,10 +111,8 @@ func TestExpiredValueSubtraction(t *testing.T) {
 		{ExpiredValue{Base: 128, Exp: 1}, ExpiredValue{Base: 128, Exp: 0}, Uint64ToFixed64(0), 128},
 		{ExpiredValue{Base: 128, Exp: 1}, ExpiredValue{Base: 128, Exp: 0}, Uint64ToFixed64(1), 64},
 	}
-
 	for _, c := range cases {
 		c.input.SubExp(c.another)
-
 		if got := c.input.Value(c.timeOffset); got != c.expect {
 			t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, got)
 		}
@@ -156,7 +149,6 @@ func TestLinearExpiredValue(t *testing.T) {
 			Rate:   mclock.AbsTime(1),
 		}, mclock.AbsTime(3), 0},
 	}
-
 	for _, c := range cases {
 		if value := c.value.Value(c.now); value != c.expect {
 			t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, value)
@@ -195,7 +187,6 @@ func TestLinearExpiredAddition(t *testing.T) {
 			Rate:   mclock.AbsTime(1),
 		}, -2, mclock.AbsTime(2), 0},
 	}
-
 	for _, c := range cases {
 		if value := c.value.Add(c.amount, c.now); value != c.expect {
 			t.Fatalf("Value mismatch, want=%d, got=%d", c.expect, value)

les/utils/limiter.go

@@ -17,10 +17,10 @@
 package utils
 
 import (
-	"sort"
 	"sync"
 
 	"github.com/ethereum/go-ethereum/p2p/enode"
+	"golang.org/x/exp/slices"
 )
 
 const maxSelectionWeight = 1000000000 // maximum selection weight of each individual node/address group
@@ -77,7 +77,6 @@ func (ag *addressGroup) add(nq *nodeQueue) {
 	if nq.groupIndex != -1 {
 		panic("added node queue is already in an address group")
 	}
-
 	l := len(ag.nodes)
 	nq.groupIndex = l
 	ag.nodes = append(ag.nodes, nq)
@@ -93,7 +92,6 @@ func (ag *addressGroup) update(nq *nodeQueue, weight uint64) {
 	if nq.groupIndex == -1 || nq.groupIndex >= len(ag.nodes) || ag.nodes[nq.groupIndex] != nq {
 		panic("updated node queue is not in this address group")
 	}
-
 	ag.sumFlatWeight += weight - nq.flatWeight
 	nq.flatWeight = weight
 	ag.groupWeight = ag.sumFlatWeight / uint64(len(ag.nodes))
@@ -112,17 +110,14 @@ func (ag *addressGroup) remove(nq *nodeQueue) {
 		ag.nodes[nq.groupIndex] = ag.nodes[l]
 		ag.nodes[nq.groupIndex].groupIndex = nq.groupIndex
 	}
-
 	nq.groupIndex = -1
 	ag.nodes = ag.nodes[:l]
 	ag.sumFlatWeight -= nq.flatWeight
-
 	if l >= 1 {
 		ag.groupWeight = ag.sumFlatWeight / uint64(l)
 	} else {
 		ag.groupWeight = 0
 	}
-
 	ag.nodeSelect.Remove(nq)
 }
 
@@ -141,9 +136,7 @@ func NewLimiter(sumCostLimit uint) *Limiter {
 		sumCostLimit:  sumCostLimit,
 	}
 	l.cond = sync.NewCond(&l.lock)
-
 	go l.processLoop()
-
 	return l
 }
 
@@ -154,33 +147,25 @@ func (l *Limiter) selectionWeights(reqCost uint, value float64) (flatWeight, val
 	if value > l.maxValue {
 		l.maxValue = value
 	}
-
 	if value > 0 {
 		// normalize value to <= 1
 		value /= l.maxValue
 	}
-
 	if reqCost > l.maxCost {
 		l.maxCost = reqCost
 	}
-
 	relCost := float64(reqCost) / float64(l.maxCost)
-
 	var f float64
-
 	if relCost <= 0.001 {
 		f = 1
 	} else {
 		f = 0.001 / relCost
 	}
-
 	f *= maxSelectionWeight
-
 	flatWeight, valueWeight = uint64(f), uint64(f*value)
 	if flatWeight == 0 {
 		flatWeight = 1
 	}
-
 	return
 }
 
@@ -198,17 +183,14 @@ func (l *Limiter) Add(id enode.ID, address string, value float64, reqCost uint)
 		close(process)
 		return process
 	}
-
 	if reqCost == 0 {
 		reqCost = 1
 	}
-
 	if nq, ok := l.nodes[id]; ok {
 		if nq.queue != nil {
 			nq.queue = append(nq.queue, request{process, reqCost})
 			nq.sumCost += reqCost
 			nq.value = value
-
 			if address != nq.address {
 				// known id sending request from a new address, move to different address group
 				l.removeFromGroup(nq)
@@ -219,7 +201,6 @@ func (l *Limiter) Add(id enode.ID, address string, value float64, reqCost uint)
 			nq.penaltyCost += reqCost
 			l.update(nq)
 			close(process)
-
 			return process
 		}
 	} else {
@@ -231,24 +212,19 @@ func (l *Limiter) Add(id enode.ID, address string, value float64, reqCost uint)
 			groupIndex: -1,
 		}
 		nq.flatWeight, nq.valueWeight = l.selectionWeights(reqCost, value)
-
 		if len(l.nodes) == 0 {
 			l.cond.Signal()
 		}
-
 		l.nodes[id] = nq
 		if nq.valueWeight != 0 {
 			l.valueSelect.Update(nq)
 		}
-
 		l.addToGroup(nq, address)
 	}
-
 	l.sumCost += reqCost
 	if l.sumCost > l.sumCostLimit {
 		l.dropRequests()
 	}
-
 	return process
 }
 
@@ -260,12 +236,10 @@ func (l *Limiter) update(nq *nodeQueue) {
 	} else {
 		cost = nq.penaltyCost
 	}
-
 	flatWeight, valueWeight := l.selectionWeights(cost, nq.value)
 	ag := l.addresses[nq.address]
 	ag.update(nq, flatWeight)
 	l.addressSelect.Update(ag)
-
 	nq.valueWeight = valueWeight
 	l.valueSelect.Update(nq)
 }
@@ -274,13 +248,11 @@ func (l *Limiter) update(nq *nodeQueue) {
 // it does not exist yet.
 func (l *Limiter) addToGroup(nq *nodeQueue, address string) {
 	nq.address = address
-
 	ag := l.addresses[address]
 	if ag == nil {
 		ag = &addressGroup{nodeSelect: NewWeightedRandomSelect(flatWeight)}
 		l.addresses[address] = ag
 	}
-
 	ag.add(nq)
 	l.addressSelect.Update(ag)
 }
@@ -289,11 +261,9 @@ func (l *Limiter) addToGroup(nq *nodeQueue, address string) {
 func (l *Limiter) removeFromGroup(nq *nodeQueue) {
 	ag := l.addresses[nq.address]
 	ag.remove(nq)
-
 	if len(ag.nodes) == 0 {
 		delete(l.addresses, nq.address)
 	}
-
 	l.addressSelect.Update(ag)
 }
 
@@ -301,11 +271,9 @@ func (l *Limiter) removeFromGroup(nq *nodeQueue) {
 // selector
 func (l *Limiter) remove(nq *nodeQueue) {
 	l.removeFromGroup(nq)
-
 	if nq.valueWeight != 0 {
 		l.valueSelect.Remove(nq)
 	}
-
 	delete(l.nodes, nq.id)
 }
 
@@ -317,10 +285,8 @@ func (l *Limiter) choose() *nodeQueue {
 			return ag.choose()
 		}
 	}
-
 	nq, _ := l.valueSelect.Choose().(*nodeQueue)
 	l.selectAddressNext = true
-
 	return nq
 }
 
@@ -336,23 +302,19 @@ func (l *Limiter) processLoop() {
 					close(request.process)
 				}
 			}
-
 			return
 		}
-
 		nq := l.choose()
 		if nq == nil {
 			l.cond.Wait()
 			continue
 		}
-
 		if nq.queue != nil {
 			request := nq.queue[0]
 			nq.queue = nq.queue[1:]
 			nq.sumCost -= request.cost
 			l.sumCost -= request.cost
 			l.lock.Unlock()
-
 			ch := make(chan struct{})
 			request.process <- ch
 			<-ch
@@ -391,29 +353,31 @@ func (l *Limiter) dropRequests() {
 		sumValue float64
 		list     []dropListItem
 	)
-
 	for _, nq := range l.nodes {
 		sumValue += nq.value
 	}
-
 	for _, nq := range l.nodes {
 		if nq.sumCost == 0 {
 			continue
 		}
-
 		w := 1 / float64(len(l.addresses)*len(l.addresses[nq.address].nodes))
 		if sumValue > 0 {
 			w += nq.value / sumValue
 		}
-
 		list = append(list, dropListItem{
 			nq:       nq,
 			priority: w / float64(nq.sumCost),
 		})
 	}
-
+	slices.SortFunc(list, func(a, b dropListItem) int {
-	sort.Sort(list)
+		if a.priority < b.priority {
-
+			return -1
+		}
+		if a.priority < b.priority {
+			return 1
+		}
+		return 0
+	})
 	for _, item := range list {
 		for _, request := range item.nq.queue {
 			close(request.process)
@@ -427,7 +391,6 @@ func (l *Limiter) dropRequests() {
 		l.sumCost -= item.nq.sumCost // penalty costs are not counted in sumCost
 		item.nq.sumCost = 0
 		l.update(item.nq)
-
 		if l.sumCost <= l.sumCostLimit/2 {
 			return
 		}

les/utils/limiter_test.go

@@ -58,26 +58,21 @@ func (lt *limTest) request(n *ltNode) {
 		address string
 		id      enode.ID
 	)
-
 	if n.addr >= 0 {
 		address = string([]byte{byte(n.addr)})
 	} else {
 		var b [32]byte
-
 		rand.Read(b[:])
 		address = string(b[:])
 	}
-
 	if n.id >= 0 {
 		id = enode.ID{byte(n.id)}
 	} else {
 		rand.Read(id[:])
 	}
-
 	lt.runCount++
 	n.runCount++
 	cch := lt.limiter.Add(id, address, n.value, n.cost)
-
 	go func() {
 		lt.results <- ltResult{n, <-cch}
 	}()
@@ -88,10 +83,8 @@ func (lt *limTest) moreRequests(n *ltNode) {
 	if maxStart != 0 {
 		n.lastTotalCost = lt.totalCost
 	}
-
 	for n.reqMax > n.runCount && maxStart > 0 {
 		lt.request(n)
-
 		maxStart--
 	}
 }
@@ -99,14 +92,12 @@ func (lt *limTest) moreRequests(n *ltNode) {
 func (lt *limTest) process() {
 	res := <-lt.results
 	lt.runCount--
-
 	res.node.runCount--
 	if res.ch != nil {
 		res.node.served++
 		if res.node.exp != 0 {
 			lt.expCost += res.node.cost
 		}
-
 		lt.totalCost += res.node.cost
 		close(res.ch)
 	} else {
@@ -169,53 +160,41 @@ func TestLimiter(t *testing.T) {
 	for _, test := range limTests {
 		lt.expCost, lt.totalCost = 0, 0
 		iterCount := 10000
-
 		for j := 0; j < ltRounds; j++ {
 			// try to reach expected target range in multiple rounds with increasing iteration counts
 			last := j == ltRounds-1
-
 			for _, n := range test {
 				lt.request(n)
 			}
-
 			for i := 0; i < iterCount; i++ {
 				lt.process()
-
 				for _, n := range test {
 					lt.moreRequests(n)
 				}
 			}
-
 			for lt.runCount > 0 {
 				lt.process()
 			}
-
 			if spamRatio := 1 - float64(lt.expCost)/float64(lt.totalCost); spamRatio > 0.5*(1+ltTolerance) {
 				t.Errorf("Spam ratio too high (%f)", spamRatio)
 			}
-
 			fail, success := false, true
-
 			for _, n := range test {
 				if n.exp != 0 {
 					if n.dropped > 0 {
 						t.Errorf("Dropped %d requests of non-spam node", n.dropped)
-
 						fail = true
 					}
-
 					r := float64(n.served) * float64(n.cost) / float64(lt.expCost)
 					if r < n.exp*(1-ltTolerance) || r > n.exp*(1+ltTolerance) {
 						if last {
 							// print error only if the target is still not reached in the last round
 							t.Errorf("Request ratio (%f) does not match expected value (%f)", r, n.exp)
 						}
-
 						success = false
 					}
 				}
 			}
-
 			if fail || success {
 				break
 			}
@@ -223,6 +202,5 @@ func TestLimiter(t *testing.T) {
 			iterCount *= 2
 		}
 	}
-
 	lt.limiter.Stop()
 }

les/utils/timeutils.go

@@ -39,7 +39,6 @@ func NewUpdateTimer(clock mclock.Clock, threshold time.Duration) *UpdateTimer {
 	if clock == nil {
 		clock = mclock.System{}
 	}
-
 	return &UpdateTimer{
 		clock:     clock,
 		last:      clock.Now(),
@@ -59,15 +58,12 @@ func (t *UpdateTimer) UpdateAt(at mclock.AbsTime, callback func(diff time.Durati
 	if diff < 0 {
 		diff = 0
 	}
-
 	if diff < t.threshold {
 		return false
 	}
-
 	if callback(diff) {
 		t.last = at
 		return true
 	}
-
 	return false
 }

les/utils/timeutils_test.go

@@ -28,24 +28,18 @@ func TestUpdateTimer(t *testing.T) {
 	if timer != nil {
 		t.Fatalf("Create update timer with negative threshold")
 	}
-
 	sim := &mclock.Simulated{}
-
 	timer = NewUpdateTimer(sim, time.Second)
 	if updated := timer.Update(func(diff time.Duration) bool { return true }); updated {
 		t.Fatalf("Update the clock without reaching the threshold")
 	}
-
 	sim.Run(time.Second)
-
 	if updated := timer.Update(func(diff time.Duration) bool { return true }); !updated {
 		t.Fatalf("Doesn't update the clock when reaching the threshold")
 	}
-
 	if updated := timer.UpdateAt(sim.Now().Add(time.Second), func(diff time.Duration) bool { return true }); !updated {
 		t.Fatalf("Doesn't update the clock when reaching the threshold")
 	}
-
 	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")

les/utils/weighted_select.go

@@ -60,17 +60,14 @@ func (w *WeightedRandomSelect) setWeight(item WrsItem, weight uint64) {
 	if weight > math.MaxInt64-w.root.sumCost {
 		// old weight is still included in sumCost, remove and check again
 		w.setWeight(item, 0)
-
 		if weight > math.MaxInt64-w.root.sumCost {
 			log.Error("WeightedRandomSelect overflow", "sumCost", w.root.sumCost, "new weight", weight)
 			weight = math.MaxInt64 - w.root.sumCost
 		}
 	}
-
 	idx, ok := w.idx[item]
 	if ok {
 		w.root.setWeight(idx, weight)
-
 		if weight == 0 {
 			delete(w.idx, item)
 		}
@@ -83,7 +80,6 @@ func (w *WeightedRandomSelect) setWeight(item WrsItem, weight uint64) {
 				newRoot.weights[0] = w.root.sumCost
 				w.root = newRoot
 			}
-
 			w.idx[item] = w.root.insert(item, weight)
 		}
 	}
@@ -98,15 +94,12 @@ func (w *WeightedRandomSelect) Choose() WrsItem {
 		if w.root.sumCost == 0 {
 			return nil
 		}
-
 		val := uint64(rand.Int63n(int64(w.root.sumCost)))
 		choice, lastWeight := w.root.choose(val)
 		weight := w.wfn(choice)
-
 		if weight != lastWeight {
 			w.setWeight(choice, weight)
 		}
-
 		if weight >= lastWeight || uint64(rand.Int63n(int64(lastWeight))) < weight {
 			return choice
 		}
@@ -132,16 +125,13 @@ func (n *wrsNode) insert(item WrsItem, weight uint64) int {
 			panic(nil)
 		}
 	}
-
 	n.itemCnt++
 	n.sumCost += weight
 	n.weights[branch] += weight
-
 	if n.level == 0 {
 		n.items[branch] = item
 		return branch
 	}
-
 	var subNode *wrsNode
 	if n.items[branch] == nil {
 		subNode = &wrsNode{maxItems: n.maxItems / wrsBranches, level: n.level - 1}
@@ -149,9 +139,7 @@ func (n *wrsNode) insert(item WrsItem, weight uint64) int {
 	} else {
 		subNode = n.items[branch].(*wrsNode)
 	}
-
 	subIdx := subNode.insert(item, weight)
-
 	return subNode.maxItems*branch + subIdx
 }
 
@@ -162,26 +150,21 @@ func (n *wrsNode) setWeight(idx int, weight uint64) uint64 {
 		oldWeight := n.weights[idx]
 		n.weights[idx] = weight
 		diff := weight - oldWeight
-
 		n.sumCost += diff
 		if weight == 0 {
 			n.items[idx] = nil
 			n.itemCnt--
 		}
-
 		return diff
 	}
-
 	branchItems := n.maxItems / wrsBranches
 	branch := idx / branchItems
 	diff := n.items[branch].(*wrsNode).setWeight(idx-branch*branchItems, weight)
 	n.weights[branch] += diff
 	n.sumCost += diff
-
 	if weight == 0 {
 		n.itemCnt--
 	}
-
 	return diff
 }
 
@@ -192,12 +175,9 @@ func (n *wrsNode) choose(val uint64) (WrsItem, uint64) {
 			if n.level == 0 {
 				return n.items[i].(WrsItem), n.weights[i]
 			}
-
 			return n.items[i].(*wrsNode).choose(val)
 		}
-
 		val -= w
 	}
-
 	panic(nil)
 }

les/utils/weighted_select_test.go

@@ -29,11 +29,9 @@ type testWrsItem struct {
 func testWeight(i interface{}) uint64 {
 	t := i.(*testWrsItem)
 	w := *t.widx
-
 	if w == -1 || w == t.idx {
 		return uint64(t.idx + 1)
 	}
-
 	return 0
 }
 
@@ -42,14 +40,11 @@ func TestWeightedRandomSelect(t *testing.T) {
 		s := NewWeightedRandomSelect(testWeight)
 		w := -1
 		list := make([]testWrsItem, cnt)
-
 		for i := range list {
 			list[i] = testWrsItem{idx: i, widx: &w}
 			s.Update(&list[i])
 		}
-
 		w = rand.Intn(cnt)
-
 		c := s.Choose()
 		if c == nil {
 			t.Errorf("expected item, got nil")
@@ -58,9 +53,7 @@ func TestWeightedRandomSelect(t *testing.T) {
 				t.Errorf("expected another item")
 			}
 		}
-
 		w = -2
-
 		if s.Choose() != nil {
 			t.Errorf("expected nil, got item")
 		}

les/vflux/client/api.go

@@ -39,7 +39,6 @@ func parseNodeStr(nodeStr string) (enode.ID, error) {
 	if id, err := enode.ParseID(nodeStr); err == nil {
 		return id, nil
 	}
-
 	if node, err := enode.Parse(enode.ValidSchemes, nodeStr); err == nil {
 		return node.ID(), nil
 	} else {
@@ -64,11 +63,9 @@ func (api *PrivateClientAPI) Distribution(nodeStr string, normalized bool) (RtDi
 	if !normalized {
 		expFactor = utils.ExpFactor(api.vt.StatsExpirer().LogOffset(mclock.Now()))
 	}
-
 	if nodeStr == "" {
 		return api.vt.RtStats().Distribution(normalized, expFactor), nil
 	}
-
 	if id, err := parseNodeStr(nodeStr); err == nil {
 		return api.vt.GetNode(id).RtStats().Distribution(normalized, expFactor), nil
 	} else {
@@ -87,7 +84,6 @@ func (api *PrivateClientAPI) Timeout(nodeStr string, failRate float64) (float64,
 	if nodeStr == "" {
 		return float64(api.vt.RtStats().Timeout(failRate)) / float64(time.Second), nil
 	}
-
 	if id, err := parseNodeStr(nodeStr); err == nil {
 		return float64(api.vt.GetNode(id).RtStats().Timeout(failRate)) / float64(time.Second), nil
 	} else {
@@ -100,11 +96,9 @@ func (api *PrivateClientAPI) Timeout(nodeStr string, failRate float64) (float64,
 func (api *PrivateClientAPI) Value(nodeStr string, timeout float64) (float64, error) {
 	wt := TimeoutWeights(time.Duration(timeout * float64(time.Second)))
 	expFactor := utils.ExpFactor(api.vt.StatsExpirer().LogOffset(mclock.Now()))
-
 	if nodeStr == "" {
 		return api.vt.RtStats().Value(wt, expFactor), nil
 	}
-
 	if id, err := parseNodeStr(nodeStr); err == nil {
 		return api.vt.GetNode(id).RtStats().Value(wt, expFactor), nil
 	} else {

les/vflux/client/fillset.go

@@ -52,11 +52,9 @@ func NewFillSet(ns *nodestate.NodeStateMachine, input enode.Iterator, flags node
 		if oldState.Equals(flags) {
 			fs.count--
 		}
-
 		if newState.Equals(flags) {
 			fs.count++
 		}
-
 		if fs.target > fs.count {
 			fs.cond.Signal()
 		}
@@ -64,7 +62,6 @@ func NewFillSet(ns *nodestate.NodeStateMachine, input enode.Iterator, flags node
 	})
 
 	go fs.readLoop()
-
 	return fs
 }
 
@@ -78,11 +75,9 @@ func (fs *FillSet) readLoop() {
 		}
 
 		fs.lock.Unlock()
-
 		if !fs.input.Next() {
 			return
 		}
-
 		fs.ns.SetState(fs.input.Node(), fs.flags, nodestate.Flags{}, 0)
 	}
 }

les/vflux/client/fillset_test.go

@@ -37,9 +37,7 @@ func (i *testIter) Next() bool {
 	if _, ok := <-i.waitCh; !ok {
 		return false
 	}
-
 	i.node = <-i.nodeCh
-
 	return true
 }
 
@@ -53,7 +51,6 @@ func (i *testIter) Close() {
 
 func (i *testIter) push() {
 	var id enode.ID
-
 	rand.Read(id[:])
 	i.nodeCh <- enode.SignNull(new(enr.Record), id)
 }
@@ -81,7 +78,6 @@ func TestFillSet(t *testing.T) {
 			if !iter.waiting(time.Second * 10) {
 				t.Fatalf("FillSet not waiting for new nodes")
 			}
-
 			if push {
 				iter.push()
 			}

les/vflux/client/queueiterator.go

@@ -50,7 +50,6 @@ func NewQueueIterator(ns *nodestate.NodeStateMachine, requireFlags, disableFlags
 	ns.SubscribeState(requireFlags.Or(disableFlags), func(n *enode.Node, oldState, newState nodestate.Flags) {
 		oldMatch := oldState.HasAll(requireFlags) && oldState.HasNone(disableFlags)
 		newMatch := newState.HasAll(requireFlags) && newState.HasNone(disableFlags)
-
 		if newMatch == oldMatch {
 			return
 		}
@@ -66,15 +65,12 @@ func NewQueueIterator(ns *nodestate.NodeStateMachine, requireFlags, disableFlags
 				if qn.ID() == id {
 					copy(qi.queue[i:len(qi.queue)-1], qi.queue[i+1:])
 					qi.queue = qi.queue[:len(qi.queue)-1]
-
 					break
 				}
 			}
 		}
-
 		qi.cond.Signal()
 	})
-
 	return qi
 }
 
@@ -85,20 +81,16 @@ func (qi *QueueIterator) Next() bool {
 		if qi.waitCallback != nil {
 			qi.waitCallback(true)
 		}
-
 		for !qi.closed && len(qi.queue) == 0 {
 			qi.cond.Wait()
 		}
-
 		if qi.waitCallback != nil {
 			qi.waitCallback(false)
 		}
 	}
-
 	if qi.closed {
 		qi.nextNode = nil
 		qi.lock.Unlock()
-
 		return false
 	}
 	// Move to the next node in queue.
@@ -111,7 +103,6 @@ func (qi *QueueIterator) Next() bool {
 		qi.queue = qi.queue[:len(qi.queue)-1]
 	}
 	qi.lock.Unlock()
-
 	return true
 }
 

les/vflux/client/queueiterator_test.go

@@ -42,11 +42,9 @@ func testQueueIterator(t *testing.T, fifo bool) {
 	ns := nodestate.NewNodeStateMachine(nil, nil, &mclock.Simulated{}, testSetup)
 	qi := NewQueueIterator(ns, sfTest2, sfTest3.Or(sfTest4), fifo, nil)
 	ns.Start()
-
 	for i := 1; i <= iterTestNodeCount; i++ {
 		ns.SetState(testNode(i), sfTest1, nodestate.Flags{}, 0)
 	}
-
 	next := func() int {
 		ch := make(chan struct{})
 		go func() {
@@ -58,10 +56,8 @@ func testQueueIterator(t *testing.T, fifo bool) {
 		case <-time.After(time.Second * 5):
 			t.Fatalf("Iterator.Next() timeout")
 		}
-
 		node := qi.Node()
 		ns.SetState(node, sfTest4, nodestate.Flags{}, 0)
-
 		return testNodeIndex(node.ID())
 	}
 	exp := func(i int) {

les/vflux/client/requestbasket.go

@@ -80,10 +80,8 @@ func (b *requestBasket) setExp(exp uint64) {
 			item.value >>= shift
 			b.items[i] = item
 		}
-
 		b.exp = exp
 	}
-
 	if exp < b.exp {
 		shift := b.exp - exp
 		for i, item := range b.items {
@@ -91,7 +89,6 @@ func (b *requestBasket) setExp(exp uint64) {
 			item.value <<= shift
 			b.items[i] = item
 		}
-
 		b.exp = exp
 	}
 }
@@ -127,23 +124,18 @@ func (s *serverBasket) transfer(ratio float64) requestBasket {
 		items: make([]basketItem, len(s.basket.items)),
 		exp:   s.basket.exp,
 	}
-
 	for i, v := range s.basket.items {
 		ta := uint64(float64(v.amount) * ratio)
 		tv := uint64(float64(v.value) * ratio)
-
 		if ta > v.amount {
 			ta = v.amount
 		}
-
 		if tv > v.value {
 			tv = v.value
 		}
-
 		s.basket.items[i] = basketItem{v.amount - ta, v.value - tv}
 		res.items[i] = basketItem{ta, tv}
 	}
-
 	return res
 }
 
@@ -165,22 +157,18 @@ func (r *referenceBasket) add(newBasket requestBasket) {
 		totalCost  uint64
 		totalValue float64
 	)
-
 	for i, v := range newBasket.items {
 		totalCost += v.value
 		totalValue += float64(v.amount) * r.reqValues[i]
 	}
-
 	if totalCost > 0 {
 		// add to reference with scaled values
 		scaleValues := totalValue / float64(totalCost)
-
 		for i, v := range newBasket.items {
 			r.basket.items[i].amount += v.amount
 			r.basket.items[i].value += uint64(float64(v.value) * scaleValues)
 		}
 	}
-
 	r.updateReqValues()
 }
 
@@ -204,7 +192,6 @@ func (r *referenceBasket) normalize() {
 		sumAmount += b.amount
 		sumValue += b.value
 	}
-
 	add := float64(int64(sumAmount-sumValue)) / float64(sumValue)
 	for i, b := range r.basket.items {
 		b.value += uint64(int64(float64(b.value) * add))
@@ -219,16 +206,13 @@ func (r *referenceBasket) reqValueFactor(costList []uint64) float64 {
 		totalCost  float64
 		totalValue uint64
 	)
-
 	for i, b := range r.basket.items {
 		totalCost += float64(costList[i]) * float64(b.amount) // use floats to avoid overflow
 		totalValue += b.value
 	}
-
 	if totalCost < 1 {
 		return 0
 	}
-
 	return float64(totalValue) * basketFactor / totalCost
 }
 
@@ -242,13 +226,10 @@ func (b *basketItem) DecodeRLP(s *rlp.Stream) error {
 	var item struct {
 		Amount, Value uint64
 	}
-
 	if err := s.Decode(&item); err != nil {
 		return err
 	}
-
 	b.amount, b.value = item.Amount, item.Value
-
 	return nil
 }
 
@@ -263,13 +244,10 @@ func (r *requestBasket) DecodeRLP(s *rlp.Stream) error {
 		Items []basketItem
 		Exp   uint64
 	}
-
 	if err := s.Decode(&enc); err != nil {
 		return err
 	}
-
 	r.items, r.exp = enc.Items, enc.Exp
-
 	return nil
 }
 
@@ -283,11 +261,8 @@ func (r requestBasket) convertMapping(oldMapping, newMapping []string, initBaske
 	for i, name := range oldMapping {
 		nameMap[name] = i
 	}
-
 	rc := requestBasket{items: make([]basketItem, len(newMapping))}
-
 	var scale, oldScale, newScale float64
-
 	for i, name := range newMapping {
 		if ii, ok := nameMap[name]; ok {
 			rc.items[i] = r.items[ii]
@@ -295,19 +270,16 @@ func (r requestBasket) convertMapping(oldMapping, newMapping []string, initBaske
 			newScale += float64(rc.items[i].amount) * float64(initBasket.items[i].amount)
 		}
 	}
-
 	if oldScale > 1e-10 {
 		scale = newScale / oldScale
 	} else {
 		scale = 1
 	}
-
 	for i, name := range newMapping {
 		if _, ok := nameMap[name]; !ok {
 			rc.items[i].amount = uint64(float64(initBasket.items[i].amount) * scale)
 			rc.items[i].value = uint64(float64(initBasket.items[i].value) * scale)
 		}
 	}
-
 	return rc
 }

les/vflux/client/requestbasket_test.go

@@ -37,11 +37,9 @@ func checkF64(t *testing.T, name string, value, exp, tol float64) {
 
 func TestServerBasket(t *testing.T) {
 	var s serverBasket
-
 	s.init(2)
 	// add some requests with different request value factors
 	s.updateRvFactor(1)
-
 	noexp := utils.ExpirationFactor{Factor: 1}
 	s.add(0, 1000, 10000, noexp)
 	s.add(1, 3000, 60000, noexp)
@@ -85,13 +83,11 @@ func TestConvertMapping(t *testing.T) {
 
 func TestReqValueFactor(t *testing.T) {
 	var ref referenceBasket
-
 	ref.basket = requestBasket{items: make([]basketItem, 4)}
 	for i := range ref.basket.items {
 		ref.basket.items[i].amount = uint64(i+1) * basketFactor
 		ref.basket.items[i].value = uint64(i+1) * basketFactor
 	}
-
 	ref.init(4)
 	rvf := ref.reqValueFactor([]uint64{1000, 2000, 3000, 4000})
 	// expected value is (1000000+2000000+3000000+4000000) / (1*1000+2*2000+3*3000+4*4000) = 10000000/30000 = 333.333
@@ -103,7 +99,6 @@ func TestNormalize(t *testing.T) {
 		// Initialize data for testing
 		valueRange, lower := 1000000, 1000000
 		ref := referenceBasket{basket: requestBasket{items: make([]basketItem, 10)}}
-
 		for i := 0; i < 10; i++ {
 			ref.basket.items[i].amount = uint64(rand.Intn(valueRange) + lower)
 			ref.basket.items[i].value = uint64(rand.Intn(valueRange) + lower)
@@ -116,7 +111,6 @@ func TestNormalize(t *testing.T) {
 			sumAmount += ref.basket.items[i].amount
 			sumValue += ref.basket.items[i].value
 		}
-
 		var epsilon = 0.01
 		if float64(sumAmount)*(1+epsilon) < float64(sumValue) || float64(sumAmount)*(1-epsilon) > float64(sumValue) {
 			t.Fatalf("Failed to normalize sumAmount: %d sumValue: %d", sumAmount, sumValue)
@@ -126,31 +120,24 @@ func TestNormalize(t *testing.T) {
 
 func TestReqValueAdjustment(t *testing.T) {
 	var s1, s2 serverBasket
-
 	s1.init(3)
 	s2.init(3)
-
 	cost1 := []uint64{30000, 60000, 90000}
 	cost2 := []uint64{100000, 200000, 300000}
-
 	var ref referenceBasket
-
 	ref.basket = requestBasket{items: make([]basketItem, 3)}
 	for i := range ref.basket.items {
 		ref.basket.items[i].amount = 123 * basketFactor
 		ref.basket.items[i].value = 123 * basketFactor
 	}
-
 	ref.init(3)
 	// initial reqValues are expected to be {1, 1, 1}
 	checkF64(t, "reqValues[0]", ref.reqValues[0], 1, 0.01)
 	checkF64(t, "reqValues[1]", ref.reqValues[1], 1, 0.01)
 	checkF64(t, "reqValues[2]", ref.reqValues[2], 1, 0.01)
-
 	var logOffset utils.Fixed64
 	for period := 0; period < 1000; period++ {
 		exp := utils.ExpFactor(logOffset)
-
 		s1.updateRvFactor(ref.reqValueFactor(cost1))
 		s2.updateRvFactor(ref.reqValueFactor(cost2))
 		// throw in random requests into each basket using their internal pricing
@@ -166,7 +153,6 @@ func TestReqValueAdjustment(t *testing.T) {
 		ref.add(s2.transfer(0.1))
 		ref.normalize()
 		ref.updateReqValues()
-
 		logOffset += utils.Float64ToFixed64(0.1)
 	}
 	checkF64(t, "reqValues[0]", ref.reqValues[0], 0.5, 0.01)