Merge branch 'portal' into feature_offer

Dockerfile.alltools

@@ -4,7 +4,7 @@ ARG VERSION=""
 ARG BUILDNUM=""
 
 # Build Geth in a stock Go builder container
-FROM golang:1.20-alpine as builder
+FROM golang:1.21-alpine as builder
 
 RUN apk add --no-cache gcc musl-dev linux-headers git
 

accounts/abi/argument.go

@@ -80,7 +80,7 @@ func (arguments Arguments) isTuple() bool {
 func (arguments Arguments) Unpack(data []byte) ([]interface{}, error) {
 	if len(data) == 0 {
 		if len(arguments.NonIndexed()) != 0 {
-			return nil, errors.New("abi: attempting to unmarshall an empty string while arguments are expected")
+			return nil, errors.New("abi: attempting to unmarshal an empty string while arguments are expected")
 		}
 		return make([]interface{}, 0), nil
 	}
@@ -95,7 +95,7 @@ func (arguments Arguments) UnpackIntoMap(v map[string]interface{}, data []byte)
 	}
 	if len(data) == 0 {
 		if len(arguments.NonIndexed()) != 0 {
-			return errors.New("abi: attempting to unmarshall an empty string while arguments are expected")
+			return errors.New("abi: attempting to unmarshal an empty string while arguments are expected")
 		}
 		return nil // Nothing to unmarshal, return
 	}

accounts/abi/bind/util_test.go

@@ -121,7 +121,7 @@ func TestWaitDeployedCornerCases(t *testing.T) {
 	backend.Commit()
 	notContentCreation := errors.New("tx is not contract creation")
 	if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != notContentCreation.Error() {
-		t.Errorf("error missmatch: want %q, got %q, ", notContentCreation, err)
+		t.Errorf("error mismatch: want %q, got %q, ", notContentCreation, err)
 	}
 
 	// Create a transaction that is not mined.
@@ -131,7 +131,7 @@ func TestWaitDeployedCornerCases(t *testing.T) {
 	go func() {
 		contextCanceled := errors.New("context canceled")
 		if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != contextCanceled.Error() {
-			t.Errorf("error missmatch: want %q, got %q, ", contextCanceled, err)
+			t.Errorf("error mismatch: want %q, got %q, ", contextCanceled, err)
 		}
 	}()
 

accounts/abi/error.go

@@ -18,7 +18,6 @@ package abi
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"strings"
 
@@ -84,10 +83,10 @@ func (e Error) String() string {
 
 func (e *Error) Unpack(data []byte) (interface{}, error) {
 	if len(data) < 4 {
-		return "", errors.New("invalid data for unpacking")
+		return "", fmt.Errorf("insufficient data for unpacking: have %d, want at least 4", len(data))
 	}
 	if !bytes.Equal(data[:4], e.ID[:4]) {
-		return "", errors.New("invalid data for unpacking")
+		return "", fmt.Errorf("invalid identifier, have %#x want %#x", data[:4], e.ID[:4])
 	}
 	return e.Inputs.Unpack(data[4:])
 }

accounts/abi/unpack_test.go

@@ -206,13 +206,13 @@ var unpackTests = []unpackTest{
 		def:  `[{"type":"bool"}]`,
 		enc:  "",
 		want: false,
-		err:  "abi: attempting to unmarshall an empty string while arguments are expected",
+		err:  "abi: attempting to unmarshal an empty string while arguments are expected",
 	},
 	{
 		def:  `[{"type":"bytes32","indexed":true},{"type":"uint256","indexed":false}]`,
 		enc:  "",
 		want: false,
-		err:  "abi: attempting to unmarshall an empty string while arguments are expected",
+		err:  "abi: attempting to unmarshal an empty string while arguments are expected",
 	},
 	{
 		def:  `[{"type":"bool","indexed":true},{"type":"uint64","indexed":true}]`,

accounts/keystore/account_cache_test.go

@@ -68,7 +68,7 @@ func waitWatcherStart(ks *KeyStore) bool {
 
 func waitForAccounts(wantAccounts []accounts.Account, ks *KeyStore) error {
 	var list []accounts.Account
-	for t0 := time.Now(); time.Since(t0) < 5*time.Second; time.Sleep(200 * time.Millisecond) {
+	for t0 := time.Now(); time.Since(t0) < 5*time.Second; time.Sleep(100 * time.Millisecond) {
 		list = ks.Accounts()
 		if reflect.DeepEqual(list, wantAccounts) {
 			// ks should have also received change notifications
@@ -350,7 +350,7 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 		return
 	}
 	// needed so that modTime of `file` is different to its current value after forceCopyFile
-	time.Sleep(time.Second)
+	os.Chtimes(file, time.Now().Add(-time.Second), time.Now().Add(-time.Second))
 
 	// Now replace file contents
 	if err := forceCopyFile(file, cachetestAccounts[1].URL.Path); err != nil {
@@ -366,7 +366,7 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 	}
 
 	// needed so that modTime of `file` is different to its current value after forceCopyFile
-	time.Sleep(time.Second)
+	os.Chtimes(file, time.Now().Add(-time.Second), time.Now().Add(-time.Second))
 
 	// Now replace file contents again
 	if err := forceCopyFile(file, cachetestAccounts[2].URL.Path); err != nil {
@@ -382,7 +382,7 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 	}
 
 	// needed so that modTime of `file` is different to its current value after os.WriteFile
-	time.Sleep(time.Second)
+	os.Chtimes(file, time.Now().Add(-time.Second), time.Now().Add(-time.Second))
 
 	// Now replace file contents with crap
 	if err := os.WriteFile(file, []byte("foo"), 0600); err != nil {

accounts/keystore/passphrase_test.go

@@ -54,7 +54,7 @@ func TestKeyEncryptDecrypt(t *testing.T) {
 		// Recrypt with a new password and start over
 		password += "new data appended" // nolint: gosec
 		if keyjson, err = EncryptKey(key, password, veryLightScryptN, veryLightScryptP); err != nil {
-			t.Errorf("test %d: failed to recrypt key %v", i, err)
+			t.Errorf("test %d: failed to re-encrypt key %v", i, err)
 		}
 	}
 }

accounts/keystore/watch.go

@@ -125,7 +125,7 @@ func (w *watcher) loop() {
 			if !ok {
 				return
 			}
-			log.Info("Filsystem watcher error", "err", err)
+			log.Info("Filesystem watcher error", "err", err)
 		case <-debounce.C:
 			w.ac.scanAccounts()
 			rescanTriggered = false

accounts/url_test.go

@@ -55,7 +55,7 @@ func TestURLMarshalJSON(t *testing.T) {
 	url := URL{Scheme: "https", Path: "ethereum.org"}
 	json, err := url.MarshalJSON()
 	if err != nil {
-		t.Errorf("unexpcted error: %v", err)
+		t.Errorf("unexpected error: %v", err)
 	}
 	if string(json) != "\"https://ethereum.org\"" {
 		t.Errorf("expected: %v, got: %v", "\"https://ethereum.org\"", string(json))
@@ -66,7 +66,7 @@ func TestURLUnmarshalJSON(t *testing.T) {
 	url := &URL{}
 	err := url.UnmarshalJSON([]byte("\"https://ethereum.org\""))
 	if err != nil {
-		t.Errorf("unexpcted error: %v", err)
+		t.Errorf("unexpected error: %v", err)
 	}
 	if url.Scheme != "https" {
 		t.Errorf("expected: %v, got: %v", "https", url.Scheme)

cmd/abigen/namefilter_test.go

@@ -8,6 +8,7 @@ import (
 )
 
 func TestNameFilter(t *testing.T) {
+	t.Parallel()
 	_, err := newNameFilter("Foo")
 	require.Error(t, err)
 	_, err = newNameFilter("too/many:colons:Foo")

cmd/clef/consolecmd_test.go

@@ -26,12 +26,13 @@ import (
 
 // TestImportRaw tests clef --importraw
 func TestImportRaw(t *testing.T) {
+	t.Parallel()
 	keyPath := filepath.Join(os.TempDir(), fmt.Sprintf("%v-tempkey.test", t.Name()))
 	os.WriteFile(keyPath, []byte("0102030405060708090a0102030405060708090a0102030405060708090a0102"), 0777)
 	t.Cleanup(func() { os.Remove(keyPath) })
 
-	t.Parallel()
 	t.Run("happy-path", func(t *testing.T) {
+		t.Parallel()
 		// Run clef importraw
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "importraw", keyPath)
 		clef.input("myverylongpassword").input("myverylongpassword")
@@ -43,6 +44,7 @@ func TestImportRaw(t *testing.T) {
 	})
 	// tests clef --importraw with mismatched passwords.
 	t.Run("pw-mismatch", func(t *testing.T) {
+		t.Parallel()
 		// Run clef importraw
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "importraw", keyPath)
 		clef.input("myverylongpassword1").input("myverylongpassword2").WaitExit()
@@ -52,6 +54,7 @@ func TestImportRaw(t *testing.T) {
 	})
 	// tests clef --importraw with a too short password.
 	t.Run("short-pw", func(t *testing.T) {
+		t.Parallel()
 		// Run clef importraw
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "importraw", keyPath)
 		clef.input("shorty").input("shorty").WaitExit()
@@ -64,12 +67,13 @@ func TestImportRaw(t *testing.T) {
 
 // TestListAccounts tests clef --list-accounts
 func TestListAccounts(t *testing.T) {
+	t.Parallel()
 	keyPath := filepath.Join(os.TempDir(), fmt.Sprintf("%v-tempkey.test", t.Name()))
 	os.WriteFile(keyPath, []byte("0102030405060708090a0102030405060708090a0102030405060708090a0102"), 0777)
 	t.Cleanup(func() { os.Remove(keyPath) })
 
-	t.Parallel()
 	t.Run("no-accounts", func(t *testing.T) {
+		t.Parallel()
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "list-accounts")
 		if out := string(clef.Output()); !strings.Contains(out, "The keystore is empty.") {
 			t.Logf("Output\n%v", out)
@@ -77,6 +81,7 @@ func TestListAccounts(t *testing.T) {
 		}
 	})
 	t.Run("one-account", func(t *testing.T) {
+		t.Parallel()
 		// First, we need to import
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "importraw", keyPath)
 		clef.input("myverylongpassword").input("myverylongpassword").WaitExit()
@@ -91,12 +96,13 @@ func TestListAccounts(t *testing.T) {
 
 // TestListWallets tests clef --list-wallets
 func TestListWallets(t *testing.T) {
+	t.Parallel()
 	keyPath := filepath.Join(os.TempDir(), fmt.Sprintf("%v-tempkey.test", t.Name()))
 	os.WriteFile(keyPath, []byte("0102030405060708090a0102030405060708090a0102030405060708090a0102"), 0777)
 	t.Cleanup(func() { os.Remove(keyPath) })
 
-	t.Parallel()
 	t.Run("no-accounts", func(t *testing.T) {
+		t.Parallel()
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "list-wallets")
 		if out := string(clef.Output()); !strings.Contains(out, "There are no wallets.") {
 			t.Logf("Output\n%v", out)
@@ -104,6 +110,7 @@ func TestListWallets(t *testing.T) {
 		}
 	})
 	t.Run("one-account", func(t *testing.T) {
+		t.Parallel()
 		// First, we need to import
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "importraw", keyPath)
 		clef.input("myverylongpassword").input("myverylongpassword").WaitExit()

cmd/devp2p/dns_route53_test.go

@@ -26,6 +26,7 @@ import (
 // This test checks that computeChanges/splitChanges create DNS changes in
 // leaf-added -> root-changed -> leaf-deleted order.
 func TestRoute53ChangeSort(t *testing.T) {
+	t.Parallel()
 	testTree0 := map[string]recordSet{
 		"2kfjogvxdqtxxugbh7gs7naaai.n": {ttl: 3333, values: []string{
 			`"enr:-HW4QO1ml1DdXLeZLsUxewnthhUy8eROqkDyoMTyavfks9JlYQIlMFEUoM78PovJDPQrAkrb3LRJ-""vtrymDguKCOIAWAgmlkgnY0iXNlY3AyNTZrMaEDffaGfJzgGhUif1JqFruZlYmA31HzathLSWxfbq_QoQ4"`,
@@ -164,6 +165,7 @@ func TestRoute53ChangeSort(t *testing.T) {
 
 // This test checks that computeChanges compares the quoted value of the records correctly.
 func TestRoute53NoChange(t *testing.T) {
+	t.Parallel()
 	// Existing record set.
 	testTree0 := map[string]recordSet{
 		"n": {ttl: rootTTL, values: []string{

cmd/devp2p/internal/ethtest/chain_test.go

@@ -30,6 +30,7 @@ import (
 // TestEthProtocolNegotiation tests whether the test suite
 // can negotiate the highest eth protocol in a status message exchange
 func TestEthProtocolNegotiation(t *testing.T) {
+	t.Parallel()
 	var tests = []struct {
 		conn     *Conn
 		caps     []p2p.Cap
@@ -125,6 +126,7 @@ func TestEthProtocolNegotiation(t *testing.T) {
 // TestChain_GetHeaders tests whether the test suite can correctly
 // respond to a GetBlockHeaders request from a node.
 func TestChain_GetHeaders(t *testing.T) {
+	t.Parallel()
 	chainFile, err := filepath.Abs("./testdata/chain.rlp")
 	if err != nil {
 		t.Fatal(err)

cmd/devp2p/internal/ethtest/snap.go

@@ -461,7 +461,7 @@ func (s *Suite) TestSnapTrieNodes(t *utesting.T) {
 				common.HexToHash("0xbe3d75a1729be157e79c3b77f00206db4d54e3ea14375a015451c88ec067c790"),
 			},
 		},
-	}[7:] {
+	} {
 		tc := tc
 		if err := s.snapGetTrieNodes(t, &tc); err != nil {
 			t.Errorf("test %d \n #hashes %x\n root: %#x\n bytes: %d\nfailed: %v", i, len(tc.expHashes), tc.root, tc.nBytes, err)

cmd/devp2p/internal/ethtest/suite_test.go

@@ -35,6 +35,7 @@ var (
 )
 
 func TestEthSuite(t *testing.T) {
+	t.Parallel()
 	geth, err := runGeth()
 	if err != nil {
 		t.Fatalf("could not run geth: %v", err)
@@ -56,6 +57,7 @@ func TestEthSuite(t *testing.T) {
 }
 
 func TestSnapSuite(t *testing.T) {
+	t.Parallel()
 	geth, err := runGeth()
 	if err != nil {
 		t.Fatalf("could not run geth: %v", err)

cmd/ethkey/message_test.go

@@ -22,6 +22,7 @@ import (
 )
 
 func TestMessageSignVerify(t *testing.T) {
+	t.Parallel()
 	tmpdir := t.TempDir()
 
 	keyfile := filepath.Join(tmpdir, "the-keyfile")

cmd/evm/blockrunner.go

@@ -40,7 +40,7 @@ var RunFlag = &cli.StringFlag{
 var blockTestCommand = &cli.Command{
 	Action:    blockTestCmd,
 	Name:      "blocktest",
-	Usage:     "executes the given blockchain tests",
+	Usage:     "Executes the given blockchain tests",
 	ArgsUsage: "<file>",
 	Flags:     []cli.Flag{RunFlag},
 }

cmd/evm/compiler.go

@@ -29,7 +29,7 @@ import (
 var compileCommand = &cli.Command{
 	Action:    compileCmd,
 	Name:      "compile",
-	Usage:     "compiles easm source to evm binary",
+	Usage:     "Compiles easm source to evm binary",
 	ArgsUsage: "<file>",
 }
 

cmd/evm/disasm.go

@@ -29,7 +29,7 @@ import (
 var disasmCommand = &cli.Command{
 	Action:    disasmCmd,
 	Name:      "disasm",
-	Usage:     "disassembles evm binary",
+	Usage:     "Disassembles evm binary",
 	ArgsUsage: "<file>",
 }
 

cmd/evm/main.go

@@ -139,7 +139,7 @@ var (
 var stateTransitionCommand = &cli.Command{
 	Name:    "transition",
 	Aliases: []string{"t8n"},
-	Usage:   "executes a full state transition",
+	Usage:   "Executes a full state transition",
 	Action:  t8ntool.Transition,
 	Flags: []cli.Flag{
 		t8ntool.TraceFlag,
@@ -165,7 +165,7 @@ var stateTransitionCommand = &cli.Command{
 var transactionCommand = &cli.Command{
 	Name:    "transaction",
 	Aliases: []string{"t9n"},
-	Usage:   "performs transaction validation",
+	Usage:   "Performs transaction validation",
 	Action:  t8ntool.Transaction,
 	Flags: []cli.Flag{
 		t8ntool.InputTxsFlag,
@@ -178,7 +178,7 @@ var transactionCommand = &cli.Command{
 var blockBuilderCommand = &cli.Command{
 	Name:    "block-builder",
 	Aliases: []string{"b11r"},
-	Usage:   "builds a block",
+	Usage:   "Builds a block",
 	Action:  t8ntool.BuildBlock,
 	Flags: []cli.Flag{
 		t8ntool.OutputBasedir,

cmd/evm/runner.go

@@ -46,7 +46,7 @@ import (
 var runCommand = &cli.Command{
 	Action:      runCmd,
 	Name:        "run",
-	Usage:       "run arbitrary evm binary",
+	Usage:       "Run arbitrary evm binary",
 	ArgsUsage:   "<code>",
 	Description: `The run command runs arbitrary EVM code.`,
 	Flags:       flags.Merge(vmFlags, traceFlags),

cmd/evm/t8n_test.go

@@ -106,6 +106,7 @@ func (args *t8nOutput) get() (out []string) {
 }
 
 func TestT8n(t *testing.T) {
+	t.Parallel()
 	tt := new(testT8n)
 	tt.TestCmd = cmdtest.NewTestCmd(t, tt)
 	for i, tc := range []struct {
@@ -338,6 +339,7 @@ func (args *t9nInput) get(base string) []string {
 }
 
 func TestT9n(t *testing.T) {
+	t.Parallel()
 	tt := new(testT8n)
 	tt.TestCmd = cmdtest.NewTestCmd(t, tt)
 	for i, tc := range []struct {
@@ -473,6 +475,7 @@ func (args *b11rInput) get(base string) []string {
 }
 
 func TestB11r(t *testing.T) {
+	t.Parallel()
 	tt := new(testT8n)
 	tt.TestCmd = cmdtest.NewTestCmd(t, tt)
 	for i, tc := range []struct {

cmd/faucet/README.md

@@ -1,52 +0,0 @@
-# Faucet
-
-The `faucet` is a simplistic web application with the goal of distributing small amounts of Ether in private and test networks.
-
-Users need to post their Ethereum addresses to fund in a Twitter status update or public Facebook post and share the link to the faucet. The faucet will in turn deduplicate user requests and send the Ether. After a funding round, the faucet prevents the same user from requesting again for a pre-configured amount of time, proportional to the amount of Ether requested.
-
-## Operation
-
-The `faucet` is a single binary app (everything included) with all configurations set via command line flags and a few files.
-
-First things first, the `faucet` needs to connect to an Ethereum network, for which it needs the necessary genesis and network infos. Each of the following flags must be set:
-
-- `-genesis` is a path to a file containing the network `genesis.json`. or using:
-  - `-goerli` with the faucet with Görli network config
-  - `-sepolia` with the faucet with Sepolia network config
-- `-network` is the devp2p network id used during connection
-- `-bootnodes` is a list of `enode://` ids to join the network through
-
-The `faucet` will use the `les` protocol to join the configured Ethereum network and will store its data in `$HOME/.faucet` (currently not configurable).
-
-## Funding
-
-To be able to distribute funds, the `faucet` needs access to an already funded Ethereum account. This can be configured via:
-
-- `-account.json` is a path to the Ethereum account's JSON key file
-- `-account.pass` is a path to a text file with the decryption passphrase
-
-The faucet is able to distribute various amounts of Ether in exchange for various timeouts. These can be configured via:
-
-- `-faucet.amount` is the number of Ethers to send by default
-- `-faucet.minutes` is the time to wait before allowing a rerequest
-- `-faucet.tiers` is the funding tiers to support  (x3 time, x2.5 funds)
-
-## Sybil protection
-
-To prevent the same user from exhausting funds in a loop, the `faucet` ties requests to social networks and captcha resolvers.
-
-Captcha protection uses Google's invisible ReCaptcha, thus the `faucet` needs to run on a live domain. The domain needs to be registered in Google's systems to retrieve the captcha API token and secrets. After doing so, captcha protection may be enabled via:
-
-- `-captcha.token` is the API token for ReCaptcha
-- `-captcha.secret` is the API secret for ReCaptcha
-
-Sybil protection via Twitter requires an API key as of 15th December, 2020. To obtain it, a Twitter user must be upgraded to developer status and a new Twitter App deployed with it. The app's `Bearer` token is required by the faucet to retrieve tweet data:
-
-- `-twitter.token` is the Bearer token for `v2` API access
-- `-twitter.token.v1` is the Bearer token for `v1` API access
-
-Sybil protection via Facebook uses the website to directly download post data thus does not currently require an API configuration. 
-
-## Miscellaneous
-
-Beside the above - mostly essential - CLI flags, there are a number that can be used to fine-tune the `faucet`'s operation. Please see `faucet --help` for a full list.

cmd/faucet/faucet.go

@@ -1,891 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-// faucet is an Ether faucet backed by a light client.
-package main
-
-import (
-	"bytes"
-	"context"
-	_ "embed"
-	"encoding/json"
-	"errors"
-	"flag"
-	"fmt"
-	"html/template"
-	"io"
-	"math"
-	"math/big"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/accounts/keystore"
-	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/eth/downloader"
-	"github.com/ethereum/go-ethereum/eth/ethconfig"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/ethstats"
-	"github.com/ethereum/go-ethereum/internal/version"
-	"github.com/ethereum/go-ethereum/les"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/node"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/p2p/nat"
-	"github.com/ethereum/go-ethereum/params"
-	"github.com/gorilla/websocket"
-)
-
-var (
-	genesisFlag = flag.String("genesis", "", "Genesis json file to seed the chain with")
-	apiPortFlag = flag.Int("apiport", 8080, "Listener port for the HTTP API connection")
-	ethPortFlag = flag.Int("ethport", 30303, "Listener port for the devp2p connection")
-	bootFlag    = flag.String("bootnodes", "", "Comma separated bootnode enode URLs to seed with")
-	netFlag     = flag.Uint64("network", 0, "Network ID to use for the Ethereum protocol")
-	statsFlag   = flag.String("ethstats", "", "Ethstats network monitoring auth string")
-
-	netnameFlag = flag.String("faucet.name", "", "Network name to assign to the faucet")
-	payoutFlag  = flag.Int("faucet.amount", 1, "Number of Ethers to pay out per user request")
-	minutesFlag = flag.Int("faucet.minutes", 1440, "Number of minutes to wait between funding rounds")
-	tiersFlag   = flag.Int("faucet.tiers", 3, "Number of funding tiers to enable (x3 time, x2.5 funds)")
-
-	accJSONFlag = flag.String("account.json", "", "Key json file to fund user requests with")
-	accPassFlag = flag.String("account.pass", "", "Decryption password to access faucet funds")
-
-	captchaToken  = flag.String("captcha.token", "", "Recaptcha site key to authenticate client side")
-	captchaSecret = flag.String("captcha.secret", "", "Recaptcha secret key to authenticate server side")
-
-	noauthFlag = flag.Bool("noauth", false, "Enables funding requests without authentication")
-	logFlag    = flag.Int("loglevel", 3, "Log level to use for Ethereum and the faucet")
-
-	twitterTokenFlag   = flag.String("twitter.token", "", "Bearer token to authenticate with the v2 Twitter API")
-	twitterTokenV1Flag = flag.String("twitter.token.v1", "", "Bearer token to authenticate with the v1.1 Twitter API")
-
-	goerliFlag  = flag.Bool("goerli", false, "Initializes the faucet with Görli network config")
-	sepoliaFlag = flag.Bool("sepolia", false, "Initializes the faucet with Sepolia network config")
-)
-
-var (
-	ether = new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)
-)
-
-//go:embed faucet.html
-var websiteTmpl string
-
-func main() {
-	// Parse the flags and set up the logger to print everything requested
-	flag.Parse()
-	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*logFlag), log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
-
-	// Construct the payout tiers
-	amounts := make([]string, *tiersFlag)
-	periods := make([]string, *tiersFlag)
-	for i := 0; i < *tiersFlag; i++ {
-		// Calculate the amount for the next tier and format it
-		amount := float64(*payoutFlag) * math.Pow(2.5, float64(i))
-		amounts[i] = fmt.Sprintf("%s Ethers", strconv.FormatFloat(amount, 'f', -1, 64))
-		if amount == 1 {
-			amounts[i] = strings.TrimSuffix(amounts[i], "s")
-		}
-		// Calculate the period for the next tier and format it
-		period := *minutesFlag * int(math.Pow(3, float64(i)))
-		periods[i] = fmt.Sprintf("%d mins", period)
-		if period%60 == 0 {
-			period /= 60
-			periods[i] = fmt.Sprintf("%d hours", period)
-
-			if period%24 == 0 {
-				period /= 24
-				periods[i] = fmt.Sprintf("%d days", period)
-			}
-		}
-		if period == 1 {
-			periods[i] = strings.TrimSuffix(periods[i], "s")
-		}
-	}
-	website := new(bytes.Buffer)
-	err := template.Must(template.New("").Parse(websiteTmpl)).Execute(website, map[string]interface{}{
-		"Network":   *netnameFlag,
-		"Amounts":   amounts,
-		"Periods":   periods,
-		"Recaptcha": *captchaToken,
-		"NoAuth":    *noauthFlag,
-	})
-	if err != nil {
-		log.Crit("Failed to render the faucet template", "err", err)
-	}
-	// Load and parse the genesis block requested by the user
-	genesis, err := getGenesis(*genesisFlag, *goerliFlag, *sepoliaFlag)
-	if err != nil {
-		log.Crit("Failed to parse genesis config", "err", err)
-	}
-	// Convert the bootnodes to internal enode representations
-	var enodes []*enode.Node
-	for _, boot := range strings.Split(*bootFlag, ",") {
-		if url, err := enode.Parse(enode.ValidSchemes, boot); err == nil {
-			enodes = append(enodes, url)
-		} else {
-			log.Error("Failed to parse bootnode URL", "url", boot, "err", err)
-		}
-	}
-	// Load up the account key and decrypt its password
-	blob, err := os.ReadFile(*accPassFlag)
-	if err != nil {
-		log.Crit("Failed to read account password contents", "file", *accPassFlag, "err", err)
-	}
-	pass := strings.TrimSuffix(string(blob), "\n")
-
-	ks := keystore.NewKeyStore(filepath.Join(os.Getenv("HOME"), ".faucet", "keys"), keystore.StandardScryptN, keystore.StandardScryptP)
-	if blob, err = os.ReadFile(*accJSONFlag); err != nil {
-		log.Crit("Failed to read account key contents", "file", *accJSONFlag, "err", err)
-	}
-	acc, err := ks.Import(blob, pass, pass)
-	if err != nil && err != keystore.ErrAccountAlreadyExists {
-		log.Crit("Failed to import faucet signer account", "err", err)
-	}
-	if err := ks.Unlock(acc, pass); err != nil {
-		log.Crit("Failed to unlock faucet signer account", "err", err)
-	}
-	// Assemble and start the faucet light service
-	faucet, err := newFaucet(genesis, *ethPortFlag, enodes, *netFlag, *statsFlag, ks, website.Bytes())
-	if err != nil {
-		log.Crit("Failed to start faucet", "err", err)
-	}
-	defer faucet.close()
-
-	if err := faucet.listenAndServe(*apiPortFlag); err != nil {
-		log.Crit("Failed to launch faucet API", "err", err)
-	}
-}
-
-// request represents an accepted funding request.
-type request struct {
-	Avatar  string             `json:"avatar"`  // Avatar URL to make the UI nicer
-	Account common.Address     `json:"account"` // Ethereum address being funded
-	Time    time.Time          `json:"time"`    // Timestamp when the request was accepted
-	Tx      *types.Transaction `json:"tx"`      // Transaction funding the account
-}
-
-// faucet represents a crypto faucet backed by an Ethereum light client.
-type faucet struct {
-	config *params.ChainConfig // Chain configurations for signing
-	stack  *node.Node          // Ethereum protocol stack
-	client *ethclient.Client   // Client connection to the Ethereum chain
-	index  []byte              // Index page to serve up on the web
-
-	keystore *keystore.KeyStore // Keystore containing the single signer
-	account  accounts.Account   // Account funding user faucet requests
-	head     *types.Header      // Current head header of the faucet
-	balance  *big.Int           // Current balance of the faucet
-	nonce    uint64             // Current pending nonce of the faucet
-	price    *big.Int           // Current gas price to issue funds with
-
-	conns    []*wsConn            // Currently live websocket connections
-	timeouts map[string]time.Time // History of users and their funding timeouts
-	reqs     []*request           // Currently pending funding requests
-	update   chan struct{}        // Channel to signal request updates
-
-	lock sync.RWMutex // Lock protecting the faucet's internals
-}
-
-// wsConn wraps a websocket connection with a write mutex as the underlying
-// websocket library does not synchronize access to the stream.
-type wsConn struct {
-	conn  *websocket.Conn
-	wlock sync.Mutex
-}
-
-func newFaucet(genesis *core.Genesis, port int, enodes []*enode.Node, network uint64, stats string, ks *keystore.KeyStore, index []byte) (*faucet, error) {
-	// Assemble the raw devp2p protocol stack
-	git, _ := version.VCS()
-	stack, err := node.New(&node.Config{
-		Name:    "geth",
-		Version: params.VersionWithCommit(git.Commit, git.Date),
-		DataDir: filepath.Join(os.Getenv("HOME"), ".faucet"),
-		P2P: p2p.Config{
-			NAT:              nat.Any(),
-			NoDiscovery:      true,
-			DiscoveryV5:      true,
-			ListenAddr:       fmt.Sprintf(":%d", port),
-			MaxPeers:         25,
-			BootstrapNodesV5: enodes,
-		},
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	// Assemble the Ethereum light client protocol
-	cfg := ethconfig.Defaults
-	cfg.SyncMode = downloader.LightSync
-	cfg.NetworkId = network
-	cfg.Genesis = genesis
-	utils.SetDNSDiscoveryDefaults(&cfg, genesis.ToBlock().Hash())
-
-	lesBackend, err := les.New(stack, &cfg)
-	if err != nil {
-		return nil, fmt.Errorf("failed to register the Ethereum service: %w", err)
-	}
-
-	// Assemble the ethstats monitoring and reporting service'
-	if stats != "" {
-		if err := ethstats.New(stack, lesBackend.ApiBackend, lesBackend.Engine(), stats); err != nil {
-			return nil, err
-		}
-	}
-	// Boot up the client and ensure it connects to bootnodes
-	if err := stack.Start(); err != nil {
-		return nil, err
-	}
-	for _, boot := range enodes {
-		old, err := enode.Parse(enode.ValidSchemes, boot.String())
-		if err == nil {
-			stack.Server().AddPeer(old)
-		}
-	}
-	// Attach to the client and retrieve and interesting metadatas
-	api := stack.Attach()
-	client := ethclient.NewClient(api)
-
-	return &faucet{
-		config:   genesis.Config,
-		stack:    stack,
-		client:   client,
-		index:    index,
-		keystore: ks,
-		account:  ks.Accounts()[0],
-		timeouts: make(map[string]time.Time),
-		update:   make(chan struct{}, 1),
-	}, nil
-}
-
-// close terminates the Ethereum connection and tears down the faucet.
-func (f *faucet) close() error {
-	return f.stack.Close()
-}
-
-// listenAndServe registers the HTTP handlers for the faucet and boots it up
-// for service user funding requests.
-func (f *faucet) listenAndServe(port int) error {
-	go f.loop()
-
-	http.HandleFunc("/", f.webHandler)
-	http.HandleFunc("/api", f.apiHandler)
-	return http.ListenAndServe(fmt.Sprintf(":%d", port), nil)
-}
-
-// webHandler handles all non-api requests, simply flattening and returning the
-// faucet website.
-func (f *faucet) webHandler(w http.ResponseWriter, r *http.Request) {
-	w.Write(f.index)
-}
-
-// apiHandler handles requests for Ether grants and transaction statuses.
-func (f *faucet) apiHandler(w http.ResponseWriter, r *http.Request) {
-	upgrader := websocket.Upgrader{}
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		return
-	}
-
-	// Start tracking the connection and drop at the end
-	defer conn.Close()
-
-	f.lock.Lock()
-	wsconn := &wsConn{conn: conn}
-	f.conns = append(f.conns, wsconn)
-	f.lock.Unlock()
-
-	defer func() {
-		f.lock.Lock()
-		for i, c := range f.conns {
-			if c.conn == conn {
-				f.conns = append(f.conns[:i], f.conns[i+1:]...)
-				break
-			}
-		}
-		f.lock.Unlock()
-	}()
-	// Gather the initial stats from the network to report
-	var (
-		head    *types.Header
-		balance *big.Int
-		nonce   uint64
-	)
-	for head == nil || balance == nil {
-		// Retrieve the current stats cached by the faucet
-		f.lock.RLock()
-		if f.head != nil {
-			head = types.CopyHeader(f.head)
-		}
-		if f.balance != nil {
-			balance = new(big.Int).Set(f.balance)
-		}
-		nonce = f.nonce
-		f.lock.RUnlock()
-
-		if head == nil || balance == nil {
-			// Report the faucet offline until initial stats are ready
-			//lint:ignore ST1005 This error is to be displayed in the browser
-			if err = sendError(wsconn, errors.New("Faucet offline")); err != nil {
-				log.Warn("Failed to send faucet error to client", "err", err)
-				return
-			}
-			time.Sleep(3 * time.Second)
-		}
-	}
-	// Send over the initial stats and the latest header
-	f.lock.RLock()
-	reqs := f.reqs
-	f.lock.RUnlock()
-	if err = send(wsconn, map[string]interface{}{
-		"funds":    new(big.Int).Div(balance, ether),
-		"funded":   nonce,
-		"peers":    f.stack.Server().PeerCount(),
-		"requests": reqs,
-	}, 3*time.Second); err != nil {
-		log.Warn("Failed to send initial stats to client", "err", err)
-		return
-	}
-	if err = send(wsconn, head, 3*time.Second); err != nil {
-		log.Warn("Failed to send initial header to client", "err", err)
-		return
-	}
-	// Keep reading requests from the websocket until the connection breaks
-	for {
-		// Fetch the next funding request and validate against github
-		var msg struct {
-			URL     string `json:"url"`
-			Tier    uint   `json:"tier"`
-			Captcha string `json:"captcha"`
-		}
-		if err = conn.ReadJSON(&msg); err != nil {
-			return
-		}
-		if !*noauthFlag && !strings.HasPrefix(msg.URL, "https://twitter.com/") && !strings.HasPrefix(msg.URL, "https://www.facebook.com/") {
-			if err = sendError(wsconn, errors.New("URL doesn't link to supported services")); err != nil {
-				log.Warn("Failed to send URL error to client", "err", err)
-				return
-			}
-			continue
-		}
-		if msg.Tier >= uint(*tiersFlag) {
-			//lint:ignore ST1005 This error is to be displayed in the browser
-			if err = sendError(wsconn, errors.New("Invalid funding tier requested")); err != nil {
-				log.Warn("Failed to send tier error to client", "err", err)
-				return
-			}
-			continue
-		}
-		log.Info("Faucet funds requested", "url", msg.URL, "tier", msg.Tier)
-
-		// If captcha verifications are enabled, make sure we're not dealing with a robot
-		if *captchaToken != "" {
-			form := url.Values{}
-			form.Add("secret", *captchaSecret)
-			form.Add("response", msg.Captcha)
-
-			res, err := http.PostForm("https://www.google.com/recaptcha/api/siteverify", form)
-			if err != nil {
-				if err = sendError(wsconn, err); err != nil {
-					log.Warn("Failed to send captcha post error to client", "err", err)
-					return
-				}
-				continue
-			}
-			var result struct {
-				Success bool            `json:"success"`
-				Errors  json.RawMessage `json:"error-codes"`
-			}
-			err = json.NewDecoder(res.Body).Decode(&result)
-			res.Body.Close()
-			if err != nil {
-				if err = sendError(wsconn, err); err != nil {
-					log.Warn("Failed to send captcha decode error to client", "err", err)
-					return
-				}
-				continue
-			}
-			if !result.Success {
-				log.Warn("Captcha verification failed", "err", string(result.Errors))
-				//lint:ignore ST1005 it's funny and the robot won't mind
-				if err = sendError(wsconn, errors.New("Beep-bop, you're a robot!")); err != nil {
-					log.Warn("Failed to send captcha failure to client", "err", err)
-					return
-				}
-				continue
-			}
-		}
-		// Retrieve the Ethereum address to fund, the requesting user and a profile picture
-		var (
-			id       string
-			username string
-			avatar   string
-			address  common.Address
-		)
-		switch {
-		case strings.HasPrefix(msg.URL, "https://twitter.com/"):
-			id, username, avatar, address, err = authTwitter(msg.URL, *twitterTokenV1Flag, *twitterTokenFlag)
-		case strings.HasPrefix(msg.URL, "https://www.facebook.com/"):
-			username, avatar, address, err = authFacebook(msg.URL)
-			id = username
-		case *noauthFlag:
-			username, avatar, address, err = authNoAuth(msg.URL)
-			id = username
-		default:
-			//lint:ignore ST1005 This error is to be displayed in the browser
-			err = errors.New("Something funky happened, please open an issue at https://github.com/ethereum/go-ethereum/issues")
-		}
-		if err != nil {
-			if err = sendError(wsconn, err); err != nil {
-				log.Warn("Failed to send prefix error to client", "err", err)
-				return
-			}
-			continue
-		}
-		log.Info("Faucet request valid", "url", msg.URL, "tier", msg.Tier, "user", username, "address", address)
-
-		// Ensure the user didn't request funds too recently
-		f.lock.Lock()
-		var (
-			fund    bool
-			timeout time.Time
-		)
-		if timeout = f.timeouts[id]; time.Now().After(timeout) {
-			// User wasn't funded recently, create the funding transaction
-			amount := new(big.Int).Mul(big.NewInt(int64(*payoutFlag)), ether)
-			amount = new(big.Int).Mul(amount, new(big.Int).Exp(big.NewInt(5), big.NewInt(int64(msg.Tier)), nil))
-			amount = new(big.Int).Div(amount, new(big.Int).Exp(big.NewInt(2), big.NewInt(int64(msg.Tier)), nil))
-
-			tx := types.NewTransaction(f.nonce+uint64(len(f.reqs)), address, amount, 21000, f.price, nil)
-			signed, err := f.keystore.SignTx(f.account, tx, f.config.ChainID)
-			if err != nil {
-				f.lock.Unlock()
-				if err = sendError(wsconn, err); err != nil {
-					log.Warn("Failed to send transaction creation error to client", "err", err)
-					return
-				}
-				continue
-			}
-			// Submit the transaction and mark as funded if successful
-			if err := f.client.SendTransaction(context.Background(), signed); err != nil {
-				f.lock.Unlock()
-				if err = sendError(wsconn, err); err != nil {
-					log.Warn("Failed to send transaction transmission error to client", "err", err)
-					return
-				}
-				continue
-			}
-			f.reqs = append(f.reqs, &request{
-				Avatar:  avatar,
-				Account: address,
-				Time:    time.Now(),
-				Tx:      signed,
-			})
-			timeout := time.Duration(*minutesFlag*int(math.Pow(3, float64(msg.Tier)))) * time.Minute
-			grace := timeout / 288 // 24h timeout => 5m grace
-
-			f.timeouts[id] = time.Now().Add(timeout - grace)
-			fund = true
-		}
-		f.lock.Unlock()
-
-		// Send an error if too frequent funding, othewise a success
-		if !fund {
-			if err = sendError(wsconn, fmt.Errorf("%s left until next allowance", common.PrettyDuration(time.Until(timeout)))); err != nil { // nolint: gosimple
-				log.Warn("Failed to send funding error to client", "err", err)
-				return
-			}
-			continue
-		}
-		if err = sendSuccess(wsconn, fmt.Sprintf("Funding request accepted for %s into %s", username, address.Hex())); err != nil {
-			log.Warn("Failed to send funding success to client", "err", err)
-			return
-		}
-		select {
-		case f.update <- struct{}{}:
-		default:
-		}
-	}
-}
-
-// refresh attempts to retrieve the latest header from the chain and extract the
-// associated faucet balance and nonce for connectivity caching.
-func (f *faucet) refresh(head *types.Header) error {
-	// Ensure a state update does not run for too long
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	// If no header was specified, use the current chain head
-	var err error
-	if head == nil {
-		if head, err = f.client.HeaderByNumber(ctx, nil); err != nil {
-			return err
-		}
-	}
-	// Retrieve the balance, nonce and gas price from the current head
-	var (
-		balance *big.Int
-		nonce   uint64
-		price   *big.Int
-	)
-	if balance, err = f.client.BalanceAt(ctx, f.account.Address, head.Number); err != nil {
-		return err
-	}
-	if nonce, err = f.client.NonceAt(ctx, f.account.Address, head.Number); err != nil {
-		return err
-	}
-	if price, err = f.client.SuggestGasPrice(ctx); err != nil {
-		return err
-	}
-	// Everything succeeded, update the cached stats and eject old requests
-	f.lock.Lock()
-	f.head, f.balance = head, balance
-	f.price, f.nonce = price, nonce
-	for len(f.reqs) > 0 && f.reqs[0].Tx.Nonce() < f.nonce {
-		f.reqs = f.reqs[1:]
-	}
-	f.lock.Unlock()
-
-	return nil
-}
-
-// loop keeps waiting for interesting events and pushes them out to connected
-// websockets.
-func (f *faucet) loop() {
-	// Wait for chain events and push them to clients
-	heads := make(chan *types.Header, 16)
-	sub, err := f.client.SubscribeNewHead(context.Background(), heads)
-	if err != nil {
-		log.Crit("Failed to subscribe to head events", "err", err)
-	}
-	defer sub.Unsubscribe()
-
-	// Start a goroutine to update the state from head notifications in the background
-	update := make(chan *types.Header)
-
-	go func() {
-		for head := range update {
-			// New chain head arrived, query the current stats and stream to clients
-			timestamp := time.Unix(int64(head.Time), 0)
-			if time.Since(timestamp) > time.Hour {
-				log.Warn("Skipping faucet refresh, head too old", "number", head.Number, "hash", head.Hash(), "age", common.PrettyAge(timestamp))
-				continue
-			}
-			if err := f.refresh(head); err != nil {
-				log.Warn("Failed to update faucet state", "block", head.Number, "hash", head.Hash(), "err", err)
-				continue
-			}
-			// Faucet state retrieved, update locally and send to clients
-			f.lock.RLock()
-			log.Info("Updated faucet state", "number", head.Number, "hash", head.Hash(), "age", common.PrettyAge(timestamp), "balance", f.balance, "nonce", f.nonce, "price", f.price)
-
-			balance := new(big.Int).Div(f.balance, ether)
-			peers := f.stack.Server().PeerCount()
-
-			for _, conn := range f.conns {
-				if err := send(conn, map[string]interface{}{
-					"funds":    balance,
-					"funded":   f.nonce,
-					"peers":    peers,
-					"requests": f.reqs,
-				}, time.Second); err != nil {
-					log.Warn("Failed to send stats to client", "err", err)
-					conn.conn.Close()
-					continue
-				}
-				if err := send(conn, head, time.Second); err != nil {
-					log.Warn("Failed to send header to client", "err", err)
-					conn.conn.Close()
-				}
-			}
-			f.lock.RUnlock()
-		}
-	}()
-	// Wait for various events and assing to the appropriate background threads
-	for {
-		select {
-		case head := <-heads:
-			// New head arrived, send if for state update if there's none running
-			select {
-			case update <- head:
-			default:
-			}
-
-		case <-f.update:
-			// Pending requests updated, stream to clients
-			f.lock.RLock()
-			for _, conn := range f.conns {
-				if err := send(conn, map[string]interface{}{"requests": f.reqs}, time.Second); err != nil {
-					log.Warn("Failed to send requests to client", "err", err)
-					conn.conn.Close()
-				}
-			}
-			f.lock.RUnlock()
-		}
-	}
-}
-
-// sends transmits a data packet to the remote end of the websocket, but also
-// setting a write deadline to prevent waiting forever on the node.
-func send(conn *wsConn, value interface{}, timeout time.Duration) error {
-	if timeout == 0 {
-		timeout = 60 * time.Second
-	}
-	conn.wlock.Lock()
-	defer conn.wlock.Unlock()
-	conn.conn.SetWriteDeadline(time.Now().Add(timeout))
-	return conn.conn.WriteJSON(value)
-}
-
-// sendError transmits an error to the remote end of the websocket, also setting
-// the write deadline to 1 second to prevent waiting forever.
-func sendError(conn *wsConn, err error) error {
-	return send(conn, map[string]string{"error": err.Error()}, time.Second)
-}
-
-// sendSuccess transmits a success message to the remote end of the websocket, also
-// setting the write deadline to 1 second to prevent waiting forever.
-func sendSuccess(conn *wsConn, msg string) error {
-	return send(conn, map[string]string{"success": msg}, time.Second)
-}
-
-// authTwitter tries to authenticate a faucet request using Twitter posts, returning
-// the uniqueness identifier (user id/username), username, avatar URL and Ethereum address to fund on success.
-func authTwitter(url string, tokenV1, tokenV2 string) (string, string, string, common.Address, error) {
-	// Ensure the user specified a meaningful URL, no fancy nonsense
-	parts := strings.Split(url, "/")
-	if len(parts) < 4 || parts[len(parts)-2] != "status" {
-		//lint:ignore ST1005 This error is to be displayed in the browser
-		return "", "", "", common.Address{}, errors.New("Invalid Twitter status URL")
-	}
-	// Strip any query parameters from the tweet id and ensure it's numeric
-	tweetID := strings.Split(parts[len(parts)-1], "?")[0]
-	if !regexp.MustCompile("^[0-9]+$").MatchString(tweetID) {
-		return "", "", "", common.Address{}, errors.New("Invalid Tweet URL")
-	}
-	// Twitter's API isn't really friendly with direct links.
-	// It is restricted to 300 queries / 15 minute with an app api key.
-	// Anything more will require read only authorization from the users and that we want to avoid.
-
-	// If Twitter bearer token is provided, use the API, selecting the version
-	// the user would prefer (currently there's a limit of 1 v2 app / developer
-	// but unlimited v1.1 apps).
-	switch {
-	case tokenV1 != "":
-		return authTwitterWithTokenV1(tweetID, tokenV1)
-	case tokenV2 != "":
-		return authTwitterWithTokenV2(tweetID, tokenV2)
-	}
-	// Twitter API token isn't provided so we just load the public posts
-	// and scrape it for the Ethereum address and profile URL. We need to load
-	// the mobile page though since the main page loads tweet contents via JS.
-	url = strings.Replace(url, "https://twitter.com/", "https://mobile.twitter.com/", 1)
-
-	res, err := http.Get(url)
-	if err != nil {
-		return "", "", "", common.Address{}, err
-	}
-	defer res.Body.Close()
-
-	// Resolve the username from the final redirect, no intermediate junk
-	parts = strings.Split(res.Request.URL.String(), "/")
-	if len(parts) < 4 || parts[len(parts)-2] != "status" {
-		//lint:ignore ST1005 This error is to be displayed in the browser
-		return "", "", "", common.Address{}, errors.New("Invalid Twitter status URL")
-	}
-	username := parts[len(parts)-3]
-
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return "", "", "", common.Address{}, err
-	}
-	address := common.HexToAddress(string(regexp.MustCompile("0x[0-9a-fA-F]{40}").Find(body)))
-	if address == (common.Address{}) {
-		//lint:ignore ST1005 This error is to be displayed in the browser
-		return "", "", "", common.Address{}, errors.New("No Ethereum address found to fund")
-	}
-	var avatar string
-	if parts = regexp.MustCompile(`src="([^"]+twimg\.com/profile_images[^"]+)"`).FindStringSubmatch(string(body)); len(parts) == 2 {
-		avatar = parts[1]
-	}
-	return username + "@twitter", username, avatar, address, nil
-}
-
-// authTwitterWithTokenV1 tries to authenticate a faucet request using Twitter's v1
-// API, returning the user id, username, avatar URL and Ethereum address to fund on
-// success.
-func authTwitterWithTokenV1(tweetID string, token string) (string, string, string, common.Address, error) {
-	// Query the tweet details from Twitter
-	url := fmt.Sprintf("https://api.twitter.com/1.1/statuses/show.json?id=%s", tweetID)
-	req, err := http.NewRequest(http.MethodGet, url, nil)
-	if err != nil {
-		return "", "", "", common.Address{}, err
-	}
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
-	res, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return "", "", "", common.Address{}, err
-	}
-	defer res.Body.Close()
-
-	var result struct {
-		Text string `json:"text"`
-		User struct {
-			ID       string `json:"id_str"`
-			Username string `json:"screen_name"`
-			Avatar   string `json:"profile_image_url"`
-		} `json:"user"`
-	}
-	err = json.NewDecoder(res.Body).Decode(&result)
-	if err != nil {
-		return "", "", "", common.Address{}, err
-	}
-	address := common.HexToAddress(regexp.MustCompile("0x[0-9a-fA-F]{40}").FindString(result.Text))
-	if address == (common.Address{}) {
-		//lint:ignore ST1005 This error is to be displayed in the browser
-		return "", "", "", common.Address{}, errors.New("No Ethereum address found to fund")
-	}
-	return result.User.ID + "@twitter", result.User.Username, result.User.Avatar, address, nil
-}
-
-// authTwitterWithTokenV2 tries to authenticate a faucet request using Twitter's v2
-// API, returning the user id, username, avatar URL and Ethereum address to fund on
-// success.
-func authTwitterWithTokenV2(tweetID string, token string) (string, string, string, common.Address, error) {
-	// Query the tweet details from Twitter
-	url := fmt.Sprintf("https://api.twitter.com/2/tweets/%s?expansions=author_id&user.fields=profile_image_url", tweetID)
-	req, err := http.NewRequest(http.MethodGet, url, nil)
-	if err != nil {
-		return "", "", "", common.Address{}, err
-	}
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
-	res, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return "", "", "", common.Address{}, err
-	}
-	defer res.Body.Close()
-
-	var result struct {
-		Data struct {
-			AuthorID string `json:"author_id"`
-			Text     string `json:"text"`
-		} `json:"data"`
-		Includes struct {
-			Users []struct {
-				ID       string `json:"id"`
-				Username string `json:"username"`
-				Avatar   string `json:"profile_image_url"`
-			} `json:"users"`
-		} `json:"includes"`
-	}
-
-	err = json.NewDecoder(res.Body).Decode(&result)
-	if err != nil {
-		return "", "", "", common.Address{}, err
-	}
-
-	address := common.HexToAddress(regexp.MustCompile("0x[0-9a-fA-F]{40}").FindString(result.Data.Text))
-	if address == (common.Address{}) {
-		//lint:ignore ST1005 This error is to be displayed in the browser
-		return "", "", "", common.Address{}, errors.New("No Ethereum address found to fund")
-	}
-	return result.Data.AuthorID + "@twitter", result.Includes.Users[0].Username, result.Includes.Users[0].Avatar, address, nil
-}
-
-// authFacebook tries to authenticate a faucet request using Facebook posts,
-// returning the username, avatar URL and Ethereum address to fund on success.
-func authFacebook(url string) (string, string, common.Address, error) {
-	// Ensure the user specified a meaningful URL, no fancy nonsense
-	parts := strings.Split(strings.Split(url, "?")[0], "/")
-	if parts[len(parts)-1] == "" {
-		parts = parts[0 : len(parts)-1]
-	}
-	if len(parts) < 4 || parts[len(parts)-2] != "posts" {
-		//lint:ignore ST1005 This error is to be displayed in the browser
-		return "", "", common.Address{}, errors.New("Invalid Facebook post URL")
-	}
-	username := parts[len(parts)-3]
-
-	// Facebook's Graph API isn't really friendly with direct links. Still, we don't
-	// want to do ask read permissions from users, so just load the public posts and
-	// scrape it for the Ethereum address and profile URL.
-	//
-	// Facebook recently changed their desktop webpage to use AJAX for loading post
-	// content, so switch over to the mobile site for now. Will probably end up having
-	// to use the API eventually.
-	crawl := strings.Replace(url, "www.facebook.com", "m.facebook.com", 1)
-
-	res, err := http.Get(crawl)
-	if err != nil {
-		return "", "", common.Address{}, err
-	}
-	defer res.Body.Close()
-
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return "", "", common.Address{}, err
-	}
-	address := common.HexToAddress(string(regexp.MustCompile("0x[0-9a-fA-F]{40}").Find(body)))
-	if address == (common.Address{}) {
-		//lint:ignore ST1005 This error is to be displayed in the browser
-		return "", "", common.Address{}, errors.New("No Ethereum address found to fund. Please check the post URL and verify that it can be viewed publicly.")
-	}
-	var avatar string
-	if parts = regexp.MustCompile(`src="([^"]+fbcdn\.net[^"]+)"`).FindStringSubmatch(string(body)); len(parts) == 2 {
-		avatar = parts[1]
-	}
-	return username + "@facebook", avatar, address, nil
-}
-
-// authNoAuth tries to interpret a faucet request as a plain Ethereum address,
-// without actually performing any remote authentication. This mode is prone to
-// Byzantine attack, so only ever use for truly private networks.
-func authNoAuth(url string) (string, string, common.Address, error) {
-	address := common.HexToAddress(regexp.MustCompile("0x[0-9a-fA-F]{40}").FindString(url))
-	if address == (common.Address{}) {
-		//lint:ignore ST1005 This error is to be displayed in the browser
-		return "", "", common.Address{}, errors.New("No Ethereum address found to fund")
-	}
-	return address.Hex() + "@noauth", "", address, nil
-}
-
-// getGenesis returns a genesis based on input args
-func getGenesis(genesisFlag string, goerliFlag bool, sepoliaFlag bool) (*core.Genesis, error) {
-	switch {
-	case genesisFlag != "":
-		var genesis core.Genesis
-		err := common.LoadJSON(genesisFlag, &genesis)
-		return &genesis, err
-	case goerliFlag:
-		return core.DefaultGoerliGenesisBlock(), nil
-	case sepoliaFlag:
-		return core.DefaultSepoliaGenesisBlock(), nil
-	default:
-		return nil, errors.New("no genesis flag provided")
-	}
-}

cmd/faucet/faucet.html

@@ -1,233 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-	<head>
-		<meta charset="utf-8">
-		<meta http-equiv="X-UA-Compatible" content="IE=edge">
-		<meta name="viewport" content="width=device-width, initial-scale=1">
-
-		<title>{{.Network}}: Authenticated Faucet</title>
-
-		<link href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet" />
-		<link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" />
-
-		<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.1.1/jquery.min.js"></script>
-		<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-noty/2.4.1/packaged/jquery.noty.packaged.min.js"></script>
-		<script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>
-		<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.18.0/moment.min.js"></script>
-
-		<style>
-			.vertical-center {
-				min-height: 100%;
-				min-height: 100vh;
-				display: flex;
-				align-items: center;
-			}
-			.progress {
-				position: relative;
-			}
-			.progress span {
-				position: absolute;
-				display: block;
-				width: 100%;
-				color: white;
-			 }
-			 pre {
-				 padding: 6px;
-				 margin: 0;
-			 }
-		</style>
-	</head>
-
-	<body>
-		<div class="vertical-center">
-			<div class="container">
-				<div class="row" style="margin-bottom: 16px;">
-					<div class="col-lg-12">
-						<h1 style="text-align: center;"><i class="fa fa-bath" aria-hidden="true"></i> {{.Network}} Authenticated Faucet</h1>
-					</div>
-				</div>
-				<div class="row">
-					<div class="col-lg-8 col-lg-offset-2">
-						<div class="input-group">
-							<input id="url" name="url" type="text" class="form-control" placeholder="Social network URL containing your Ethereum address..."/>
-							<span class="input-group-btn">
-								<button class="btn btn-default dropdown-toggle" type="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Give me Ether	<i class="fa fa-caret-down" aria-hidden="true"></i></button>
-				        <ul class="dropdown-menu dropdown-menu-right">{{range $idx, $amount := .Amounts}}
-				          <li><a style="text-align: center;" onclick="tier={{$idx}}; {{if $.Recaptcha}}grecaptcha.execute(){{else}}submit({{$idx}}){{end}}">{{$amount}} / {{index $.Periods $idx}}</a></li>{{end}}
-				        </ul>
-							</span>
-						</div>{{if .Recaptcha}}
-						<div class="g-recaptcha" data-sitekey="{{.Recaptcha}}" data-callback="submit" data-size="invisible"></div>{{end}}
-					</div>
-				</div>
-				<div class="row" style="margin-top: 32px;">
-						<div class="col-lg-6 col-lg-offset-3">
-						<div class="panel panel-small panel-default">
-							<div class="panel-body" style="padding: 0; overflow: auto; max-height: 300px;">
-								<table id="requests" class="table table-condensed" style="margin: 0;"></table>
-							</div>
-							<div class="panel-footer">
-								<table style="width: 100%"><tr>
-									<td style="text-align: center;"><i class="fa fa-rss" aria-hidden="true"></i> <span id="peers"></span> peers</td>
-									<td style="text-align: center;"><i class="fa fa-database" aria-hidden="true"></i> <span id="block"></span> blocks</td>
-									<td style="text-align: center;"><i class="fa fa-heartbeat" aria-hidden="true"></i> <span id="funds"></span> Ethers</td>
-									<td style="text-align: center;"><i class="fa fa-university" aria-hidden="true"></i> <span id="funded"></span> funded</td>
-								</tr></table>
-							</div>
-						</div>
-					</div>
-				</div>
-				<div class="row" style="margin-top: 32px;">
-					<div class="col-lg-12">
-						<h3>How does this work?</h3>
-						<p>This Ether faucet is running on the {{.Network}} network. To prevent malicious actors from exhausting all available funds or accumulating enough Ether to mount long running spam attacks, requests are tied to common 3rd party social network accounts. Anyone having a Twitter or Facebook account may request funds within the permitted limits.</p>
-						<dl class="dl-horizontal">
-							<dt style="width: auto; margin-left: 40px;"><i class="fa fa-twitter" aria-hidden="true" style="font-size: 36px;"></i></dt>
-							<dd style="margin-left: 88px; margin-bottom: 10px;"></i> To request funds via Twitter, make a <a href="https://twitter.com/intent/tweet?text=Requesting%20faucet%20funds%20into%200x0000000000000000000000000000000000000000%20on%20the%20%23{{.Network}}%20%23Ethereum%20test%20network." target="_about:blank">tweet</a> with your Ethereum address pasted into the contents (surrounding text doesn't matter).<br/>Copy-paste the <a href="https://support.twitter.com/articles/80586" target="_about:blank">tweets URL</a> into the above input box and fire away!</dd>
-
-							<dt style="width: auto; margin-left: 40px;"><i class="fa fa-facebook" aria-hidden="true" style="font-size: 36px;"></i></dt>
-							<dd style="margin-left: 88px; margin-bottom: 10px;"></i> To request funds via Facebook, publish a new <strong>public</strong> post with your Ethereum address embedded into the content (surrounding text doesn't matter).<br/>Copy-paste the <a href="https://www.facebook.com/help/community/question/?id=282662498552845" target="_about:blank">posts URL</a> into the above input box and fire away!</dd>
-
-							{{if .NoAuth}}
-								<dt class="text-danger" style="width: auto; margin-left: 40px;"><i class="fa fa-unlock-alt" aria-hidden="true" style="font-size: 36px;"></i></dt>
-								<dd class="text-danger" style="margin-left: 88px; margin-bottom: 10px;"></i> To request funds <strong>without authentication</strong>, simply copy-paste your Ethereum address into the above input box (surrounding text doesn't matter) and fire away.<br/>This mode is susceptible to Byzantine attacks. Only use for debugging or private networks!</dd>
-							{{end}}
-						</dl>
-						<p>You can track the current pending requests below the input field to see how much you have to wait until your turn comes.</p>
-						{{if .Recaptcha}}<em>The faucet is running invisible reCaptcha protection against bots.</em>{{end}}
-					</div>
-				</div>
-			</div>
-		</div>
-
-		<script>
-			// Global variables to hold the current status of the faucet
-			var attempt = 0;
-			var server;
-			var tier = 0;
-			var requests = [];
-
-			// Define a function that creates closures to drop old requests
-			var dropper = function(hash) {
-				return function() {
-					for (var i=0; i<requests.length; i++) {
-						if (requests[i].tx.hash == hash) {
-							requests.splice(i, 1);
-							break;
-						}
-					}
-				}
-			};
-			// Define the function that submits a gist url to the server
-			var submit = function({{if .Recaptcha}}captcha{{end}}) {
-				server.send(JSON.stringify({url: $("#url")[0].value, tier: tier{{if .Recaptcha}}, captcha: captcha{{end}}}));{{if .Recaptcha}}
-				grecaptcha.reset();{{end}}
-			};
-			// Define a method to reconnect upon server loss
-			var reconnect = function() {
-				server = new WebSocket(((window.location.protocol === "https:") ? "wss://" : "ws://") + window.location.host + "/api");
-
-				server.onmessage = function(event) {
-					var msg = JSON.parse(event.data);
-					if (msg === null) {
-						return;
-					}
-
-					if (msg.funds !== undefined) {
-						$("#funds").text(msg.funds);
-					}
-					if (msg.funded !== undefined) {
-						$("#funded").text(msg.funded);
-					}
-					if (msg.peers !== undefined) {
-						$("#peers").text(msg.peers);
-					}
-					if (msg.number !== undefined) {
-						$("#block").text(parseInt(msg.number, 16));
-					}
-					if (msg.error !== undefined) {
-						noty({layout: 'topCenter', text: msg.error, type: 'error', timeout: 5000, progressBar: true});
-					}
-					if (msg.success !== undefined) {
-						noty({layout: 'topCenter', text: msg.success, type: 'success', timeout: 5000, progressBar: true});
-					}
-					if (msg.requests !== undefined && msg.requests !== null) {
-						// Mark all previous requests missing as done
-						for (var i=0; i<requests.length; i++) {
-							if (msg.requests.length > 0 && msg.requests[0].tx.hash == requests[i].tx.hash) {
-								break;
-							}
-							if (requests[i].time != "") {
-								requests[i].time = "";
-								setTimeout(dropper(requests[i].tx.hash), 3000);
-							}
-						}
-						// Append any new requests into our local collection
-						var common = -1;
-						if (requests.length > 0) {
-							for (var i=0; i<msg.requests.length; i++) {
-								if (requests[requests.length-1].tx.hash == msg.requests[i].tx.hash) {
-									common = i;
-									break;
-								}
-							}
-						}
-						for (var i=common+1; i<msg.requests.length; i++) {
-							requests.push(msg.requests[i]);
-						}
-						// Iterate over our entire local collection and re-render the funding table
-						var content = "";
-						for (var i=requests.length-1; i >= 0; i--) {
-							var done    = requests[i].time == "";
-							var elapsed = moment().unix()-moment(requests[i].time).unix();
-
-							content += "<tr id='" + requests[i].tx.hash + "'>";
-							content += "  <td><div style=\"background: url('" + requests[i].avatar + "'); background-size: cover; width:32px; height: 32px; border-radius: 4px;\"></div></td>";
-							content += "  <td><pre>" + requests[i].account + "</pre></td>";
-							content += "  <td style=\"width: 100%; text-align: center; vertical-align: middle;\">";
-							if (done) {
-								content += "    funded";
-							} else {
-								content += "    <span id='time-" + i + "' class='timer'>" + moment.duration(-elapsed, 'seconds').humanize(true) + "</span>";
-							}
-							content += "    <div class='progress' style='height: 4px; margin: 0;'>";
-							if (done) {
-								content += "      <div class='progress-bar progress-bar-success' role='progressbar' aria-valuenow='30' style='width:100%;'></div>";
-							} else if (elapsed > 30) {
-								content += "      <div class='progress-bar progress-bar-danger progress-bar-striped active' role='progressbar' aria-valuenow='30' style='width:100%;'></div>";
-							} else {
-								content += "      <div class='progress-bar progress-bar-striped active' role='progressbar' aria-valuenow='" + elapsed + "' style='width:" + (elapsed * 100 / 30) + "%;'></div>";
-							}
-							content += "    </div>";
-							content += "  </td>";
-							content += "</tr>";
-						}
-						$("#requests").html("<tbody>" + content + "</tbody>");
-					}
-				}
-				server.onclose = function() { setTimeout(reconnect, 3000); };
-			}
-			// Start a UI updater to push the progress bars forward until they are done
-			setInterval(function() {
-				$('.progress-bar').each(function() {
-					var progress = Number($(this).attr('aria-valuenow')) + 1;
-					if (progress < 30) {
-						$(this).attr('aria-valuenow', progress);
-						$(this).css('width', (progress * 100 / 30) + '%');
-					} else if (progress == 30) {
-						$(this).css('width', '100%');
-						$(this).addClass("progress-bar-danger");
-					}
-				})
-				$('.timer').each(function() {
-					var index = Number($(this).attr('id').substring(5));
-					$(this).html(moment.duration(moment(requests[index].time).unix()-moment().unix(), 'seconds').humanize(true));
-				})
-			}, 1000);
-
-			// Establish a websocket connection to the API server
-			reconnect();
-		</script>{{if .Recaptcha}}
-		<script src="https://www.google.com/recaptcha/api.js" async defer></script>{{end}}
-	</body>
-</html>

cmd/faucet/faucet_test.go

@@ -1,45 +0,0 @@
-// Copyright 2021 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-func TestFacebook(t *testing.T) {
-	// TODO: Remove facebook auth or implement facebook api, which seems to require an API key
-	t.Skipf("The facebook access is flaky, needs to be reimplemented or removed")
-	for _, tt := range []struct {
-		url  string
-		want common.Address
-	}{
-		{
-			"https://www.facebook.com/fooz.gazonk/posts/2837228539847129",
-			common.HexToAddress("0xDeadDeaDDeaDbEefbEeFbEEfBeeFBeefBeeFbEEF"),
-		},
-	} {
-		_, _, gotAddress, err := authFacebook(tt.url)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if gotAddress != tt.want {
-			t.Fatalf("address wrong, have %v want %v", gotAddress, tt.want)
-		}
-	}
-}

cmd/geth/accountcmd_test.go

@@ -43,11 +43,13 @@ func tmpDatadirWithKeystore(t *testing.T) string {
 }
 
 func TestAccountListEmpty(t *testing.T) {
+	t.Parallel()
 	geth := runGeth(t, "account", "list")
 	geth.ExpectExit()
 }
 
 func TestAccountList(t *testing.T) {
+	t.Parallel()
 	datadir := tmpDatadirWithKeystore(t)
 	var want = `
 Account #0: {7ef5a6135f1fd6a02593eedc869c6d41d934aef8} keystore://{{.Datadir}}/keystore/UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8
@@ -74,6 +76,7 @@ Account #2: {289d485d9771714cce91d3393d764e1311907acc} keystore://{{.Datadir}}\k
 }
 
 func TestAccountNew(t *testing.T) {
+	t.Parallel()
 	geth := runGeth(t, "account", "new", "--lightkdf")
 	defer geth.ExpectExit()
 	geth.Expect(`
@@ -96,6 +99,7 @@ Path of the secret key file: .*UTC--.+--[0-9a-f]{40}
 }
 
 func TestAccountImport(t *testing.T) {
+	t.Parallel()
 	tests := []struct{ name, key, output string }{
 		{
 			name:   "correct account",
@@ -118,6 +122,7 @@ func TestAccountImport(t *testing.T) {
 }
 
 func TestAccountHelp(t *testing.T) {
+	t.Parallel()
 	geth := runGeth(t, "account", "-h")
 	geth.WaitExit()
 	if have, want := geth.ExitStatus(), 0; have != want {
@@ -147,6 +152,7 @@ func importAccountWithExpect(t *testing.T, key string, expected string) {
 }
 
 func TestAccountNewBadRepeat(t *testing.T) {
+	t.Parallel()
 	geth := runGeth(t, "account", "new", "--lightkdf")
 	defer geth.ExpectExit()
 	geth.Expect(`
@@ -159,6 +165,7 @@ Fatal: Passwords do not match
 }
 
 func TestAccountUpdate(t *testing.T) {
+	t.Parallel()
 	datadir := tmpDatadirWithKeystore(t)
 	geth := runGeth(t, "account", "update",
 		"--datadir", datadir, "--lightkdf",
@@ -175,6 +182,7 @@ Repeat password: {{.InputLine "foobar2"}}
 }
 
 func TestWalletImport(t *testing.T) {
+	t.Parallel()
 	geth := runGeth(t, "wallet", "import", "--lightkdf", "testdata/guswallet.json")
 	defer geth.ExpectExit()
 	geth.Expect(`
@@ -190,6 +198,7 @@ Address: {d4584b5f6229b7be90727b0fc8c6b91bb427821f}
 }
 
 func TestWalletImportBadPassword(t *testing.T) {
+	t.Parallel()
 	geth := runGeth(t, "wallet", "import", "--lightkdf", "testdata/guswallet.json")
 	defer geth.ExpectExit()
 	geth.Expect(`
@@ -200,6 +209,7 @@ Fatal: could not decrypt key with given password
 }
 
 func TestUnlockFlag(t *testing.T) {
+	t.Parallel()
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "console", "--exec", "loadScript('testdata/empty.js')")
 	geth.Expect(`
@@ -222,6 +232,7 @@ undefined
 }
 
 func TestUnlockFlagWrongPassword(t *testing.T) {
+	t.Parallel()
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "console", "--exec", "loadScript('testdata/empty.js')")
 
@@ -240,6 +251,7 @@ Fatal: Failed to unlock account f466859ead1932d743d622cb74fc058882e8648a (could
 
 // https://github.com/ethereum/go-ethereum/issues/1785
 func TestUnlockFlagMultiIndex(t *testing.T) {
+	t.Parallel()
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--unlock", "0,2", "console", "--exec", "loadScript('testdata/empty.js')")
 
@@ -266,6 +278,7 @@ undefined
 }
 
 func TestUnlockFlagPasswordFile(t *testing.T) {
+	t.Parallel()
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--password", "testdata/passwords.txt", "--unlock", "0,2", "console", "--exec", "loadScript('testdata/empty.js')")
 
@@ -287,6 +300,7 @@ undefined
 }
 
 func TestUnlockFlagPasswordFileWrongPassword(t *testing.T) {
+	t.Parallel()
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--password",
 		"testdata/wrong-passwords.txt", "--unlock", "0,2")
@@ -297,6 +311,7 @@ Fatal: Failed to unlock account 0 (could not decrypt key with given password)
 }
 
 func TestUnlockFlagAmbiguous(t *testing.T) {
+	t.Parallel()
 	store := filepath.Join("..", "..", "accounts", "keystore", "testdata", "dupes")
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--keystore",
@@ -336,6 +351,7 @@ undefined
 }
 
 func TestUnlockFlagAmbiguousWrongPassword(t *testing.T) {
+	t.Parallel()
 	store := filepath.Join("..", "..", "accounts", "keystore", "testdata", "dupes")
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--keystore",

cmd/geth/chaincmd.go

@@ -137,20 +137,7 @@ The import-preimages command imports hash preimages from an RLP encoded stream.
 It's deprecated, please use "geth db import" instead.
 `,
 	}
-	exportPreimagesCommand = &cli.Command{
+
-		Action:    exportPreimages,
-		Name:      "export-preimages",
-		Usage:     "Export the preimage database into an RLP stream",
-		ArgsUsage: "<dumpfile>",
-		Flags: flags.Merge([]cli.Flag{
-			utils.CacheFlag,
-			utils.SyncModeFlag,
-		}, utils.DatabaseFlags),
-		Description: `
-The export-preimages command exports hash preimages to an RLP encoded stream.
-It's deprecated, please use "geth db export" instead.
-`,
-	}
 	dumpCommand = &cli.Command{
 		Action:    dump,
 		Name:      "dump",
@@ -224,14 +211,21 @@ func initGenesis(ctx *cli.Context) error {
 }
 
 func dumpGenesis(ctx *cli.Context) error {
-	// if there is a testnet preset enabled, dump that
+	// check if there is a testnet preset enabled
+	var genesis *core.Genesis
 	if utils.IsNetworkPreset(ctx) {
-		genesis := utils.MakeGenesis(ctx)
+		genesis = utils.MakeGenesis(ctx)
+	} else if ctx.IsSet(utils.DeveloperFlag.Name) && !ctx.IsSet(utils.DataDirFlag.Name) {
+		genesis = core.DeveloperGenesisBlock(11_500_000, nil)
+	}
+
+	if genesis != nil {
 		if err := json.NewEncoder(os.Stdout).Encode(genesis); err != nil {
 			utils.Fatalf("could not encode genesis: %s", err)
 		}
 		return nil
 	}
+
 	// dump whatever already exists in the datadir
 	stack, _ := makeConfigNode(ctx)
 	for _, name := range []string{"chaindata", "lightchaindata"} {
@@ -256,7 +250,7 @@ func dumpGenesis(ctx *cli.Context) error {
 	if ctx.IsSet(utils.DataDirFlag.Name) {
 		utils.Fatalf("no existing datadir at %s", stack.Config().DataDir)
 	}
-	utils.Fatalf("no network preset provided, no existing genesis in the default datadir")
+	utils.Fatalf("no network preset provided, and no genesis exists in the default datadir")
 	return nil
 }
 
@@ -379,6 +373,9 @@ func exportChain(ctx *cli.Context) error {
 }
 
 // importPreimages imports preimage data from the specified file.
+// it is deprecated, and the export function has been removed, but
+// the import function is kept around for the time being so that
+// older file formats can still be imported.
 func importPreimages(ctx *cli.Context) error {
 	if ctx.Args().Len() < 1 {
 		utils.Fatalf("This command requires an argument.")
@@ -398,25 +395,6 @@ func importPreimages(ctx *cli.Context) error {
 	return nil
 }
 
-// exportPreimages dumps the preimage data to specified json file in streaming way.
-func exportPreimages(ctx *cli.Context) error {
-	if ctx.Args().Len() < 1 {
-		utils.Fatalf("This command requires an argument.")
-	}
-	stack, _ := makeConfigNode(ctx)
-	defer stack.Close()
-
-	db := utils.MakeChainDatabase(ctx, stack, true)
-	defer db.Close()
-	start := time.Now()
-
-	if err := utils.ExportPreimages(db, ctx.Args().First()); err != nil {
-		utils.Fatalf("Export error: %v\n", err)
-	}
-	fmt.Printf("Export done in %v\n", time.Since(start))
-	return nil
-}
-
 func parseDumpConfig(ctx *cli.Context, stack *node.Node) (*state.DumpConfig, ethdb.Database, common.Hash, error) {
 	db := utils.MakeChainDatabase(ctx, stack, true)
 	defer db.Close()

cmd/geth/config.go

@@ -35,7 +35,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/eth/catalyst"
-	"github.com/ethereum/go-ethereum/eth/downloader"
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/internal/ethapi"
 	"github.com/ethereum/go-ethereum/internal/flags"
@@ -222,7 +221,7 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
 		}
 		catalyst.RegisterSimulatedBeaconAPIs(stack, simBeacon)
 		stack.RegisterLifecycle(simBeacon)
-	} else if cfg.Eth.SyncMode != downloader.LightSync {
+	} else {
 		err := catalyst.Register(stack, eth)
 		if err != nil {
 			utils.Fatalf("failed to register catalyst service: %v", err)

cmd/geth/consolecmd_test.go

@@ -50,6 +50,7 @@ func runMinimalGeth(t *testing.T, args ...string) *testgeth {
 // Tests that a node embedded within a console can be started up properly and
 // then terminated by closing the input stream.
 func TestConsoleWelcome(t *testing.T) {
+	t.Parallel()
 	coinbase := "0x8605cdbbdb6d264aa742e77020dcbc58fcdce182"
 
 	// Start a geth console, make sure it's cleaned up and terminate the console

cmd/geth/exportcmd_test.go

@@ -27,6 +27,7 @@ import (
 
 // TestExport does a basic test of "geth export", exporting the test-genesis.
 func TestExport(t *testing.T) {
+	t.Parallel()
 	outfile := fmt.Sprintf("%v/testExport.out", os.TempDir())
 	defer os.Remove(outfile)
 	geth := runGeth(t, "--datadir", initGeth(t), "export", outfile)

cmd/geth/les_test.go

@@ -1,205 +0,0 @@
-// Copyright 2020 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/rpc"
-)
-
-type gethrpc struct {
-	name     string
-	rpc      *rpc.Client
-	geth     *testgeth
-	nodeInfo *p2p.NodeInfo
-}
-
-func (g *gethrpc) killAndWait() {
-	g.geth.Kill()
-	g.geth.WaitExit()
-}
-
-func (g *gethrpc) callRPC(result interface{}, method string, args ...interface{}) {
-	if err := g.rpc.Call(&result, method, args...); err != nil {
-		g.geth.Fatalf("callRPC %v: %v", method, err)
-	}
-}
-
-func (g *gethrpc) addPeer(peer *gethrpc) {
-	g.geth.Logf("%v.addPeer(%v)", g.name, peer.name)
-	enode := peer.getNodeInfo().Enode
-	peerCh := make(chan *p2p.PeerEvent)
-	sub, err := g.rpc.Subscribe(context.Background(), "admin", peerCh, "peerEvents")
-	if err != nil {
-		g.geth.Fatalf("subscribe %v: %v", g.name, err)
-	}
-	defer sub.Unsubscribe()
-	g.callRPC(nil, "admin_addPeer", enode)
-	dur := 14 * time.Second
-	timeout := time.After(dur)
-	select {
-	case ev := <-peerCh:
-		g.geth.Logf("%v received event: type=%v, peer=%v", g.name, ev.Type, ev.Peer)
-	case err := <-sub.Err():
-		g.geth.Fatalf("%v sub error: %v", g.name, err)
-	case <-timeout:
-		g.geth.Error("timeout adding peer after", dur)
-	}
-}
-
-// Use this function instead of `g.nodeInfo` directly
-func (g *gethrpc) getNodeInfo() *p2p.NodeInfo {
-	if g.nodeInfo != nil {
-		return g.nodeInfo
-	}
-	g.nodeInfo = &p2p.NodeInfo{}
-	g.callRPC(&g.nodeInfo, "admin_nodeInfo")
-	return g.nodeInfo
-}
-
-// ipcEndpoint resolves an IPC endpoint based on a configured value, taking into
-// account the set data folders as well as the designated platform we're currently
-// running on.
-func ipcEndpoint(ipcPath, datadir string) string {
-	// On windows we can only use plain top-level pipes
-	if runtime.GOOS == "windows" {
-		if strings.HasPrefix(ipcPath, `\\.\pipe\`) {
-			return ipcPath
-		}
-		return `\\.\pipe\` + ipcPath
-	}
-	// Resolve names into the data directory full paths otherwise
-	if filepath.Base(ipcPath) == ipcPath {
-		if datadir == "" {
-			return filepath.Join(os.TempDir(), ipcPath)
-		}
-		return filepath.Join(datadir, ipcPath)
-	}
-	return ipcPath
-}
-
-// nextIPC ensures that each ipc pipe gets a unique name.
-// On linux, it works well to use ipc pipes all over the filesystem (in datadirs),
-// but windows require pipes to sit in "\\.\pipe\". Therefore, to run several
-// nodes simultaneously, we need to distinguish between them, which we do by
-// the pipe filename instead of folder.
-var nextIPC atomic.Uint32
-
-func startGethWithIpc(t *testing.T, name string, args ...string) *gethrpc {
-	ipcName := fmt.Sprintf("geth-%d.ipc", nextIPC.Add(1))
-	args = append([]string{"--networkid=42", "--port=0", "--authrpc.port", "0", "--ipcpath", ipcName}, args...)
-	t.Logf("Starting %v with rpc: %v", name, args)
-
-	g := &gethrpc{
-		name: name,
-		geth: runGeth(t, args...),
-	}
-	ipcpath := ipcEndpoint(ipcName, g.geth.Datadir)
-	// We can't know exactly how long geth will take to start, so we try 10
-	// times over a 5 second period.
-	var err error
-	for i := 0; i < 10; i++ {
-		time.Sleep(500 * time.Millisecond)
-		if g.rpc, err = rpc.Dial(ipcpath); err == nil {
-			return g
-		}
-	}
-	t.Fatalf("%v rpc connect to %v: %v", name, ipcpath, err)
-	return nil
-}
-
-func initGeth(t *testing.T) string {
-	args := []string{"--networkid=42", "init", "./testdata/clique.json"}
-	t.Logf("Initializing geth: %v ", args)
-	g := runGeth(t, args...)
-	datadir := g.Datadir
-	g.WaitExit()
-	return datadir
-}
-
-func startLightServer(t *testing.T) *gethrpc {
-	datadir := initGeth(t)
-	t.Logf("Importing keys to geth")
-	runGeth(t, "account", "import", "--datadir", datadir, "--password", "./testdata/password.txt", "--lightkdf", "./testdata/key.prv").WaitExit()
-	account := "0x02f0d131f1f97aef08aec6e3291b957d9efe7105"
-	server := startGethWithIpc(t, "lightserver", "--allow-insecure-unlock", "--datadir", datadir, "--password", "./testdata/password.txt", "--unlock", account, "--miner.etherbase=0x02f0d131f1f97aef08aec6e3291b957d9efe7105", "--mine", "--light.serve=100", "--light.maxpeers=1", "--discv4=false", "--nat=extip:127.0.0.1", "--verbosity=4")
-	return server
-}
-
-func startClient(t *testing.T, name string) *gethrpc {
-	datadir := initGeth(t)
-	return startGethWithIpc(t, name, "--datadir", datadir, "--discv4=false", "--syncmode=light", "--nat=extip:127.0.0.1", "--verbosity=4")
-}
-
-func TestPriorityClient(t *testing.T) {
-	lightServer := startLightServer(t)
-	defer lightServer.killAndWait()
-
-	// Start client and add lightServer as peer
-	freeCli := startClient(t, "freeCli")
-	defer freeCli.killAndWait()
-	freeCli.addPeer(lightServer)
-
-	var peers []*p2p.PeerInfo
-	freeCli.callRPC(&peers, "admin_peers")
-	if len(peers) != 1 {
-		t.Errorf("Expected: # of client peers == 1, actual: %v", len(peers))
-		return
-	}
-
-	// Set up priority client, get its nodeID, increase its balance on the lightServer
-	prioCli := startClient(t, "prioCli")
-	defer prioCli.killAndWait()
-	// 3_000_000_000 once we move to Go 1.13
-	tokens := uint64(3000000000)
-	lightServer.callRPC(nil, "les_addBalance", prioCli.getNodeInfo().ID, tokens)
-	prioCli.addPeer(lightServer)
-
-	// Check if priority client is actually syncing and the regular client got kicked out
-	prioCli.callRPC(&peers, "admin_peers")
-	if len(peers) != 1 {
-		t.Errorf("Expected: # of prio peers == 1, actual: %v", len(peers))
-	}
-
-	nodes := map[string]*gethrpc{
-		lightServer.getNodeInfo().ID: lightServer,
-		freeCli.getNodeInfo().ID:     freeCli,
-		prioCli.getNodeInfo().ID:     prioCli,
-	}
-	time.Sleep(1 * time.Second)
-	lightServer.callRPC(&peers, "admin_peers")
-	peersWithNames := make(map[string]string)
-	for _, p := range peers {
-		peersWithNames[nodes[p.ID].name] = p.ID
-	}
-	if _, freeClientFound := peersWithNames[freeCli.name]; freeClientFound {
-		t.Error("client is still a peer of lightServer", peersWithNames)
-	}
-	if _, prioClientFound := peersWithNames[prioCli.name]; !prioClientFound {
-		t.Error("prio client is not among lightServer peers", peersWithNames)
-	}
-}

cmd/geth/logging_test.go

@@ -58,6 +58,7 @@ func censor(input string, start, end int) string {
 }
 
 func TestLogging(t *testing.T) {
+	t.Parallel()
 	testConsoleLogging(t, "terminal", 6, 24)
 	testConsoleLogging(t, "logfmt", 2, 26)
 }
@@ -98,6 +99,7 @@ func testConsoleLogging(t *testing.T, format string, tStart, tEnd int) {
 }
 
 func TestVmodule(t *testing.T) {
+	t.Parallel()
 	checkOutput := func(level int, want, wantNot string) {
 		t.Helper()
 		output, err := runSelf("--log.format", "terminal", "--verbosity=0", "--log.vmodule", fmt.Sprintf("logtestcmd_active.go=%d", level), "logtest")
@@ -145,6 +147,7 @@ func nicediff(have, want []byte) string {
 }
 
 func TestFileOut(t *testing.T) {
+	t.Parallel()
 	var (
 		have, want []byte
 		err        error
@@ -165,6 +168,7 @@ func TestFileOut(t *testing.T) {
 }
 
 func TestRotatingFileOut(t *testing.T) {
+	t.Parallel()
 	var (
 		have, want []byte
 		err        error

cmd/geth/main.go

@@ -62,7 +62,7 @@ var (
 		utils.MinFreeDiskSpaceFlag,
 		utils.KeyStoreDirFlag,
 		utils.ExternalSignerFlag,
-		utils.NoUSBFlag,
+		utils.NoUSBFlag, // deprecated
 		utils.USBFlag,
 		utils.SmartCardDaemonPathFlag,
 		utils.OverrideCancun,
@@ -87,24 +87,24 @@ var (
 		utils.ExitWhenSyncedFlag,
 		utils.GCModeFlag,
 		utils.SnapshotFlag,
-		utils.TxLookupLimitFlag,
+		utils.TxLookupLimitFlag, // deprecated
 		utils.TransactionHistoryFlag,
 		utils.StateHistoryFlag,
-		utils.LightServeFlag,
+		utils.LightServeFlag,    // deprecated
-		utils.LightIngressFlag,
+		utils.LightIngressFlag,  // deprecated
-		utils.LightEgressFlag,
+		utils.LightEgressFlag,   // deprecated
-		utils.LightMaxPeersFlag,
+		utils.LightMaxPeersFlag, // deprecated
-		utils.LightNoPruneFlag,
+		utils.LightNoPruneFlag,  // deprecated
 		utils.LightKDFFlag,
-		utils.LightNoSyncServeFlag,
+		utils.LightNoSyncServeFlag, // deprecated
 		utils.EthRequiredBlocksFlag,
-		utils.LegacyWhitelistFlag,
+		utils.LegacyWhitelistFlag, // deprecated
 		utils.BloomFilterSizeFlag,
 		utils.CacheFlag,
 		utils.CacheDatabaseFlag,
 		utils.CacheTrieFlag,
-		utils.CacheTrieJournalFlag,
+		utils.CacheTrieJournalFlag,   // deprecated
-		utils.CacheTrieRejournalFlag,
+		utils.CacheTrieRejournalFlag, // deprecated
 		utils.CacheGCFlag,
 		utils.CacheSnapshotFlag,
 		utils.CacheNoPrefetchFlag,
@@ -127,7 +127,7 @@ var (
 		utils.NoDiscoverFlag,
 		utils.DiscoveryV4Flag,
 		utils.DiscoveryV5Flag,
-		utils.LegacyDiscoveryV5Flag,
+		utils.LegacyDiscoveryV5Flag, // deprecated
 		utils.NetrestrictFlag,
 		utils.NodeKeyFileFlag,
 		utils.NodeKeyHexFlag,
@@ -208,7 +208,6 @@ func init() {
 		importCommand,
 		exportCommand,
 		importPreimagesCommand,
-		exportPreimagesCommand,
 		removedbCommand,
 		dumpCommand,
 		dumpGenesisCommand,
@@ -307,7 +306,7 @@ func prepare(ctx *cli.Context) {
 		log.Info("Starting Geth on Ethereum mainnet...")
 	}
 	// If we're a full node on mainnet without --cache specified, bump default cache allowance
-	if ctx.String(utils.SyncModeFlag.Name) != "light" && !ctx.IsSet(utils.CacheFlag.Name) && !ctx.IsSet(utils.NetworkIdFlag.Name) {
+	if !ctx.IsSet(utils.CacheFlag.Name) && !ctx.IsSet(utils.NetworkIdFlag.Name) {
 		// Make sure we're not on any supported preconfigured testnet either
 		if !ctx.IsSet(utils.HoleskyFlag.Name) &&
 			!ctx.IsSet(utils.SepoliaFlag.Name) &&
@@ -318,11 +317,6 @@ func prepare(ctx *cli.Context) {
 			ctx.Set(utils.CacheFlag.Name, strconv.Itoa(4096))
 		}
 	}
-	// If we're running a light client on any network, drop the cache to some meaningfully low amount
-	if ctx.String(utils.SyncModeFlag.Name) == "light" && !ctx.IsSet(utils.CacheFlag.Name) {
-		log.Info("Dropping default light client cache", "provided", ctx.Int(utils.CacheFlag.Name), "updated", 128)
-		ctx.Set(utils.CacheFlag.Name, strconv.Itoa(128))
-	}
 
 	// Start metrics export if enabled
 	utils.SetupMetrics(ctx)

cmd/geth/run_test.go

@@ -55,6 +55,15 @@ func TestMain(m *testing.M) {
 	os.Exit(m.Run())
 }
 
+func initGeth(t *testing.T) string {
+	args := []string{"--networkid=42", "init", "./testdata/clique.json"}
+	t.Logf("Initializing geth: %v ", args)
+	g := runGeth(t, args...)
+	datadir := g.Datadir
+	g.WaitExit()
+	return datadir
+}
+
 // spawns geth with the given command line args. If the args don't set --datadir, the
 // child g gets a temporary data directory.
 func runGeth(t *testing.T, args ...string) *testgeth {

cmd/geth/snapshot.go

@@ -20,6 +20,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"os"
 	"time"
 
@@ -147,6 +148,17 @@ as the backend data source, making this command a lot faster.
 
 The argument is interpreted as block number or hash. If none is provided, the latest
 block is used.
+`,
+			},
+			{
+				Action:    snapshotExportPreimages,
+				Name:      "export-preimages",
+				Usage:     "Export the preimage in snapshot enumeration order",
+				ArgsUsage: "<dumpfile> [<root>]",
+				Flags:     utils.DatabaseFlags,
+				Description: `
+The export-preimages command exports hash preimages to a flat file, in exactly
+the expected order for the overlay tree migration.
 `,
 			},
 		},
@@ -604,6 +616,48 @@ func dumpState(ctx *cli.Context) error {
 	return nil
 }
 
+// snapshotExportPreimages dumps the preimage data to a flat file.
+func snapshotExportPreimages(ctx *cli.Context) error {
+	if ctx.NArg() < 1 {
+		utils.Fatalf("This command requires an argument.")
+	}
+	stack, _ := makeConfigNode(ctx)
+	defer stack.Close()
+
+	chaindb := utils.MakeChainDatabase(ctx, stack, true)
+	defer chaindb.Close()
+
+	triedb := utils.MakeTrieDatabase(ctx, chaindb, false, true, false)
+	defer triedb.Close()
+
+	var root common.Hash
+	if ctx.NArg() > 1 {
+		rootBytes := common.FromHex(ctx.Args().Get(1))
+		if len(rootBytes) != common.HashLength {
+			return fmt.Errorf("invalid hash: %s", ctx.Args().Get(1))
+		}
+		root = common.BytesToHash(rootBytes)
+	} else {
+		headBlock := rawdb.ReadHeadBlock(chaindb)
+		if headBlock == nil {
+			log.Error("Failed to load head block")
+			return errors.New("no head block")
+		}
+		root = headBlock.Root()
+	}
+	snapConfig := snapshot.Config{
+		CacheSize:  256,
+		Recovery:   false,
+		NoBuild:    true,
+		AsyncBuild: false,
+	}
+	snaptree, err := snapshot.New(snapConfig, chaindb, triedb, root)
+	if err != nil {
+		return err
+	}
+	return utils.ExportSnapshotPreimages(chaindb, snaptree, ctx.Args().First(), root)
+}
+
 // checkAccount iterates the snap data layers, and looks up the given account
 // across all layers.
 func checkAccount(ctx *cli.Context) error {

cmd/geth/version_check_test.go

@@ -30,14 +30,17 @@ import (
 )
 
 func TestVerification(t *testing.T) {
+	t.Parallel()
 	// Signatures generated with `minisign`. Legacy format, not pre-hashed file.
 	t.Run("minisig-legacy", func(t *testing.T) {
+		t.Parallel()
 		// For this test, the pubkey is in testdata/vcheck/minisign.pub
 		// (the privkey is `minisign.sec`, if we want to expand this test. Password 'test' )
 		pub := "RWQkliYstQBOKOdtClfgC3IypIPX6TAmoEi7beZ4gyR3wsaezvqOMWsp"
 		testVerification(t, pub, "./testdata/vcheck/minisig-sigs/")
 	})
 	t.Run("minisig-new", func(t *testing.T) {
+		t.Parallel()
 		// For this test, the pubkey is in testdata/vcheck/minisign.pub
 		// (the privkey is `minisign.sec`, if we want to expand this test. Password 'test' )
 		// `minisign -S -s ./minisign.sec  -m data.json  -x ./minisig-sigs-new/data.json.minisig`
@@ -46,6 +49,7 @@ func TestVerification(t *testing.T) {
 	})
 	// Signatures generated with `signify-openbsd`
 	t.Run("signify-openbsd", func(t *testing.T) {
+		t.Parallel()
 		t.Skip("This currently fails, minisign expects 4 lines of data, signify provides only 2")
 		// For this test, the pubkey is in testdata/vcheck/signifykey.pub
 		// (the privkey is `signifykey.sec`, if we want to expand this test. Password 'test' )
@@ -97,6 +101,7 @@ func versionUint(v string) int {
 
 // TestMatching can be used to check that the regexps are correct
 func TestMatching(t *testing.T) {
+	t.Parallel()
 	data, _ := os.ReadFile("./testdata/vcheck/vulnerabilities.json")
 	var vulns []vulnJson
 	if err := json.Unmarshal(data, &vulns); err != nil {
@@ -141,6 +146,7 @@ func TestMatching(t *testing.T) {
 }
 
 func TestGethPubKeysParseable(t *testing.T) {
+	t.Parallel()
 	for _, pubkey := range gethPubKeys {
 		_, err := minisign.NewPublicKey(pubkey)
 		if err != nil {
@@ -150,6 +156,7 @@ func TestGethPubKeysParseable(t *testing.T) {
 }
 
 func TestKeyID(t *testing.T) {
+	t.Parallel()
 	type args struct {
 		id [8]byte
 	}
@@ -163,7 +170,9 @@ func TestKeyID(t *testing.T) {
 		{"third key", args{id: extractKeyId(gethPubKeys[2])}, "FD9813B2D2098484"},
 	}
 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
 			if got := keyID(tt.args.id); got != tt.want {
 				t.Errorf("keyID() = %v, want %v", got, tt.want)
 			}

cmd/rlpdump/rlpdump_test.go

@@ -27,6 +27,7 @@ import (
 )
 
 func TestRoundtrip(t *testing.T) {
+	t.Parallel()
 	for i, want := range []string{
 		"0xf880806482520894d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0a1010000000000000000000000000000000000000000000000000000000000000001801ba0c16787a8e25e941d67691954642876c08f00996163ae7dfadbbfd6cd436f549da06180e5626cae31590f40641fe8f63734316c4bfeb4cdfab6714198c1044d2e28",
 		"0xd5c0d3cb84746573742a2a808213378667617a6f6e6b",
@@ -51,6 +52,7 @@ func TestRoundtrip(t *testing.T) {
 }
 
 func TestTextToRlp(t *testing.T) {
+	t.Parallel()
 	type tc struct {
 		text string
 		want string

cmd/utils/cmd.go

@@ -33,6 +33,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/state/snapshot"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
@@ -374,6 +375,101 @@ func ExportPreimages(db ethdb.Database, fn string) error {
 	return nil
 }
 
+// ExportSnapshotPreimages exports the preimages corresponding to the enumeration of
+// the snapshot for a given root.
+func ExportSnapshotPreimages(chaindb ethdb.Database, snaptree *snapshot.Tree, fn string, root common.Hash) error {
+	log.Info("Exporting preimages", "file", fn)
+
+	fh, err := os.OpenFile(fn, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
+	if err != nil {
+		return err
+	}
+	defer fh.Close()
+
+	// Enable gzip compressing if file name has gz suffix.
+	var writer io.Writer = fh
+	if strings.HasSuffix(fn, ".gz") {
+		gz := gzip.NewWriter(writer)
+		defer gz.Close()
+		writer = gz
+	}
+	buf := bufio.NewWriter(writer)
+	defer buf.Flush()
+	writer = buf
+
+	type hashAndPreimageSize struct {
+		Hash common.Hash
+		Size int
+	}
+	hashCh := make(chan hashAndPreimageSize)
+
+	var (
+		start     = time.Now()
+		logged    = time.Now()
+		preimages int
+	)
+	go func() {
+		defer close(hashCh)
+		accIt, err := snaptree.AccountIterator(root, common.Hash{})
+		if err != nil {
+			log.Error("Failed to create account iterator", "error", err)
+			return
+		}
+		defer accIt.Release()
+
+		for accIt.Next() {
+			acc, err := types.FullAccount(accIt.Account())
+			if err != nil {
+				log.Error("Failed to get full account", "error", err)
+				return
+			}
+			preimages += 1
+			hashCh <- hashAndPreimageSize{Hash: accIt.Hash(), Size: common.AddressLength}
+
+			if acc.Root != (common.Hash{}) && acc.Root != types.EmptyRootHash {
+				stIt, err := snaptree.StorageIterator(root, accIt.Hash(), common.Hash{})
+				if err != nil {
+					log.Error("Failed to create storage iterator", "error", err)
+					return
+				}
+				for stIt.Next() {
+					preimages += 1
+					hashCh <- hashAndPreimageSize{Hash: stIt.Hash(), Size: common.HashLength}
+
+					if time.Since(logged) > time.Second*8 {
+						logged = time.Now()
+						log.Info("Exporting preimages", "count", preimages, "elapsed", common.PrettyDuration(time.Since(start)))
+					}
+				}
+				stIt.Release()
+			}
+			if time.Since(logged) > time.Second*8 {
+				logged = time.Now()
+				log.Info("Exporting preimages", "count", preimages, "elapsed", common.PrettyDuration(time.Since(start)))
+			}
+		}
+	}()
+
+	for item := range hashCh {
+		preimage := rawdb.ReadPreimage(chaindb, item.Hash)
+		if len(preimage) == 0 {
+			return fmt.Errorf("missing preimage for %v", item.Hash)
+		}
+		if len(preimage) != item.Size {
+			return fmt.Errorf("invalid preimage size, have %d", len(preimage))
+		}
+		rlpenc, err := rlp.EncodeToBytes(preimage)
+		if err != nil {
+			return fmt.Errorf("error encoding preimage: %w", err)
+		}
+		if _, err := writer.Write(rlpenc); err != nil {
+			return fmt.Errorf("failed to write preimage: %w", err)
+		}
+	}
+	log.Info("Exported preimages", "count", preimages, "elapsed", common.PrettyDuration(time.Since(start)), "file", fn)
+	return nil
+}
+
 // exportHeader is used in the export/import flow. When we do an export,
 // the first element we output is the exportHeader.
 // Whenever a backwards-incompatible change is made, the Version header

cmd/utils/export_test.go

@@ -170,6 +170,7 @@ func testDeletion(t *testing.T, f string) {
 
 // TestImportFutureFormat tests that we reject unsupported future versions.
 func TestImportFutureFormat(t *testing.T) {
+	t.Parallel()
 	f := fmt.Sprintf("%v/tempdump-future", os.TempDir())
 	defer func() {
 		os.Remove(f)

cmd/utils/flags.go

@@ -57,7 +57,6 @@ import (
 	"github.com/ethereum/go-ethereum/graphql"
 	"github.com/ethereum/go-ethereum/internal/ethapi"
 	"github.com/ethereum/go-ethereum/internal/flags"
-	"github.com/ethereum/go-ethereum/les"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/metrics/exp"
@@ -255,7 +254,7 @@ var (
 	}
 	SyncModeFlag = &flags.TextMarshalerFlag{
 		Name:     "syncmode",
-		Usage:    `Blockchain sync mode ("snap", "full" or "light")`,
+		Usage:    `Blockchain sync mode ("snap" or "full")`,
 		Value:    &defaultSyncMode,
 		Category: flags.StateCategory,
 	}
@@ -282,41 +281,6 @@ var (
 		Value:    ethconfig.Defaults.TransactionHistory,
 		Category: flags.StateCategory,
 	}
-	// Light server and client settings
-	LightServeFlag = &cli.IntFlag{
-		Name:     "light.serve",
-		Usage:    "Maximum percentage of time allowed for serving LES requests (multi-threaded processing allows values over 100)",
-		Value:    ethconfig.Defaults.LightServ,
-		Category: flags.LightCategory,
-	}
-	LightIngressFlag = &cli.IntFlag{
-		Name:     "light.ingress",
-		Usage:    "Incoming bandwidth limit for serving light clients (kilobytes/sec, 0 = unlimited)",
-		Value:    ethconfig.Defaults.LightIngress,
-		Category: flags.LightCategory,
-	}
-	LightEgressFlag = &cli.IntFlag{
-		Name:     "light.egress",
-		Usage:    "Outgoing bandwidth limit for serving light clients (kilobytes/sec, 0 = unlimited)",
-		Value:    ethconfig.Defaults.LightEgress,
-		Category: flags.LightCategory,
-	}
-	LightMaxPeersFlag = &cli.IntFlag{
-		Name:     "light.maxpeers",
-		Usage:    "Maximum number of light clients to serve, or light servers to attach to",
-		Value:    ethconfig.Defaults.LightPeers,
-		Category: flags.LightCategory,
-	}
-	LightNoPruneFlag = &cli.BoolFlag{
-		Name:     "light.nopruning",
-		Usage:    "Disable ancient light chain data pruning",
-		Category: flags.LightCategory,
-	}
-	LightNoSyncServeFlag = &cli.BoolFlag{
-		Name:     "light.nosyncserve",
-		Usage:    "Enables serving light clients before syncing",
-		Category: flags.LightCategory,
-	}
 	// Transaction pool settings
 	TxPoolLocalsFlag = &cli.StringFlag{
 		Name:     "txpool.locals",
@@ -1224,25 +1188,25 @@ func setIPC(ctx *cli.Context, cfg *node.Config) {
 	}
 }
 
-// setLes configures the les server and ultra light client settings from the command line flags.
+// setLes shows the deprecation warnings for LES flags.
 func setLes(ctx *cli.Context, cfg *ethconfig.Config) {
 	if ctx.IsSet(LightServeFlag.Name) {
-		cfg.LightServ = ctx.Int(LightServeFlag.Name)
+		log.Warn("The light server has been deprecated, please remove this flag", "flag", LightServeFlag.Name)
 	}
 	if ctx.IsSet(LightIngressFlag.Name) {
-		cfg.LightIngress = ctx.Int(LightIngressFlag.Name)
+		log.Warn("The light server has been deprecated, please remove this flag", "flag", LightIngressFlag.Name)
 	}
 	if ctx.IsSet(LightEgressFlag.Name) {
-		cfg.LightEgress = ctx.Int(LightEgressFlag.Name)
+		log.Warn("The light server has been deprecated, please remove this flag", "flag", LightEgressFlag.Name)
 	}
 	if ctx.IsSet(LightMaxPeersFlag.Name) {
-		cfg.LightPeers = ctx.Int(LightMaxPeersFlag.Name)
+		log.Warn("The light server has been deprecated, please remove this flag", "flag", LightMaxPeersFlag.Name)
 	}
 	if ctx.IsSet(LightNoPruneFlag.Name) {
-		cfg.LightNoPrune = ctx.Bool(LightNoPruneFlag.Name)
+		log.Warn("The light server has been deprecated, please remove this flag", "flag", LightNoPruneFlag.Name)
 	}
 	if ctx.IsSet(LightNoSyncServeFlag.Name) {
-		cfg.LightNoSyncServe = ctx.Bool(LightNoSyncServeFlag.Name)
+		log.Warn("The light server has been deprecated, please remove this flag", "flag", LightNoSyncServeFlag.Name)
 	}
 }
 
@@ -1340,58 +1304,24 @@ func SetP2PConfig(ctx *cli.Context, cfg *p2p.Config) {
 	setBootstrapNodes(ctx, cfg)
 	setBootstrapNodesV5(ctx, cfg)
 
-	lightClient := ctx.String(SyncModeFlag.Name) == "light"
-	lightServer := (ctx.Int(LightServeFlag.Name) != 0)
-
-	lightPeers := ctx.Int(LightMaxPeersFlag.Name)
-	if lightClient && !ctx.IsSet(LightMaxPeersFlag.Name) {
-		// dynamic default - for clients we use 1/10th of the default for servers
-		lightPeers /= 10
-	}
-
 	if ctx.IsSet(MaxPeersFlag.Name) {
 		cfg.MaxPeers = ctx.Int(MaxPeersFlag.Name)
-		if lightServer && !ctx.IsSet(LightMaxPeersFlag.Name) {
-			cfg.MaxPeers += lightPeers
-		}
-	} else {
-		if lightServer {
-			cfg.MaxPeers += lightPeers
-		}
-		if lightClient && ctx.IsSet(LightMaxPeersFlag.Name) && cfg.MaxPeers < lightPeers {
-			cfg.MaxPeers = lightPeers
-		}
 	}
-	if !(lightClient || lightServer) {
+	ethPeers := cfg.MaxPeers
-		lightPeers = 0
+	log.Info("Maximum peer count", "ETH", ethPeers, "total", cfg.MaxPeers)
-	}
-	ethPeers := cfg.MaxPeers - lightPeers
-	if lightClient {
-		ethPeers = 0
-	}
-	log.Info("Maximum peer count", "ETH", ethPeers, "LES", lightPeers, "total", cfg.MaxPeers)
 
 	if ctx.IsSet(MaxPendingPeersFlag.Name) {
 		cfg.MaxPendingPeers = ctx.Int(MaxPendingPeersFlag.Name)
 	}
-	if ctx.IsSet(NoDiscoverFlag.Name) || lightClient {
+	if ctx.IsSet(NoDiscoverFlag.Name) {
 		cfg.NoDiscovery = true
 	}
 
-	// Disallow --nodiscover when used in conjunction with light mode.
-	if (lightClient || lightServer) && ctx.Bool(NoDiscoverFlag.Name) {
-		Fatalf("Cannot use --" + NoDiscoverFlag.Name + " in light client or light server mode")
-	}
 	CheckExclusive(ctx, DiscoveryV4Flag, NoDiscoverFlag)
 	CheckExclusive(ctx, DiscoveryV5Flag, NoDiscoverFlag)
 	cfg.DiscoveryV4 = ctx.Bool(DiscoveryV4Flag.Name)
 	cfg.DiscoveryV5 = ctx.Bool(DiscoveryV5Flag.Name)
 
-	// If we're running a light client or server, force enable the v5 peer discovery.
-	if lightClient || lightServer {
-		cfg.DiscoveryV5 = true
-	}
-
 	if netrestrict := ctx.String(NetrestrictFlag.Name); netrestrict != "" {
 		list, err := netutil.ParseNetlist(netrestrict)
 		if err != nil {
@@ -1496,12 +1426,7 @@ func SetDataDir(ctx *cli.Context, cfg *node.Config) {
 	}
 }
 
-func setGPO(ctx *cli.Context, cfg *gasprice.Config, light bool) {
+func setGPO(ctx *cli.Context, cfg *gasprice.Config) {
-	// If we are running the light client, apply another group
-	// settings for gas oracle.
-	if light {
-		*cfg = ethconfig.LightClientGPO
-	}
 	if ctx.IsSet(GpoBlocksFlag.Name) {
 		cfg.Blocks = ctx.Int(GpoBlocksFlag.Name)
 	}
@@ -1650,12 +1575,11 @@ func CheckExclusive(ctx *cli.Context, args ...interface{}) {
 func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 	// Avoid conflicting network flags
 	CheckExclusive(ctx, MainnetFlag, DeveloperFlag, GoerliFlag, SepoliaFlag, HoleskyFlag)
-	CheckExclusive(ctx, LightServeFlag, SyncModeFlag, "light")
 	CheckExclusive(ctx, DeveloperFlag, ExternalSignerFlag) // Can't use both ephemeral unlocked and external signer
 
 	// Set configurations from CLI flags
 	setEtherbase(ctx, cfg)
-	setGPO(ctx, &cfg.GPO, ctx.String(SyncModeFlag.Name) == "light")
+	setGPO(ctx, &cfg.GPO)
 	setTxPool(ctx, &cfg.TxPool)
 	setMiner(ctx, &cfg.Miner)
 	setRequiredBlocks(ctx, cfg)
@@ -1734,9 +1658,6 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 		cfg.TransactionHistory = 0
 		log.Warn("Disabled transaction unindexing for archive node")
 	}
-	if ctx.IsSet(LightServeFlag.Name) && cfg.TransactionHistory != 0 {
-		log.Warn("LES server cannot serve old transaction status and cannot connect below les/4 protocol version if transaction lookup index is limited")
-	}
 	if ctx.IsSet(CacheFlag.Name) || ctx.IsSet(CacheTrieFlag.Name) {
 		cfg.TrieCleanCache = ctx.Int(CacheFlag.Name) * ctx.Int(CacheTrieFlag.Name) / 100
 	}
@@ -1865,11 +1786,26 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 		log.Info("Using developer account", "address", developer.Address)
 
 		// Create a new developer genesis block or reuse existing one
-		cfg.Genesis = core.DeveloperGenesisBlock(ctx.Uint64(DeveloperGasLimitFlag.Name), developer.Address)
+		cfg.Genesis = core.DeveloperGenesisBlock(ctx.Uint64(DeveloperGasLimitFlag.Name), &developer.Address)
 		if ctx.IsSet(DataDirFlag.Name) {
 			chaindb := tryMakeReadOnlyDatabase(ctx, stack)
 			if rawdb.ReadCanonicalHash(chaindb, 0) != (common.Hash{}) {
 				cfg.Genesis = nil // fallback to db content
+
+				//validate genesis has PoS enabled in block 0
+				genesis, err := core.ReadGenesis(chaindb)
+				if err != nil {
+					Fatalf("Could not read genesis from database: %v", err)
+				}
+				if !genesis.Config.TerminalTotalDifficultyPassed {
+					Fatalf("Bad developer-mode genesis configuration: terminalTotalDifficultyPassed must be true in developer mode")
+				}
+				if genesis.Config.TerminalTotalDifficulty == nil {
+					Fatalf("Bad developer-mode genesis configuration: terminalTotalDifficulty must be specified.")
+				}
+				if genesis.Difficulty.Cmp(genesis.Config.TerminalTotalDifficulty) != 1 {
+					Fatalf("Bad developer-mode genesis configuration: genesis block difficulty must be > terminalTotalDifficulty")
+				}
 			}
 			chaindb.Close()
 		}
@@ -1898,9 +1834,6 @@ func SetDNSDiscoveryDefaults(cfg *ethconfig.Config, genesis common.Hash) {
 		return // already set through flags/config
 	}
 	protocol := "all"
-	if cfg.SyncMode == downloader.LightSync {
-		protocol = "les"
-	}
 	if url := params.KnownDNSNetwork(genesis, protocol); url != "" {
 		cfg.EthDiscoveryURLs = []string{url}
 		cfg.SnapDiscoveryURLs = cfg.EthDiscoveryURLs
@@ -1908,27 +1841,12 @@ func SetDNSDiscoveryDefaults(cfg *ethconfig.Config, genesis common.Hash) {
 }
 
 // RegisterEthService adds an Ethereum client to the stack.
-// The second return value is the full node instance, which may be nil if the
+// The second return value is the full node instance.
-// node is running as a light client.
 func RegisterEthService(stack *node.Node, cfg *ethconfig.Config) (ethapi.Backend, *eth.Ethereum) {
-	if cfg.SyncMode == downloader.LightSync {
-		backend, err := les.New(stack, cfg)
-		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 {
-			Fatalf("Failed to create the LES server: %v", err)
-		}
-	}
 	stack.RegisterAPIs(tracers.APIs(backend.APIBackend))
 	return backend.APIBackend, backend
 }
@@ -1950,13 +1868,12 @@ func RegisterGraphQLService(stack *node.Node, backend ethapi.Backend, filterSyst
 
 // RegisterFilterAPI adds the eth log filtering RPC API to the node.
 func RegisterFilterAPI(stack *node.Node, backend ethapi.Backend, ethcfg *ethconfig.Config) *filters.FilterSystem {
-	isLightClient := ethcfg.SyncMode == downloader.LightSync
 	filterSystem := filters.NewFilterSystem(backend, filters.Config{
 		LogCacheSize: ethcfg.FilterLogCacheSize,
 	})
 	stack.RegisterAPIs([]rpc.API{{
 		Namespace: "eth",
-		Service:   filters.NewFilterAPI(filterSystem, isLightClient),
+		Service:   filters.NewFilterAPI(filterSystem, false),
 	}})
 	return filterSystem
 }

cmd/utils/flags_legacy.go

@@ -39,6 +39,12 @@ var DeprecatedFlags = []cli.Flag{
 	CacheTrieRejournalFlag,
 	LegacyDiscoveryV5Flag,
 	TxLookupLimitFlag,
+	LightServeFlag,
+	LightIngressFlag,
+	LightEgressFlag,
+	LightMaxPeersFlag,
+	LightNoPruneFlag,
+	LightNoSyncServeFlag,
 }
 
 var (
@@ -77,6 +83,41 @@ var (
 		Value:    ethconfig.Defaults.TransactionHistory,
 		Category: flags.DeprecatedCategory,
 	}
+	// Light server and client settings, Deprecated November 2023
+	LightServeFlag = &cli.IntFlag{
+		Name:     "light.serve",
+		Usage:    "Maximum percentage of time allowed for serving LES requests (deprecated)",
+		Value:    ethconfig.Defaults.LightServ,
+		Category: flags.LightCategory,
+	}
+	LightIngressFlag = &cli.IntFlag{
+		Name:     "light.ingress",
+		Usage:    "Incoming bandwidth limit for serving light clients (deprecated)",
+		Value:    ethconfig.Defaults.LightIngress,
+		Category: flags.LightCategory,
+	}
+	LightEgressFlag = &cli.IntFlag{
+		Name:     "light.egress",
+		Usage:    "Outgoing bandwidth limit for serving light clients (deprecated)",
+		Value:    ethconfig.Defaults.LightEgress,
+		Category: flags.LightCategory,
+	}
+	LightMaxPeersFlag = &cli.IntFlag{
+		Name:     "light.maxpeers",
+		Usage:    "Maximum number of light clients to serve, or light servers to attach to (deprecated)",
+		Value:    ethconfig.Defaults.LightPeers,
+		Category: flags.LightCategory,
+	}
+	LightNoPruneFlag = &cli.BoolFlag{
+		Name:     "light.nopruning",
+		Usage:    "Disable ancient light chain data pruning (deprecated)",
+		Category: flags.LightCategory,
+	}
+	LightNoSyncServeFlag = &cli.BoolFlag{
+		Name:     "light.nosyncserve",
+		Usage:    "Enables serving light clients before syncing (deprecated)",
+		Category: flags.LightCategory,
+	}
 )
 
 // showDeprecated displays deprecated flags that will be soon removed from the codebase.

cmd/utils/flags_test.go

@@ -23,6 +23,7 @@ import (
 )
 
 func Test_SplitTagsFlag(t *testing.T) {
+	t.Parallel()
 	tests := []struct {
 		name string
 		args string
@@ -55,7 +56,9 @@ func Test_SplitTagsFlag(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
 			if got := SplitTagsFlag(tt.args); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("splitTagsFlag() = %v, want %v", got, tt.want)
 			}

cmd/utils/prompt_test.go

@@ -22,6 +22,7 @@ import (
 )
 
 func TestGetPassPhraseWithList(t *testing.T) {
+	t.Parallel()
 	type args struct {
 		text         string
 		confirmation bool
@@ -65,7 +66,9 @@ func TestGetPassPhraseWithList(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
 			if got := GetPassPhraseWithList(tt.args.text, tt.args.confirmation, tt.args.index, tt.args.passwords); got != tt.want {
 				t.Errorf("GetPassPhraseWithList() = %v, want %v", got, tt.want)
 			}

console/console_test.go

@@ -94,7 +94,7 @@ func newTester(t *testing.T, confOverride func(*ethconfig.Config)) *tester {
 		t.Fatalf("failed to create node: %v", err)
 	}
 	ethConf := &ethconfig.Config{
-		Genesis: core.DeveloperGenesisBlock(11_500_000, common.Address{}),
+		Genesis: core.DeveloperGenesisBlock(11_500_000, nil),
 		Miner: miner.Config{
 			Etherbase: common.HexToAddress(testAddress),
 		},

core/forkid/forkid_test.go

@@ -366,8 +366,9 @@ func TestValidation(t *testing.T) {
 		// TODO(karalabe): Enable this when Cancun is specced
 		//{params.MainnetChainConfig, 20999999, 1677999999, ID{Hash: checksumToBytes(0x71147644), Next: 1678000000}, ErrLocalIncompatibleOrStale},
 	}
+	genesis := core.DefaultGenesisBlock().ToBlock()
 	for i, tt := range tests {
-		filter := newFilter(tt.config, core.DefaultGenesisBlock().ToBlock(), func() (uint64, uint64) { return tt.head, tt.time })
+		filter := newFilter(tt.config, genesis, func() (uint64, uint64) { return tt.head, tt.time })
 		if err := filter(tt.id); err != tt.err {
 			t.Errorf("test %d: validation error mismatch: have %v, want %v", i, err, tt.err)
 		}

core/genesis.go

@@ -580,16 +580,16 @@ func DefaultHoleskyGenesisBlock() *Genesis {
 }
 
 // DeveloperGenesisBlock returns the 'geth --dev' genesis block.
-func DeveloperGenesisBlock(gasLimit uint64, faucet common.Address) *Genesis {
+func DeveloperGenesisBlock(gasLimit uint64, faucet *common.Address) *Genesis {
 	// Override the default period to the user requested one
 	config := *params.AllDevChainProtocolChanges
 
 	// Assemble and return the genesis with the precompiles and faucet pre-funded
-	return &Genesis{
+	genesis := &Genesis{
 		Config:     &config,
 		GasLimit:   gasLimit,
 		BaseFee:    big.NewInt(params.InitialBaseFee),
-		Difficulty: big.NewInt(0),
+		Difficulty: big.NewInt(1),
 		Alloc: map[common.Address]GenesisAccount{
 			common.BytesToAddress([]byte{1}): {Balance: big.NewInt(1)}, // ECRecover
 			common.BytesToAddress([]byte{2}): {Balance: big.NewInt(1)}, // SHA256
@@ -600,9 +600,12 @@ func DeveloperGenesisBlock(gasLimit uint64, faucet common.Address) *Genesis {
 			common.BytesToAddress([]byte{7}): {Balance: big.NewInt(1)}, // ECScalarMul
 			common.BytesToAddress([]byte{8}): {Balance: big.NewInt(1)}, // ECPairing
 			common.BytesToAddress([]byte{9}): {Balance: big.NewInt(1)}, // BLAKE2b
-			faucet:                           {Balance: new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(9))},
 		},
 	}
+	if faucet != nil {
+		genesis.Alloc[*faucet] = GenesisAccount{Balance: new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(9))}
+	}
+	return genesis
 }
 
 func decodePrealloc(data string) GenesisAlloc {

core/state/snapshot/generate.go

@@ -446,7 +446,7 @@ func (dl *diskLayer) generateRange(ctx *generatorContext, trieId *trie.ID, prefi
 		// Trie errors should never happen. Still, in case of a bug, expose the
 		// error here, as the outer code will presume errors are interrupts, not
 		// some deeper issues.
-		log.Error("State snapshotter failed to iterate trie", "err", err)
+		log.Error("State snapshotter failed to iterate trie", "err", iter.Err)
 		return false, nil, iter.Err
 	}
 	// Delete all stale snapshot states remaining

core/state/statedb_test.go

@@ -426,10 +426,12 @@ func (test *snapshotTest) run() bool {
 		state, _     = New(types.EmptyRootHash, NewDatabase(rawdb.NewMemoryDatabase()), nil)
 		snapshotRevs = make([]int, len(test.snapshots))
 		sindex       = 0
+		checkstates  = make([]*StateDB, len(test.snapshots))
 	)
 	for i, action := range test.actions {
 		if len(test.snapshots) > sindex && i == test.snapshots[sindex] {
 			snapshotRevs[sindex] = state.Snapshot()
+			checkstates[sindex] = state.Copy()
 			sindex++
 		}
 		action.fn(action, state)
@@ -437,12 +439,8 @@ func (test *snapshotTest) run() bool {
 	// Revert all snapshots in reverse order. Each revert must yield a state
 	// that is equivalent to fresh state with all actions up the snapshot applied.
 	for sindex--; sindex >= 0; sindex-- {
-		checkstate, _ := New(types.EmptyRootHash, state.Database(), nil)
-		for _, action := range test.actions[:test.snapshots[sindex]] {
-			action.fn(action, checkstate)
-		}
 		state.RevertToSnapshot(snapshotRevs[sindex])
-		if err := test.checkEqual(state, checkstate); err != nil {
+		if err := test.checkEqual(state, checkstates[sindex]); err != nil {
 			test.err = fmt.Errorf("state mismatch after revert to snapshot %d\n%v", sindex, err)
 			return false
 		}

core/txpool/legacypool/legacypool.go

@@ -959,6 +959,9 @@ func (pool *LegacyPool) addRemoteSync(tx *types.Transaction) error {
 // If sync is set, the method will block until all internal maintenance related
 // to the add is finished. Only use this during tests for determinism!
 func (pool *LegacyPool) Add(txs []*types.Transaction, local, sync bool) []error {
+	// Do not treat as local if local transactions have been disabled
+	local = local && !pool.config.NoLocals
+
 	// Filter out known ones without obtaining the pool lock or recovering signatures
 	var (
 		errs = make([]error, len(txs))

core/txpool/legacypool/legacypool_test.go

@@ -1492,6 +1492,50 @@ func TestRepricing(t *testing.T) {
 	}
 }
 
+func TestMinGasPriceEnforced(t *testing.T) {
+	t.Parallel()
+
+	// Create the pool to test the pricing enforcement with
+	statedb, _ := state.New(types.EmptyRootHash, state.NewDatabase(rawdb.NewMemoryDatabase()), nil)
+	blockchain := newTestBlockChain(eip1559Config, 10000000, statedb, new(event.Feed))
+
+	txPoolConfig := DefaultConfig
+	txPoolConfig.NoLocals = true
+	pool := New(txPoolConfig, blockchain)
+	pool.Init(new(big.Int).SetUint64(txPoolConfig.PriceLimit), blockchain.CurrentBlock(), makeAddressReserver())
+	defer pool.Close()
+
+	key, _ := crypto.GenerateKey()
+	testAddBalance(pool, crypto.PubkeyToAddress(key.PublicKey), big.NewInt(1000000))
+
+	tx := pricedTransaction(0, 100000, big.NewInt(2), key)
+	pool.SetGasTip(big.NewInt(tx.GasPrice().Int64() + 1))
+
+	if err := pool.addLocal(tx); !errors.Is(err, txpool.ErrUnderpriced) {
+		t.Fatalf("Min tip not enforced")
+	}
+
+	if err := pool.Add([]*types.Transaction{tx}, true, false)[0]; !errors.Is(err, txpool.ErrUnderpriced) {
+		t.Fatalf("Min tip not enforced")
+	}
+
+	tx = dynamicFeeTx(0, 100000, big.NewInt(3), big.NewInt(2), key)
+	pool.SetGasTip(big.NewInt(tx.GasTipCap().Int64() + 1))
+
+	if err := pool.addLocal(tx); !errors.Is(err, txpool.ErrUnderpriced) {
+		t.Fatalf("Min tip not enforced")
+	}
+
+	if err := pool.Add([]*types.Transaction{tx}, true, false)[0]; !errors.Is(err, txpool.ErrUnderpriced) {
+		t.Fatalf("Min tip not enforced")
+	}
+	// Make sure the tx is accepted if locals are enabled
+	pool.config.NoLocals = false
+	if err := pool.Add([]*types.Transaction{tx}, true, false)[0]; err != nil {
+		t.Fatalf("Min tip enforced with locals enabled, error: %v", err)
+	}
+}
+
 // Tests that setting the transaction pool gas price to a higher value correctly
 // discards everything cheaper (legacy & dynamic fee) than that and moves any
 // gapped transactions back from the pending pool to the queue.

core/types/transaction.go

@@ -37,6 +37,9 @@ var (
 	ErrTxTypeNotSupported   = errors.New("transaction type not supported")
 	ErrGasFeeCapTooLow      = errors.New("fee cap less than base fee")
 	errShortTypedTx         = errors.New("typed transaction too short")
+	errInvalidYParity       = errors.New("'yParity' field must be 0 or 1")
+	errVYParityMismatch     = errors.New("'v' and 'yParity' fields do not match")
+	errVYParityMissing      = errors.New("missing 'yParity' or 'v' field in transaction")
 )
 
 // Transaction types.

core/types/transaction_marshalling.go

@@ -57,18 +57,18 @@ func (tx *txJSON) yParityValue() (*big.Int, error) {
 	if tx.YParity != nil {
 		val := uint64(*tx.YParity)
 		if val != 0 && val != 1 {
-			return nil, errors.New("'yParity' field must be 0 or 1")
+			return nil, errInvalidYParity
 		}
 		bigval := new(big.Int).SetUint64(val)
 		if tx.V != nil && tx.V.ToInt().Cmp(bigval) != 0 {
-			return nil, errors.New("'v' and 'yParity' fields do not match")
+			return nil, errVYParityMismatch
 		}
 		return bigval, nil
 	}
 	if tx.V != nil {
 		return tx.V.ToInt(), nil
 	}
-	return nil, errors.New("missing 'yParity' or 'v' field in transaction")
+	return nil, errVYParityMissing
 }
 
 // MarshalJSON marshals as JSON with a hash.
@@ -294,9 +294,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 			return errors.New("missing required field 'input' in transaction")
 		}
 		itx.Data = *dec.Input
-		if dec.V == nil {
-			return errors.New("missing required field 'v' in transaction")
-		}
 		if dec.AccessList != nil {
 			itx.AccessList = *dec.AccessList
 		}
@@ -361,9 +358,6 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 			return errors.New("missing required field 'input' in transaction")
 		}
 		itx.Data = *dec.Input
-		if dec.V == nil {
-			return errors.New("missing required field 'v' in transaction")
-		}
 		if dec.AccessList != nil {
 			itx.AccessList = *dec.AccessList
 		}

core/types/transaction_test.go

@@ -451,3 +451,97 @@ func TestTransactionSizes(t *testing.T) {
 		}
 	}
 }
+
+func TestYParityJSONUnmarshalling(t *testing.T) {
+	baseJson := map[string]interface{}{
+		// type is filled in by the test
+		"chainId":              "0x7",
+		"nonce":                "0x0",
+		"to":                   "0x1b442286e32ddcaa6e2570ce9ed85f4b4fc87425",
+		"gas":                  "0x124f8",
+		"gasPrice":             "0x693d4ca8",
+		"maxPriorityFeePerGas": "0x3b9aca00",
+		"maxFeePerGas":         "0x6fc23ac00",
+		"maxFeePerBlobGas":     "0x3b9aca00",
+		"value":                "0x0",
+		"input":                "0x",
+		"accessList":           []interface{}{},
+		"blobVersionedHashes": []string{
+			"0x010657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c444014",
+		},
+
+		// v and yParity are filled in by the test
+		"r": "0x2a922afc784d07e98012da29f2f37cae1f73eda78aa8805d3df6ee5dbb41ec1",
+		"s": "0x4f1f75ae6bcdf4970b4f305da1a15d8c5ddb21f555444beab77c9af2baab14",
+	}
+
+	tests := []struct {
+		name    string
+		v       string
+		yParity string
+		wantErr error
+	}{
+		// Valid v and yParity
+		{"valid v and yParity, 0x0", "0x0", "0x0", nil},
+		{"valid v and yParity, 0x1", "0x1", "0x1", nil},
+
+		// Valid v, missing yParity
+		{"valid v, missing yParity, 0x0", "0x0", "", nil},
+		{"valid v, missing yParity, 0x1", "0x1", "", nil},
+
+		// Valid yParity, missing v
+		{"valid yParity, missing v, 0x0", "", "0x0", nil},
+		{"valid yParity, missing v, 0x1", "", "0x1", nil},
+
+		// Invalid yParity
+		{"invalid yParity, 0x2", "", "0x2", errInvalidYParity},
+
+		// Conflicting v and yParity
+		{"conflicting v and yParity", "0x1", "0x0", errVYParityMismatch},
+
+		// Missing v and yParity
+		{"missing v and yParity", "", "", errVYParityMissing},
+	}
+
+	// Run for all types that accept yParity
+	t.Parallel()
+	for _, txType := range []uint64{
+		AccessListTxType,
+		DynamicFeeTxType,
+		BlobTxType,
+	} {
+		txType := txType
+		for _, test := range tests {
+			test := test
+			t.Run(fmt.Sprintf("txType=%d: %s", txType, test.name), func(t *testing.T) {
+				// Copy the base json
+				testJson := make(map[string]interface{})
+				for k, v := range baseJson {
+					testJson[k] = v
+				}
+
+				// Set v, yParity and type
+				if test.v != "" {
+					testJson["v"] = test.v
+				}
+				if test.yParity != "" {
+					testJson["yParity"] = test.yParity
+				}
+				testJson["type"] = fmt.Sprintf("0x%x", txType)
+
+				// Marshal the JSON
+				jsonBytes, err := json.Marshal(testJson)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				// Unmarshal the tx
+				var tx Transaction
+				err = tx.UnmarshalJSON(jsonBytes)
+				if err != test.wantErr {
+					t.Fatalf("wrong error: got %v, want %v", err, test.wantErr)
+				}
+			})
+		}
+	}
+}

eth/api_backend.go

@@ -249,7 +249,7 @@ func (b *EthAPIBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int {
 	return nil
 }
 
-func (b *EthAPIBackend) GetEVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockCtx *vm.BlockContext) (*vm.EVM, func() error) {
+func (b *EthAPIBackend) GetEVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockCtx *vm.BlockContext) *vm.EVM {
 	if vmConfig == nil {
 		vmConfig = b.eth.blockchain.GetVMConfig()
 	}
@@ -260,7 +260,7 @@ func (b *EthAPIBackend) GetEVM(ctx context.Context, msg *core.Message, state *st
 	} else {
 		context = core.NewEVMBlockContext(header, b.eth.BlockChain(), nil)
 	}
-	return vm.NewEVM(context, txContext, state, b.eth.blockchain.Config(), *vmConfig), state.Error
+	return vm.NewEVM(context, txContext, state, b.eth.blockchain.Config(), *vmConfig)
 }
 
 func (b *EthAPIBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {

eth/backend.go

@@ -108,7 +108,7 @@ type Ethereum struct {
 func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 	// Ensure configuration values are compatible and sane
 	if config.SyncMode == downloader.LightSync {
-		return nil, errors.New("can't run eth.Ethereum in light sync mode, use les.LightEthereum")
+		return nil, errors.New("can't run eth.Ethereum in light sync mode, light mode has been deprecated")
 	}
 	if !config.SyncMode.IsValid() {
 		return nil, fmt.Errorf("invalid sync mode %d", config.SyncMode)

eth/catalyst/simulated_beacon.go

@@ -82,10 +82,6 @@ type SimulatedBeacon struct {
 }
 
 func NewSimulatedBeacon(period uint64, eth *eth.Ethereum) (*SimulatedBeacon, error) {
-	chainConfig := eth.APIBackend.ChainConfig()
-	if !chainConfig.IsDevMode {
-		return nil, errors.New("incompatible pre-existing chain configuration")
-	}
 	block := eth.BlockChain().CurrentBlock()
 	current := engine.ForkchoiceStateV1{
 		HeadBlockHash:      block.Hash(),

eth/catalyst/simulated_beacon_test.go

@@ -85,7 +85,7 @@ func TestSimulatedBeaconSendWithdrawals(t *testing.T) {
 
 	// short period (1 second) for testing purposes
 	var gasLimit uint64 = 10_000_000
-	genesis := core.DeveloperGenesisBlock(gasLimit, testAddr)
+	genesis := core.DeveloperGenesisBlock(gasLimit, &testAddr)
 	node, ethService, mock := startSimulatedBeaconEthService(t, genesis)
 	_ = mock
 	defer node.Close()

eth/ethconfig/config.go

@@ -46,16 +46,6 @@ var FullNodeGPO = gasprice.Config{
 	IgnorePrice:      gasprice.DefaultIgnorePrice,
 }
 
-// LightClientGPO contains default gasprice oracle settings for light client.
-var LightClientGPO = gasprice.Config{
-	Blocks:           2,
-	Percentile:       60,
-	MaxHeaderHistory: 300,
-	MaxBlockHistory:  5,
-	MaxPrice:         gasprice.DefaultMaxPrice,
-	IgnorePrice:      gasprice.DefaultIgnorePrice,
-}
-
 // Defaults contains default settings for use on the Ethereum main net.
 var Defaults = Config{
 	SyncMode:           downloader.SnapSync,

eth/filters/filter.go

@@ -114,7 +114,7 @@ func (f *Filter) Logs(ctx context.Context) ([]*types.Log, error) {
 
 	// special case for pending logs
 	if beginPending && !endPending {
-		return nil, errors.New("invalid block range")
+		return nil, errInvalidBlockRange
 	}
 
 	// Short-cut if all we care about is pending logs

eth/filters/filter_test.go

@@ -353,7 +353,7 @@ func TestFilters(t *testing.T) {
 		},
 		{
 			f:   sys.NewRangeFilter(int64(rpc.PendingBlockNumber), int64(rpc.LatestBlockNumber), nil, nil),
-			err: "invalid block range",
+			err: errInvalidBlockRange.Error(),
 		},
 	} {
 		logs, err := tc.f.Logs(context.Background())

ethdb/pebble/pebble.go

@@ -609,9 +609,12 @@ func (b *batch) Replay(w ethdb.KeyValueWriter) error {
 
 // pebbleIterator is a wrapper of underlying iterator in storage engine.
 // The purpose of this structure is to implement the missing APIs.
+//
+// The pebble iterator is not thread-safe.
 type pebbleIterator struct {
-	iter  *pebble.Iterator
+	iter     *pebble.Iterator
-	moved bool
+	moved    bool
+	released bool
 }
 
 // NewIterator creates a binary-alphabetical iterator over a subset
@@ -623,7 +626,7 @@ func (d *Database) NewIterator(prefix []byte, start []byte) ethdb.Iterator {
 		UpperBound: upperBound(prefix),
 	})
 	iter.First()
-	return &pebbleIterator{iter: iter, moved: true}
+	return &pebbleIterator{iter: iter, moved: true, released: false}
 }
 
 // Next moves the iterator to the next key/value pair. It returns whether the
@@ -658,4 +661,9 @@ func (iter *pebbleIterator) Value() []byte {
 
 // Release releases associated resources. Release should always succeed and can
 // be called multiple times without causing error.
-func (iter *pebbleIterator) Release() { iter.iter.Close() }
+func (iter *pebbleIterator) Release() {
+	if !iter.released {
+		iter.iter.Close()
+		iter.released = true
+	}
+}

ethstats/ethstats.go

@@ -38,7 +38,6 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	ethproto "github.com/ethereum/go-ethereum/eth/protocols/eth"
 	"github.com/ethereum/go-ethereum/event"
-	"github.com/ethereum/go-ethereum/les"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/miner"
 	"github.com/ethereum/go-ethereum/node"
@@ -486,7 +485,7 @@ func (s *Service) login(conn *connWrapper) error {
 	if info := infos.Protocols["eth"]; info != nil {
 		network = fmt.Sprintf("%d", info.(*ethproto.NodeInfo).Network)
 	} else {
-		network = fmt.Sprintf("%d", infos.Protocols["les"].(*les.NodeInfo).Network)
+		return errors.New("no eth protocol available")
 	}
 	auth := &authMsg{
 		ID: s.node,

go.sum

@@ -93,6 +93,7 @@ github.com/aws/aws-sdk-go-v2/service/sts v1.23.2/go.mod h1:Eows6e1uQEsc4ZaHANmsP
 github.com/aws/smithy-go v1.15.0 h1:PS/durmlzvAFpQHDs4wi4sNNP9ExsqZh6IlfdHXgKK8=
 github.com/aws/smithy-go v1.15.0/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA=
 github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g=
+github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
@@ -145,6 +146,8 @@ github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3Ee
 github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
 github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/crate-crypto/go-ipa v0.0.0-20230914135612-d1b03fcb8e58 h1:PwUlswsGOrLB677lW4XrlWLeszY3BaDGbvZ6dYk28tQ=
+github.com/crate-crypto/go-ipa v0.0.0-20230914135612-d1b03fcb8e58/go.mod h1:J+gsi6D4peY0kyhaklyXFRVHOQWI2I5uU0c2+/90HYc=
 github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ=
 github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs=
 github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA=
@@ -203,6 +206,8 @@ github.com/garslo/gogen v0.0.0-20170306192744-1d203ffc1f61/go.mod h1:Q0X6pkwTILD
 github.com/gavv/httpexpect v2.0.0+incompatible/go.mod h1:x+9tiU1YnrOvnB725RkpoLv1M62hOWzwo5OXotisrKc=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
+github.com/gballet/go-verkle v0.1.1-0.20231004173727-0a4e93ed640b h1:LHeiiSTL2FEGCP1ov6FqkikiViqygeVo1ZwJ1x3nYSE=
+github.com/gballet/go-verkle v0.1.1-0.20231004173727-0a4e93ed640b/go.mod h1:7JamHhSTnnHDhcI3G8r4sWaD9XlleriqVlC3FeAQJKM=
 github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE=
 github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc=
 github.com/getkin/kin-openapi v0.53.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
@@ -617,6 +622,8 @@ go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/automaxprocs v1.5.2 h1:2LxUOGiR3O6tw8ui5sZa2LAaHnsviZdVOUZw4fvbnME=
 go.uber.org/automaxprocs v1.5.2/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=
 go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk=
@@ -837,6 +844,7 @@ golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgw
 golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
@@ -975,6 +983,7 @@ gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

internal/ethapi/api.go

@@ -1083,7 +1083,7 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S
 	if blockOverrides != nil {
 		blockOverrides.Apply(&blockCtx)
 	}
-	evm, vmError := b.GetEVM(ctx, msg, state, header, &vm.Config{NoBaseFee: true}, &blockCtx)
+	evm := b.GetEVM(ctx, msg, state, header, &vm.Config{NoBaseFee: true}, &blockCtx)
 
 	// Wait for the context to be done and cancel the evm. Even if the
 	// EVM has finished, cancelling may be done (repeatedly)
@@ -1095,7 +1095,7 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S
 	// Execute the message.
 	gp := new(core.GasPool).AddGas(math.MaxUint64)
 	result, err := core.ApplyMessage(evm, msg, gp)
-	if err := vmError(); err != nil {
+	if err := state.Error(); err != nil {
 		return nil, err
 	}
 
@@ -1640,7 +1640,7 @@ func AccessList(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrH
 		// Apply the transaction with the access list tracer
 		tracer := logger.NewAccessListTracer(accessList, args.from(), to, precompiles)
 		config := vm.Config{Tracer: tracer, NoBaseFee: true}
-		vmenv, _ := b.GetEVM(ctx, msg, statedb, header, &config, nil)
+		vmenv := b.GetEVM(ctx, msg, statedb, header, &config, nil)
 		res, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.GasLimit))
 		if err != nil {
 			return nil, 0, nil, fmt.Errorf("failed to apply transaction: %v err: %v", args.toTransaction().Hash(), err)

internal/ethapi/api_test.go

@@ -536,8 +536,7 @@ func (b testBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int {
 	}
 	return big.NewInt(1)
 }
-func (b testBackend) GetEVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockContext *vm.BlockContext) (*vm.EVM, func() error) {
+func (b testBackend) GetEVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockContext *vm.BlockContext) *vm.EVM {
-	vmError := func() error { return nil }
 	if vmConfig == nil {
 		vmConfig = b.chain.GetVMConfig()
 	}
@@ -546,7 +545,7 @@ func (b testBackend) GetEVM(ctx context.Context, msg *core.Message, state *state
 	if blockContext != nil {
 		context = *blockContext
 	}
-	return vm.NewEVM(context, txContext, state, b.chain.Config(), *vmConfig), vmError
+	return vm.NewEVM(context, txContext, state, b.chain.Config(), *vmConfig)
 }
 func (b testBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
 	panic("implement me")

internal/ethapi/backend.go

@@ -68,7 +68,7 @@ type Backend interface {
 	PendingBlockAndReceipts() (*types.Block, types.Receipts)
 	GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error)
 	GetTd(ctx context.Context, hash common.Hash) *big.Int
-	GetEVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockCtx *vm.BlockContext) (*vm.EVM, func() error)
+	GetEVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockCtx *vm.BlockContext) *vm.EVM
 	SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription
 	SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription
 	SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription

internal/ethapi/transaction_args_test.go

@@ -305,8 +305,8 @@ func (b *backendMock) GetLogs(ctx context.Context, blockHash common.Hash, number
 	return nil, nil
 }
 func (b *backendMock) GetTd(ctx context.Context, hash common.Hash) *big.Int { return nil }
-func (b *backendMock) GetEVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockCtx *vm.BlockContext) (*vm.EVM, func() error) {
+func (b *backendMock) GetEVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockCtx *vm.BlockContext) *vm.EVM {
-	return nil, nil
+	return nil
 }
 func (b *backendMock) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription { return nil }
 func (b *backendMock) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription {

les/api.go

@@ -1,349 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-	vfs "github.com/ethereum/go-ethereum/les/vflux/server"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-)
-
-var errUnknownBenchmarkType = errors.New("unknown benchmark type")
-
-// LightServerAPI provides an API to access the LES light server.
-type LightServerAPI struct {
-	server                               *LesServer
-	defaultPosFactors, defaultNegFactors vfs.PriceFactors
-}
-
-// NewLightServerAPI creates a new LES light server API.
-func NewLightServerAPI(server *LesServer) *LightServerAPI {
-	return &LightServerAPI{
-		server:            server,
-		defaultPosFactors: defaultPosFactors,
-		defaultNegFactors: defaultNegFactors,
-	}
-}
-
-// parseNode parses either an enode address a raw hex node id
-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 {
-		return enode.ID{}, err
-	}
-}
-
-// ServerInfo returns global server parameters
-func (api *LightServerAPI) ServerInfo() map[string]interface{} {
-	res := make(map[string]interface{})
-	res["minimumCapacity"] = api.server.minCapacity
-	res["maximumCapacity"] = api.server.maxCapacity
-	_, 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)
-		}
-	}
-
-	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)
-		} else {
-			api.server.clientPool.BalanceOperation(id, "", func(balance vfs.AtomicBalanceOperator) {
-				res[id] = api.clientInfo(nil, balance)
-			})
-		}
-	}
-	return res
-}
-
-// PriorityClientInfo returns information about clients with a positive balance
-// in the given ID range (stop excluded). If stop is null then the iterator stops
-// only at the end of the ID space. MaxCount limits the number of results returned.
-// If maxCount limit is applied but there are more potential results then the ID
-// of the next potential result is included in the map with an empty structure
-// assigned to it.
-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)
-		} else {
-			api.server.clientPool.BalanceOperation(id, "", func(balance vfs.AtomicBalanceOperator) {
-				res[id] = api.clientInfo(nil, balance)
-			})
-		}
-	}
-	return res
-}
-
-// clientInfo creates a client info data structure
-func (api *LightServerAPI) clientInfo(peer *clientPeer, balance vfs.ReadOnlyBalance) map[string]interface{} {
-	info := make(map[string]interface{})
-	pb, nb := balance.GetBalance()
-	info["isConnected"] = peer != nil
-	info["pricing/balance"] = pb
-	info["priority"] = pb != 0
-	//		cb := api.server.clientPool.ndb.getCurrencyBalance(id)
-	//		info["pricing/currency"] = cb.amount
-	if peer != nil {
-		info["connectionTime"] = float64(mclock.Now()-peer.connectedAt) / float64(time.Second)
-		info["capacity"] = peer.getCapacity()
-		info["pricing/negBalance"] = nb
-	}
-	return info
-}
-
-// setParams either sets the given parameters for a single connected client (if specified)
-// 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)
-		}
-		setFactor := func(v *float64) {
-			if val, ok := value.(float64); ok && val >= 0 {
-				*v = val / float64(time.Second)
-				updateFactors = true
-			} else {
-				err = errValue()
-			}
-		}
-
-		switch {
-		case name == "pricing/timeFactor":
-			setFactor(&posFactors.TimeFactor)
-		case name == "pricing/capacityFactor":
-			setFactor(&posFactors.CapacityFactor)
-		case name == "pricing/requestCostFactor":
-			setFactor(&posFactors.RequestFactor)
-		case name == "pricing/negative/timeFactor":
-			setFactor(&negFactors.TimeFactor)
-		case name == "pricing/negative/capacityFactor":
-			setFactor(&negFactors.CapacityFactor)
-		case name == "pricing/negative/requestCostFactor":
-			setFactor(&negFactors.RequestFactor)
-		case !defParams && name == "capacity":
-			if capacity, ok := value.(float64); ok && uint64(capacity) >= api.server.minCapacity {
-				_, err = api.server.clientPool.SetCapacity(client.Node(), uint64(capacity), 0, false)
-				// time factor recalculation is performed automatically by the balance tracker
-			} else {
-				err = errValue()
-			}
-		default:
-			if defParams {
-				err = fmt.Errorf("invalid default parameter '%s'", name)
-			} else {
-				err = fmt.Errorf("invalid client parameter '%s'", name)
-			}
-		}
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// SetClientParams sets client parameters for all clients listed in the ids list
-// 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
-			}
-		} else {
-			err = fmt.Errorf("client %064x is not connected", id)
-		}
-	}
-	return err
-}
-
-// SetDefaultParams sets the default parameters applicable to clients connected in the future
-func (api *LightServerAPI) SetDefaultParams(params map[string]interface{}) error {
-	update, err := api.setParams(params, nil, &api.defaultPosFactors, &api.defaultNegFactors)
-	if update {
-		api.server.clientPool.SetDefaultFactors(api.defaultPosFactors, api.defaultNegFactors)
-	}
-	return err
-}
-
-// SetConnectedBias set the connection bias, which is applied to already connected clients
-// So that already connected client won't be kicked out very soon and we can ensure all
-// connected clients can have enough time to request or sync some data.
-// When the input parameter `bias` < 0 (illegal), return error.
-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
-}
-
-// AddBalance adds the given amount to the balance of a client if possible and returns
-// 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
-}
-
-// Benchmark runs a request performance benchmark with a given set of measurement setups
-// in multiple passes specified by passCount. The measurement time for each setup in each
-// pass is specified in milliseconds by length.
-//
-// Note: measurement time is adjusted for each pass depending on the previous ones.
-// 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{
-					amount:  getInt("amount", 1),
-					skip:    getInt("skip", 1),
-					byHash:  getBool("byHash", false),
-					reverse: getBool("reverse", false),
-				}
-			case "body":
-				benchmarks[i] = &benchmarkBodiesOrReceipts{receipts: false}
-			case "receipts":
-				benchmarks[i] = &benchmarkBodiesOrReceipts{receipts: true}
-			case "proof":
-				benchmarks[i] = &benchmarkProofsOrCode{code: false}
-			case "code":
-				benchmarks[i] = &benchmarkProofsOrCode{code: true}
-			case "cht":
-				benchmarks[i] = &benchmarkHelperTrie{
-					bloom:    false,
-					reqCount: getInt("amount", 1),
-				}
-			case "bloom":
-				benchmarks[i] = &benchmarkHelperTrie{
-					bloom:    true,
-					reqCount: getInt("amount", 1),
-				}
-			case "txSend":
-				benchmarks[i] = &benchmarkTxSend{}
-			case "txStatus":
-				benchmarks[i] = &benchmarkTxStatus{}
-			default:
-				return nil, errUnknownBenchmarkType
-			}
-		} else {
-			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 {
-			res["totalCount"] = r.totalCount
-			res["avgTime"] = r.avgTime
-			res["maxInSize"] = r.maxInSize
-			res["maxOutSize"] = r.maxOutSize
-		} else {
-			res["error"] = r.err.Error()
-		}
-		result[i] = res
-	}
-	return result, nil
-}
-
-// DebugAPI provides an API to debug LES light server functionality.
-type DebugAPI struct {
-	server *LesServer
-}
-
-// NewDebugAPI creates a new LES light server debug API.
-func NewDebugAPI(server *LesServer) *DebugAPI {
-	return &DebugAPI{
-		server: server,
-	}
-}
-
-// FreezeClient forces a temporary client freeze which normally happens when the server is overloaded
-func (api *DebugAPI) FreezeClient(node string) error {
-	var (
-		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
-	} else {
-		return fmt.Errorf("client %064x is not connected", id[:])
-	}
-}

les/api_backend.go

@@ -1,337 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"context"
-	"errors"
-	"math/big"
-	"time"
-
-	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/consensus"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/bloombits"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/state"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/eth/gasprice"
-	"github.com/ethereum/go-ethereum/eth/tracers"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/event"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/rpc"
-)
-
-type LesApiBackend struct {
-	extRPCEnabled       bool
-	allowUnprotectedTxs bool
-	eth                 *LightEthereum
-	gpo                 *gasprice.Oracle
-}
-
-func (b *LesApiBackend) ChainConfig() *params.ChainConfig {
-	return b.eth.chainConfig
-}
-
-func (b *LesApiBackend) CurrentBlock() *types.Header {
-	return b.eth.BlockChain().CurrentHeader()
-}
-
-func (b *LesApiBackend) SetHead(number uint64) {
-	b.eth.blockchain.SetHead(number)
-}
-
-func (b *LesApiBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
-	// Return the latest current as the pending one since there
-	// is no pending notion in the light client. TODO(rjl493456442)
-	// unify the behavior of `HeaderByNumber` and `PendingBlockAndReceipts`.
-	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))
-}
-
-func (b *LesApiBackend) HeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Header, error) {
-	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")
-}
-
-func (b *LesApiBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
-	return b.eth.blockchain.GetHeaderByHash(hash), nil
-}
-
-func (b *LesApiBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
-	header, err := b.HeaderByNumber(ctx, number)
-	if header == nil || err != nil {
-		return nil, err
-	}
-	return b.BlockByHash(ctx, header.Hash())
-}
-
-func (b *LesApiBackend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
-	return b.eth.blockchain.GetBlockByHash(ctx, hash)
-}
-
-func (b *LesApiBackend) BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Block, error) {
-	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")
-}
-
-func (b *LesApiBackend) GetBody(ctx context.Context, hash common.Hash, number rpc.BlockNumber) (*types.Body, error) {
-	return light.GetBody(ctx, b.eth.odr, hash, uint64(number))
-}
-
-func (b *LesApiBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) {
-	return nil, nil
-}
-
-func (b *LesApiBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
-	header, err := b.HeaderByNumber(ctx, number)
-	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
-}
-
-func (b *LesApiBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) {
-	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")
-}
-
-func (b *LesApiBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
-	if number := rawdb.ReadHeaderNumber(b.eth.chainDb, hash); number != nil {
-		return light.GetBlockReceipts(ctx, b.eth.odr, hash, *number)
-	}
-	return nil, nil
-}
-
-func (b *LesApiBackend) GetLogs(ctx context.Context, hash common.Hash, number uint64) ([][]*types.Log, error) {
-	return light.GetBlockLogs(ctx, b.eth.odr, hash, number)
-}
-
-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
-}
-
-func (b *LesApiBackend) GetEVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockCtx *vm.BlockContext) (*vm.EVM, func() error) {
-	if vmConfig == nil {
-		vmConfig = new(vm.Config)
-	}
-	txContext := core.NewEVMTxContext(msg)
-	context := core.NewEVMBlockContext(header, b.eth.blockchain, nil)
-	if blockCtx != 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 {
-	return b.eth.txPool.Add(ctx, signedTx)
-}
-
-func (b *LesApiBackend) RemoveTx(txHash common.Hash) {
-	b.eth.txPool.RemoveTx(txHash)
-}
-
-func (b *LesApiBackend) GetPoolTransactions() (types.Transactions, error) {
-	return b.eth.txPool.GetTransactions()
-}
-
-func (b *LesApiBackend) GetPoolTransaction(txHash common.Hash) *types.Transaction {
-	return b.eth.txPool.GetTransaction(txHash)
-}
-
-func (b *LesApiBackend) GetTransaction(ctx context.Context, txHash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, error) {
-	return light.GetTransaction(ctx, b.eth.odr, txHash)
-}
-
-func (b *LesApiBackend) GetPoolNonce(ctx context.Context, addr common.Address) (uint64, error) {
-	return b.eth.txPool.GetNonce(ctx, addr)
-}
-
-func (b *LesApiBackend) Stats() (pending int, queued int) {
-	return b.eth.txPool.Stats(), 0
-}
-
-func (b *LesApiBackend) TxPoolContent() (map[common.Address][]*types.Transaction, map[common.Address][]*types.Transaction) {
-	return b.eth.txPool.Content()
-}
-
-func (b *LesApiBackend) TxPoolContentFrom(addr common.Address) ([]*types.Transaction, []*types.Transaction) {
-	return b.eth.txPool.ContentFrom(addr)
-}
-
-func (b *LesApiBackend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
-	return b.eth.txPool.SubscribeNewTxsEvent(ch)
-}
-
-func (b *LesApiBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
-	return b.eth.blockchain.SubscribeChainEvent(ch)
-}
-
-func (b *LesApiBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription {
-	return b.eth.blockchain.SubscribeChainHeadEvent(ch)
-}
-
-func (b *LesApiBackend) SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription {
-	return b.eth.blockchain.SubscribeChainSideEvent(ch)
-}
-
-func (b *LesApiBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
-	return b.eth.blockchain.SubscribeLogsEvent(ch)
-}
-
-func (b *LesApiBackend) SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription {
-	return event.NewSubscription(func(quit <-chan struct{}) error {
-		<-quit
-		return nil
-	})
-}
-
-func (b *LesApiBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
-	return b.eth.blockchain.SubscribeRemovedLogsEvent(ch)
-}
-
-func (b *LesApiBackend) SyncProgress() ethereum.SyncProgress {
-	return ethereum.SyncProgress{}
-}
-
-func (b *LesApiBackend) ProtocolVersion() int {
-	return b.eth.LesVersion() + 10000
-}
-
-func (b *LesApiBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
-	return b.gpo.SuggestTipCap(ctx)
-}
-
-func (b *LesApiBackend) FeeHistory(ctx context.Context, blockCount uint64, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (firstBlock *big.Int, reward [][]*big.Int, baseFee []*big.Int, gasUsedRatio []float64, err error) {
-	return b.gpo.FeeHistory(ctx, blockCount, lastBlock, rewardPercentiles)
-}
-
-func (b *LesApiBackend) ChainDb() ethdb.Database {
-	return b.eth.chainDb
-}
-
-func (b *LesApiBackend) AccountManager() *accounts.Manager {
-	return b.eth.accountManager
-}
-
-func (b *LesApiBackend) ExtRPCEnabled() bool {
-	return b.extRPCEnabled
-}
-
-func (b *LesApiBackend) UnprotectedAllowed() bool {
-	return b.allowUnprotectedTxs
-}
-
-func (b *LesApiBackend) RPCGasCap() uint64 {
-	return b.eth.config.RPCGasCap
-}
-
-func (b *LesApiBackend) RPCEVMTimeout() time.Duration {
-	return b.eth.config.RPCEVMTimeout
-}
-
-func (b *LesApiBackend) RPCTxFeeCap() float64 {
-	return b.eth.config.RPCTxFeeCap
-}
-
-func (b *LesApiBackend) BloomStatus() (uint64, uint64) {
-	if b.eth.bloomIndexer == nil {
-		return 0, 0
-	}
-	sections, _, _ := b.eth.bloomIndexer.Sections()
-	return params.BloomBitsBlocksClient, sections
-}
-
-func (b *LesApiBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession) {
-	for i := 0; i < bloomFilterThreads; i++ {
-		go session.Multiplex(bloomRetrievalBatch, bloomRetrievalWait, b.eth.bloomRequests)
-	}
-}
-
-func (b *LesApiBackend) Engine() consensus.Engine {
-	return b.eth.engine
-}
-
-func (b *LesApiBackend) CurrentHeader() *types.Header {
-	return b.eth.blockchain.CurrentHeader()
-}
-
-func (b *LesApiBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, tracers.StateReleaseFunc, error) {
-	return b.eth.stateAtBlock(ctx, block, reexec)
-}
-
-func (b *LesApiBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) {
-	return b.eth.stateAtTransaction(ctx, block, txIndex, reexec)
-}

les/api_test.go

@@ -1,512 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"context"
-	crand "crypto/rand"
-	"errors"
-	"flag"
-	"math/rand"
-	"os"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/eth"
-	"github.com/ethereum/go-ethereum/eth/downloader"
-	"github.com/ethereum/go-ethereum/eth/ethconfig"
-	"github.com/ethereum/go-ethereum/les/flowcontrol"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/node"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/p2p/simulations"
-	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
-	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/mattn/go-colorable"
-)
-
-// Additional command line flags for the test binary.
-var (
-	loglevel   = flag.Int("loglevel", 0, "verbosity of logs")
-	simAdapter = flag.String("adapter", "exec", "type of simulation: sim|socket|exec|docker")
-)
-
-func TestMain(m *testing.M) {
-	flag.Parse()
-	log.PrintOrigins(true)
-	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*loglevel), log.StreamHandler(colorable.NewColorableStderr(), log.TerminalFormat(true))))
-	// register the Delivery service which will run as a devp2p
-	// protocol when using the exec adapter
-	adapters.RegisterLifecycles(services)
-	os.Exit(m.Run())
-}
-
-// This test is not meant to be a part of the automatic testing process because it
-// runs for a long time and also requires a large database in order to do a meaningful
-// request performance test. When testServerDataDir is empty, the test is skipped.
-
-const (
-	testServerDataDir  = "" // should always be empty on the master branch
-	testServerCapacity = 200
-	testMaxClients     = 10
-	testTolerance      = 0.1
-	minRelCap          = 0.2
-)
-
-func TestCapacityAPI3(t *testing.T) {
-	testCapacityAPI(t, 3)
-}
-
-func TestCapacityAPI6(t *testing.T) {
-	testCapacityAPI(t, 6)
-}
-
-func TestCapacityAPI10(t *testing.T) {
-	testCapacityAPI(t, 10)
-}
-
-// testCapacityAPI runs an end-to-end simulation test connecting one server with
-// a given number of clients. It sets different priority capacities to all clients
-// except a randomly selected one which runs in free client mode. All clients send
-// similar requests at the maximum allowed rate and the test verifies whether the
-// ratio of processed requests is close enough to the ratio of assigned capacities.
-// Running multiple rounds with different settings ensures that changing capacity
-// while connected and going back and forth between free and priority mode with
-// the supplied API calls is also thoroughly tested.
-func testCapacityAPI(t *testing.T, clientCount int) {
-	// Skip test if no data dir specified
-	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))
-		}
-		server := servers[0]
-
-		serverRpcClient, err := server.Client()
-		if err != nil {
-			t.Fatalf("Failed to obtain rpc client: %v", err)
-		}
-		headNum, headHash := getHead(ctx, t, serverRpcClient)
-		minCap, totalCap := getCapacityInfo(ctx, t, serverRpcClient)
-		testCap := totalCap * 3 / 4
-		t.Logf("Server testCap: %d  minCap: %d  head number: %d  head hash: %064x\n", testCap, minCap, headNum, headHash)
-		reqMinCap := uint64(float64(testCap) * minRelCap / (minRelCap + float64(len(clients)-1)))
-		if minCap > reqMinCap {
-			t.Fatalf("Minimum client capacity (%d) bigger than required minimum for this test (%d)", minCap, reqMinCap)
-		}
-		freeIdx := rand.Intn(len(clients))
-
-		clientRpcClients := make([]*rpc.Client, len(clients))
-		for i, client := range clients {
-			var err error
-			clientRpcClients[i], err = client.Client()
-			if err != nil {
-				t.Fatalf("Failed to obtain rpc client: %v", err)
-			}
-			t.Log("connecting client", i)
-			if i != freeIdx {
-				setCapacity(ctx, t, serverRpcClient, client.ID(), testCap/uint64(len(clients)))
-			}
-			net.Connect(client.ID(), server.ID())
-
-			for {
-				select {
-				case <-ctx.Done():
-					t.Fatalf("Timeout")
-				default:
-				}
-				num, hash := getHead(ctx, t, clientRpcClients[i])
-				if num == headNum && hash == headHash {
-					t.Log("client", i, "synced")
-					break
-				}
-				time.Sleep(time.Millisecond * 200)
-			}
-		}
-
-		var wg sync.WaitGroup
-		stop := make(chan struct{})
-
-		reqCount := make([]atomic.Uint64, len(clientRpcClients))
-
-		// Send light request like crazy.
-		for i, c := range clientRpcClients {
-			wg.Add(1)
-			i, c := i, c
-			go func() {
-				defer wg.Done()
-
-				queue := make(chan struct{}, 100)
-				reqCount[i].Store(0)
-				for {
-					select {
-					case queue <- struct{}{}:
-						select {
-						case <-stop:
-							return
-						case <-ctx.Done():
-							return
-						default:
-							wg.Add(1)
-							go func() {
-								ok := testRequest(ctx, t, c)
-								wg.Done()
-								<-queue
-								if ok {
-									if reqCount[i].Add(1)%10000 == 0 {
-										freezeClient(ctx, t, serverRpcClient, clients[i].ID())
-									}
-								}
-							}()
-						}
-					case <-stop:
-						return
-					case <-ctx.Done():
-						return
-					}
-				}
-			}()
-		}
-
-		processedSince := func(start []uint64) []uint64 {
-			res := make([]uint64, len(reqCount))
-			for i := range reqCount {
-				res[i] = reqCount[i].Load()
-				if start != nil {
-					res[i] -= start[i]
-				}
-			}
-			return res
-		}
-
-		weights := make([]float64, len(clients))
-		for c := 0; c < 5; c++ {
-			setCapacity(ctx, t, serverRpcClient, clients[freeIdx].ID(), minCap)
-			freeIdx = rand.Intn(len(clients))
-			var sum float64
-			for i := range clients {
-				if i == freeIdx {
-					weights[i] = 0
-				} else {
-					weights[i] = rand.Float64()*(1-minRelCap) + minRelCap
-				}
-				sum += weights[i]
-			}
-			for i, client := range clients {
-				weights[i] *= float64(testCap-minCap-100) / sum
-				capacity := uint64(weights[i])
-				if i != freeIdx && capacity < getCapacity(ctx, t, serverRpcClient, client.ID()) {
-					setCapacity(ctx, t, serverRpcClient, client.ID(), capacity)
-				}
-			}
-			setCapacity(ctx, t, serverRpcClient, clients[freeIdx].ID(), 0)
-			for i, client := range clients {
-				capacity := uint64(weights[i])
-				if i != freeIdx && capacity > getCapacity(ctx, t, serverRpcClient, client.ID()) {
-					setCapacity(ctx, t, serverRpcClient, client.ID(), capacity)
-				}
-			}
-			weights[freeIdx] = float64(minCap)
-			for i := range clients {
-				weights[i] /= float64(testCap)
-			}
-
-			time.Sleep(flowcontrol.DecParamDelay)
-			t.Log("Starting measurement")
-			t.Logf("Relative weights:")
-			for i := range clients {
-				t.Logf("  %f", weights[i])
-			}
-			t.Log()
-			start := processedSince(nil)
-			for {
-				select {
-				case <-ctx.Done():
-					t.Fatalf("Timeout")
-				default:
-				}
-
-				_, totalCap = getCapacityInfo(ctx, t, serverRpcClient)
-				if totalCap < testCap {
-					t.Log("Total capacity underrun")
-					close(stop)
-					wg.Wait()
-					return false
-				}
-
-				processed := processedSince(start)
-				var avg uint64
-				t.Logf("Processed")
-				for i, p := range processed {
-					t.Logf(" %d", p)
-					processed[i] = uint64(float64(p) / weights[i])
-					avg += processed[i]
-				}
-				avg /= uint64(len(processed))
-
-				if avg >= 10000 {
-					var maxDev float64
-					for _, p := range processed {
-						dev := float64(int64(p-avg)) / float64(avg)
-						t.Logf(" %7.4f", dev)
-						if dev < 0 {
-							dev = -dev
-						}
-						if dev > maxDev {
-							maxDev = dev
-						}
-					}
-					t.Logf("  max deviation: %f  totalCap: %d\n", maxDev, totalCap)
-					if maxDev <= testTolerance {
-						t.Log("success")
-						break
-					}
-				} else {
-					t.Log()
-				}
-				time.Sleep(time.Millisecond * 200)
-			}
-		}
-
-		close(stop)
-		wg.Wait()
-
-		for i := range reqCount {
-			t.Log("client", i, "processed", reqCount[i].Load())
-		}
-		return true
-	}) {
-		t.Log("restarting test")
-	}
-}
-
-func getHead(ctx context.Context, t *testing.T, client *rpc.Client) (uint64, common.Hash) {
-	res := make(map[string]interface{})
-	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[:])
-	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
-}
-
-func freezeClient(ctx context.Context, t *testing.T, server *rpc.Client, clientID enode.ID) {
-	if err := server.CallContext(ctx, nil, "debug_freezeClient", clientID); err != nil {
-		t.Fatalf("Failed to freeze client: %v", err)
-	}
-}
-
-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)
-	}
-}
-
-func getCapacity(ctx context.Context, t *testing.T, server *rpc.Client, clientID enode.ID) uint64 {
-	var res map[enode.ID]map[string]interface{}
-	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)
-}
-
-func getCapacityInfo(ctx context.Context, t *testing.T, server *rpc.Client) (minCap, totalCap uint64) {
-	var res map[string]interface{}
-	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
-}
-
-var services = adapters.LifecycleConstructors{
-	"lesclient": newLesClientService,
-	"lesserver": newLesServerService,
-}
-
-func NewNetwork() (*simulations.Network, func(), error) {
-	adapter, adapterTeardown, err := NewAdapter(*simAdapter, services)
-	if err != nil {
-		return nil, adapterTeardown, err
-	}
-	defaultService := "streamer"
-	net := simulations.NewNetwork(adapter, &simulations.NetworkConfig{
-		ID:             "0",
-		DefaultService: defaultService,
-	})
-	teardown := func() {
-		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)
-		//	case "socket":
-		//		adapter = adapters.NewSocketAdapter(services)
-	case "exec":
-		baseDir, err0 := os.MkdirTemp("", "les-test")
-		if err0 != nil {
-			return nil, teardown, err0
-		}
-		teardown = func() { os.RemoveAll(baseDir) }
-		adapter = adapters.NewExecAdapter(baseDir)
-	/*case "docker":
-	adapter, err = adapters.NewDockerAdapter()
-	if err != nil {
-		return nil, teardown, err
-	}*/
-	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()
-
-	servers := make([]*simulations.Node, serverCount)
-	clients := make([]*simulations.Node, clientCount)
-
-	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
-	}
-
-	for _, client := range clients {
-		if err := net.Start(client.ID()); err != nil {
-			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)
-		}
-	}
-
-	return test(ctx, net, servers, clients)
-}
-
-func newLesClientService(ctx *adapters.ServiceContext, stack *node.Node) (node.Lifecycle, error) {
-	config := ethconfig.Defaults
-	config.SyncMode = downloader.LightSync
-	return New(stack, &config)
-}
-
-func newLesServerService(ctx *adapters.ServiceContext, stack *node.Node) (node.Lifecycle, error) {
-	config := ethconfig.Defaults
-	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

@@ -1,351 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	crand "crypto/rand"
-	"encoding/binary"
-	"errors"
-	"math/big"
-	"math/rand"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/les/flowcontrol"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-// requestBenchmark is an interface for different randomized request generators
-type requestBenchmark interface {
-	// init initializes the generator for generating the given number of randomized requests
-	init(h *serverHandler, count int) error
-	// request initiates sending a single request to the given peer
-	request(peer *serverPeer, index int) error
-}
-
-// benchmarkBlockHeaders implements requestBenchmark
-type benchmarkBlockHeaders struct {
-	amount, skip    int
-	reverse, byHash bool
-	offset, randMax int64
-	hashes          []common.Hash
-}
-
-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
-}
-
-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)
-}
-
-// benchmarkBodiesOrReceipts implements requestBenchmark
-type benchmarkBodiesOrReceipts struct {
-	receipts bool
-	hashes   []common.Hash
-}
-
-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
-}
-
-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]})
-}
-
-// benchmarkProofsOrCode implements requestBenchmark
-type benchmarkProofsOrCode struct {
-	code     bool
-	headHash common.Hash
-}
-
-func (b *benchmarkProofsOrCode) init(h *serverHandler, count int) error {
-	b.headHash = h.blockchain.CurrentHeader().Hash()
-	return nil
-}
-
-func (b *benchmarkProofsOrCode) request(peer *serverPeer, index int) error {
-	key := make([]byte, 32)
-	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}})
-}
-
-// benchmarkHelperTrie implements requestBenchmark
-type benchmarkHelperTrie struct {
-	bloom                 bool
-	reqCount              int
-	sectionCount, headNum uint64
-}
-
-func (b *benchmarkHelperTrie) init(h *serverHandler, count int) error {
-	if b.bloom {
-		b.sectionCount, b.headNum, _ = h.server.bloomTrieIndexer.Sections()
-	} else {
-		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
-}
-
-func (b *benchmarkHelperTrie) request(peer *serverPeer, index int) error {
-	reqs := make([]HelperTrieReq, b.reqCount)
-
-	if b.bloom {
-		bitIdx := uint16(rand.Intn(2048))
-		for i := range reqs {
-			key := make([]byte, 10)
-			binary.BigEndian.PutUint16(key[:2], bitIdx)
-			binary.BigEndian.PutUint64(key[2:], uint64(rand.Int63n(int64(b.sectionCount))))
-			reqs[i] = HelperTrieReq{Type: htBloomBits, TrieIdx: b.sectionCount - 1, Key: key}
-		}
-	} else {
-		for i := range reqs {
-			key := make([]byte, 8)
-			binary.BigEndian.PutUint64(key[:], uint64(rand.Int63n(int64(b.headNum))))
-			reqs[i] = HelperTrieReq{Type: htCanonical, TrieIdx: b.sectionCount - 1, Key: key, AuxReq: htAuxHeader}
-		}
-	}
-
-	return peer.requestHelperTrieProofs(0, reqs)
-}
-
-// benchmarkTxSend implements requestBenchmark
-type benchmarkTxSend struct {
-	txs types.Transactions
-}
-
-func (b *benchmarkTxSend) init(h *serverHandler, count int) error {
-	key, _ := crypto.GenerateKey()
-	addr := crypto.PubkeyToAddress(key.PublicKey)
-	signer := types.LatestSigner(h.server.chainConfig)
-	b.txs = make(types.Transactions, count)
-
-	for i := range b.txs {
-		data := make([]byte, txSizeCostLimit)
-		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
-}
-
-func (b *benchmarkTxSend) request(peer *serverPeer, index int) error {
-	enc, _ := rlp.EncodeToBytes(types.Transactions{b.txs[index]})
-	return peer.sendTxs(0, 1, enc)
-}
-
-// benchmarkTxStatus implements requestBenchmark
-type benchmarkTxStatus struct{}
-
-func (b *benchmarkTxStatus) init(h *serverHandler, count int) error {
-	return nil
-}
-
-func (b *benchmarkTxStatus) request(peer *serverPeer, index int) error {
-	var hash common.Hash
-	crand.Read(hash[:])
-	return peer.requestTxStatus(0, []common.Hash{hash})
-}
-
-// benchmarkSetup stores measurement data for a single benchmark type
-type benchmarkSetup struct {
-	req                   requestBenchmark
-	totalCount            int
-	totalTime, avgTime    time.Duration
-	maxInSize, maxOutSize uint32
-	err                   error
-}
-
-// runBenchmark runs a benchmark cycle for all benchmark types in the specified
-// number of passes
-func (h *serverHandler) runBenchmark(benchmarks []requestBenchmark, passCount int, targetTime time.Duration) []*benchmarkSetup {
-	setup := make([]*benchmarkSetup, len(benchmarks))
-	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))
-			next := todo[index]
-			todo[index] = todo[len(todo)-1]
-			todo = todo[:len(todo)-1]
-
-			if next.err == nil {
-				// calculate request count
-				count := 50
-				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
-				}
-			}
-		}
-	}
-	log.Info("Benchmark completed")
-
-	for _, s := range setup {
-		if s.err == nil {
-			s.avgTime = s.totalTime / time.Duration(s.totalCount)
-		}
-	}
-	return setup
-}
-
-// meteredPipe implements p2p.MsgReadWriter and remembers the largest single
-// message size sent through the pipe
-type meteredPipe struct {
-	rw      p2p.MsgReadWriter
-	maxSize uint32
-}
-
-func (m *meteredPipe) ReadMsg() (p2p.Msg, error) {
-	return m.rw.ReadMsg()
-}
-
-func (m *meteredPipe) WriteMsg(msg p2p.Msg) error {
-	if msg.Size > m.maxSize {
-		m.maxSize = msg.Size
-	}
-	return m.rw.WriteMsg(msg)
-}
-
-// measure runs a benchmark for a single type in a single pass, with the given
-// number of requests
-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[:])
-
-	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 {
-		return err
-	}
-
-	errCh := make(chan error, 10)
-	start := mclock.Now()
-
-	go func() {
-		for i := 0; i < count; i++ {
-			if err := setup.req.request(peer1, i); err != nil {
-				errCh <- err
-				return
-			}
-		}
-	}()
-	go func() {
-		for i := 0; i < count; i++ {
-			if err := h.handleMsg(peer2, &sync.WaitGroup{}); err != nil {
-				errCh <- err
-				return
-			}
-		}
-	}()
-	go func() {
-		for i := 0; i < count; i++ {
-			msg, err := clientPipe.ReadMsg()
-			if err != nil {
-				errCh <- err
-				return
-			}
-			var i interface{}
-			msg.Decode(&i)
-		}
-		// at this point we can be sure that the other two
-		// goroutines finished successfully too
-		close(errCh)
-	}()
-	select {
-	case err := <-errCh:
-		if err != nil {
-			return err
-		}
-	case <-h.closeCh:
-		clientPipe.Close()
-		serverPipe.Close()
-		return errors.New("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

@@ -1,75 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/bitutil"
-	"github.com/ethereum/go-ethereum/light"
-)
-
-const (
-	// bloomServiceThreads is the number of goroutines used globally by an Ethereum
-	// instance to service bloombits lookups for all running filters.
-	bloomServiceThreads = 16
-
-	// bloomFilterThreads is the number of goroutines used locally per filter to
-	// multiplex requests onto the global servicing goroutines.
-	bloomFilterThreads = 3
-
-	// bloomRetrievalBatch is the maximum number of bloom bit retrievals to service
-	// in a single batch.
-	bloomRetrievalBatch = 16
-
-	// bloomRetrievalWait is the maximum time to wait for enough bloom bit requests
-	// to accumulate request an entire batch (avoiding hysteresis).
-	bloomRetrievalWait = time.Microsecond * 100
-)
-
-// startBloomHandlers starts a batch of goroutines to accept bloom bit database
-// retrievals from possibly a range of filters and serving the data to satisfy.
-func (eth *LightEthereum) startBloomHandlers(sectionSize uint64) {
-	for i := 0; i < bloomServiceThreads; i++ {
-		go func() {
-			defer eth.wg.Done()
-			for {
-				select {
-				case <-eth.closeCh:
-					return
-
-				case request := <-eth.bloomRequests:
-					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 {
-								task.Bitsets[i] = blob
-							} else {
-								task.Error = err
-							}
-						}
-					} else {
-						task.Error = err
-					}
-					request <- task
-				}
-			}
-		}()
-	}
-}

les/client.go

@@ -1,377 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// Package les implements the Light Ethereum Subprotocol.
-package les
-
-import (
-	"errors"
-	"strings"
-	"time"
-
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/consensus"
-	"github.com/ethereum/go-ethereum/core"
-	"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/ethconfig"
-	"github.com/ethereum/go-ethereum/eth/gasprice"
-	"github.com/ethereum/go-ethereum/event"
-	"github.com/ethereum/go-ethereum/internal/ethapi"
-	"github.com/ethereum/go-ethereum/internal/shutdowncheck"
-	"github.com/ethereum/go-ethereum/les/vflux"
-	vfc "github.com/ethereum/go-ethereum/les/vflux/client"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/node"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/p2p/enr"
-	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/ethereum/go-ethereum/trie"
-)
-
-type LightEthereum struct {
-	lesCommons
-
-	peers              *serverPeerSet
-	reqDist            *requestDistributor
-	retriever          *retrieveManager
-	odr                *LesOdr
-	relay              *lesTxRelay
-	handler            *clientHandler
-	txPool             *light.TxPool
-	blockchain         *light.LightChain
-	serverPool         *vfc.ServerPool
-	serverPoolIterator enode.Iterator
-	merger             *consensus.Merger
-
-	bloomRequests chan chan *bloombits.Retrieval // Channel receiving bloom data retrieval requests
-	bloomIndexer  *core.ChainIndexer             // Bloom indexer operating during block imports
-
-	ApiBackend     *LesApiBackend
-	eventMux       *event.TypeMux
-	engine         consensus.Engine
-	accountManager *accounts.Manager
-	netRPCService  *ethapi.NetAPI
-
-	p2pServer  *p2p.Server
-	p2pConfig  *p2p.Config
-	udpEnabled bool
-
-	shutdownTracker *shutdowncheck.ShutdownTracker // Tracks if and when the node has shutdown ungracefully
-}
-
-// New creates an instance of the light client.
-func New(stack *node.Node, config *ethconfig.Config) (*LightEthereum, error) {
-	chainDb, err := stack.OpenDatabase("lightchaindata", config.DatabaseCache, config.DatabaseHandles, "eth/db/chaindata/", false)
-	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 {
-		overrides.OverrideCancun = config.OverrideCancun
-	}
-	if config.OverrideVerkle != nil {
-		overrides.OverrideVerkle = config.OverrideVerkle
-	}
-	triedb := trie.NewDatabase(chainDb, trie.HashDefaults)
-	chainConfig, genesisHash, genesisErr := core.SetupGenesisBlockWithOverride(chainDb, triedb, config.Genesis, &overrides)
-	if _, isCompat := genesisErr.(*params.ConfigCompatError); genesisErr != nil && !isCompat {
-		return nil, genesisErr
-	}
-	engine, err := ethconfig.CreateConsensusEngine(chainConfig, chainDb)
-	if err != nil {
-		return nil, err
-	}
-	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("")
-
-	peers := newServerPeerSet()
-	merger := consensus.NewMerger(chainDb)
-	leth := &LightEthereum{
-		lesCommons: lesCommons{
-			genesis:     genesisHash,
-			config:      config,
-			chainConfig: chainConfig,
-			iConfig:     light.DefaultClientIndexerConfig,
-			chainDb:     chainDb,
-			lesDb:       lesDb,
-			closeCh:     make(chan struct{}),
-		},
-		peers:           peers,
-		eventMux:        stack.EventMux(),
-		reqDist:         newRequestDistributor(peers, &mclock.System{}),
-		accountManager:  stack.AccountManager(),
-		merger:          merger,
-		engine:          engine,
-		bloomRequests:   make(chan chan *bloombits.Retrieval),
-		bloomIndexer:    core.NewBloomIndexer(chainDb, params.BloomBitsBlocksClient, params.HelperTrieConfirmations),
-		p2pServer:       stack.Server(),
-		p2pConfig:       &stack.Config().P2P,
-		udpEnabled:      stack.Config().P2P.DiscoveryV5,
-		shutdownTracker: shutdowncheck.NewShutdownTracker(chainDb),
-	}
-
-	var prenegQuery vfc.QueryFunc
-	if leth.udpEnabled {
-		prenegQuery = leth.prenegQuery
-	}
-	leth.serverPool, leth.serverPoolIterator = vfc.NewServerPool(lesDb, []byte("serverpool:"), time.Second, prenegQuery, &mclock.System{}, nil, requestList)
-	leth.serverPool.AddMetrics(suggestedTimeoutGauge, totalValueGauge, serverSelectableGauge, serverConnectedGauge, sessionValueMeter, serverDialedMeter)
-
-	leth.retriever = newRetrieveManager(peers, leth.reqDist, leth.serverPool.GetTimeout)
-	leth.relay = newLesTxRelay(peers, leth.retriever)
-
-	leth.odr = NewLesOdr(chainDb, light.DefaultClientIndexerConfig, leth.peers, leth.retriever)
-	leth.chtIndexer = light.NewChtIndexer(chainDb, leth.odr, params.CHTFrequency, params.HelperTrieConfirmations, config.LightNoPrune)
-	leth.bloomTrieIndexer = light.NewBloomTrieIndexer(chainDb, leth.odr, params.BloomBitsBlocksClient, params.BloomTrieFrequency, config.LightNoPrune)
-	leth.odr.SetIndexers(leth.chtIndexer, leth.bloomTrieIndexer, leth.bloomIndexer)
-
-	// 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); err != nil {
-		return nil, err
-	}
-	leth.chainReader = leth.blockchain
-	leth.txPool = light.NewTxPool(leth.chainConfig, leth.blockchain, leth.relay)
-
-	// Note: AddChildIndexer starts the update process for the child
-	leth.bloomIndexer.AddChildIndexer(leth.bloomTrieIndexer)
-	leth.chtIndexer.Start(leth.blockchain)
-	leth.bloomIndexer.Start(leth.blockchain)
-
-	// 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)
-		} else {
-			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)
-	leth.netRPCService = ethapi.NewNetAPI(leth.p2pServer, leth.config.NetworkId)
-
-	// Register the backend on the node
-	stack.RegisterAPIs(leth.APIs())
-	stack.RegisterProtocols(leth.Protocols())
-	stack.RegisterLifecycle(leth)
-
-	// Successful startup; push a marker and check previous unclean shutdowns.
-	leth.shutdownTracker.MarkStartup()
-
-	return leth, nil
-}
-
-// VfluxRequest sends a batch of requests to the given node through discv5 UDP TalkRequest and returns the responses
-func (s *LightEthereum) VfluxRequest(n *enode.Node, reqs vflux.Requests) vflux.Replies {
-	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
-}
-
-// vfxVersion returns the version number of the "les" service subdomain of the vflux UDP
-// service, as advertised in the ENR record
-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 {
-			return 0
-		}
-	}
-
-	var les []rlp.RawValue
-	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
-}
-
-// prenegQuery sends a capacity query to the given server node to determine whether
-// a connection slot is immediately available
-func (s *LightEthereum) prenegQuery(n *enode.Node) int {
-	if s.vfxVersion(n) < 1 {
-		// UDP query not supported, always try TCP connection
-		return 1
-	}
-
-	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
-}
-
-type LightDummyAPI struct{}
-
-// Etherbase is the address that mining rewards will be sent to
-func (s *LightDummyAPI) Etherbase() (common.Address, error) {
-	return common.Address{}, errors.New("mining is not supported in light mode")
-}
-
-// Coinbase is the address that mining rewards will be sent to (alias for Etherbase)
-func (s *LightDummyAPI) Coinbase() (common.Address, error) {
-	return common.Address{}, errors.New("mining is not supported in light mode")
-}
-
-// Hashrate returns the POW hashrate
-func (s *LightDummyAPI) Hashrate() hexutil.Uint {
-	return 0
-}
-
-// Mining returns an indication if this node is currently mining.
-func (s *LightDummyAPI) Mining() bool {
-	return false
-}
-
-// APIs returns the collection of RPC services the ethereum package offers.
-// NOTE, some of these services probably need to be moved to somewhere else.
-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",
-			Service:   &LightDummyAPI{},
-		}, {
-			Namespace: "net",
-			Service:   s.netRPCService,
-		}, {
-			Namespace: "vflux",
-			Service:   s.serverPool.API(),
-		},
-	}...)
-}
-
-func (s *LightEthereum) ResetWithGenesisBlock(gb *types.Block) {
-	s.blockchain.ResetWithGenesisBlock(gb)
-}
-
-func (s *LightEthereum) BlockChain() *light.LightChain { return s.blockchain }
-func (s *LightEthereum) TxPool() *light.TxPool         { return s.txPool }
-func (s *LightEthereum) Engine() consensus.Engine      { return s.engine }
-func (s *LightEthereum) LesVersion() int               { return int(ClientProtocolVersions[0]) }
-func (s *LightEthereum) EventMux() *event.TypeMux      { return s.eventMux }
-func (s *LightEthereum) Merger() *consensus.Merger     { return s.merger }
-
-// Protocols returns all the currently configured network protocols to start.
-func (s *LightEthereum) Protocols() []p2p.Protocol {
-	return s.makeProtocols(ClientProtocolVersions, s.handler.runPeer, func(id enode.ID) interface{} {
-		if p := s.peers.peer(id.String()); p != nil {
-			return p.Info()
-		}
-		return nil
-	}, s.serverPoolIterator)
-}
-
-// Start implements node.Lifecycle, starting all internal goroutines needed by the
-// light ethereum protocol implementation.
-func (s *LightEthereum) Start() error {
-	log.Warn("Light client mode is an experimental feature")
-
-	// Regularly update shutdown marker
-	s.shutdownTracker.Start()
-
-	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.
-	s.wg.Add(bloomServiceThreads)
-	s.startBloomHandlers(params.BloomBitsBlocksClient)
-
-	return nil
-}
-
-// Stop implements node.Lifecycle, terminating all internal goroutines used by the
-// Ethereum protocol.
-func (s *LightEthereum) Stop() error {
-	close(s.closeCh)
-	s.serverPool.Stop()
-	s.peers.close()
-	s.reqDist.close()
-	s.odr.Stop()
-	s.relay.Stop()
-	s.bloomIndexer.Close()
-	s.chtIndexer.Close()
-	s.blockchain.Stop()
-	s.handler.stop()
-	s.txPool.Stop()
-	s.engine.Close()
-	s.eventMux.Stop()
-	// Clean shutdown marker as the last thing before closing db
-	s.shutdownTracker.Stop()
-
-	s.chainDb.Close()
-	s.lesDb.Close()
-	s.wg.Wait()
-	log.Info("Light ethereum stopped")
-	return nil
-}

les/client_handler.go

@@ -1,309 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/core/forkid"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/trie/trienode"
-)
-
-// clientHandler is responsible for receiving and processing all incoming server
-// responses.
-type clientHandler struct {
-	forkFilter forkid.Filter
-	backend    *LightEthereum
-
-	closeCh chan struct{}
-	wg      sync.WaitGroup // WaitGroup used to track all connected peers.
-}
-
-func newClientHandler(backend *LightEthereum) *clientHandler {
-	handler := &clientHandler{
-		forkFilter: forkid.NewFilter(backend.blockchain),
-		backend:    backend,
-		closeCh:    make(chan struct{}),
-	}
-	return handler
-}
-
-func (h *clientHandler) stop() {
-	close(h.closeCh)
-	h.wg.Wait()
-}
-
-// runPeer is the p2p protocol run function for the given version.
-func (h *clientHandler) runPeer(version uint, p *p2p.Peer, rw p2p.MsgReadWriter) error {
-	peer := newServerPeer(int(version), h.backend.config.NetworkId, false, p, newMeteredMsgWriter(rw, int(version)))
-	defer peer.close()
-	h.wg.Add(1)
-	defer h.wg.Done()
-	err := h.handle(peer, false)
-	return err
-}
-
-func (h *clientHandler) handle(p *serverPeer, noInitAnnounce bool) error {
-	if h.backend.peers.len() >= h.backend.config.LightPeers && !p.Peer.Info().Network.Trusted {
-		return p2p.DiscTooManyPeers
-	}
-	p.Log().Debug("Light Ethereum peer connected", "name", p.Name())
-
-	// Execute the LES handshake
-	forkid := forkid.NewID(h.backend.blockchain.Config(), h.backend.BlockChain().Genesis(), h.backend.blockchain.CurrentHeader().Number.Uint64(), h.backend.blockchain.CurrentHeader().Time)
-	if err := p.Handshake(h.backend.blockchain.Genesis().Hash(), forkid, h.forkFilter); err != nil {
-		p.Log().Debug("Light Ethereum handshake failed", "err", err)
-		return err
-	}
-	// Register peer with the server pool
-	if h.backend.serverPool != nil {
-		if nvt, err := h.backend.serverPool.RegisterNode(p.Node()); err == nil {
-			p.setValueTracker(nvt)
-			p.updateVtParams()
-			defer func() {
-				p.setValueTracker(nil)
-				h.backend.serverPool.UnregisterNode(p.Node())
-			}()
-		} else {
-			return err
-		}
-	}
-	// Register the peer locally
-	if err := h.backend.peers.register(p); err != nil {
-		p.Log().Error("Light Ethereum peer registration failed", "err", err)
-		return err
-	}
-
-	serverConnectionGauge.Update(int64(h.backend.peers.len()))
-
-	connectedAt := mclock.Now()
-	defer func() {
-		h.backend.peers.unregister(p.id)
-		connectionTimer.Update(time.Duration(mclock.Now() - connectedAt))
-		serverConnectionGauge.Update(int64(h.backend.peers.len()))
-	}()
-
-	// Mark the peer starts to be served.
-	p.serving.Store(true)
-	defer p.serving.Store(false)
-
-	// Spawn a main loop to handle all incoming messages.
-	for {
-		if err := h.handleMsg(p); err != nil {
-			p.Log().Debug("Light Ethereum message handling failed", "err", err)
-			p.fcServer.DumpLogs()
-			return err
-		}
-	}
-}
-
-// handleMsg is invoked whenever an inbound message is received from a remote
-// peer. The remote connection is torn down upon returning any error.
-func (h *clientHandler) handleMsg(p *serverPeer) error {
-	// Read the next message from the remote peer, and ensure it's fully consumed
-	msg, err := p.rw.ReadMsg()
-	if err != nil {
-		return err
-	}
-	p.Log().Trace("Light Ethereum message arrived", "code", msg.Code, "bytes", msg.Size)
-
-	if msg.Size > ProtocolMaxMsgSize {
-		return errResp(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize)
-	}
-	defer msg.Discard()
-
-	var deliverMsg *Msg
-
-	// Handle the message depending on its contents
-	switch {
-	case msg.Code == AnnounceMsg:
-		p.Log().Trace("Received announce message")
-		var req announceData
-		if err := msg.Decode(&req); err != nil {
-			return errResp(ErrDecode, "%v: %v", msg, err)
-		}
-		if err := req.sanityCheck(); err != nil {
-			return err
-		}
-		update, size := req.Update.decode()
-		if p.rejectUpdate(size) {
-			return errResp(ErrRequestRejected, "")
-		}
-		p.updateFlowControl(update)
-		p.updateVtParams()
-
-		if req.Hash != (common.Hash{}) {
-			if p.announceType == announceTypeNone {
-				return errResp(ErrUnexpectedResponse, "")
-			}
-			if p.announceType == announceTypeSigned {
-				if err := req.checkSignature(p.ID(), update); err != nil {
-					p.Log().Trace("Invalid announcement signature", "err", err)
-					return err
-				}
-				p.Log().Trace("Valid announcement signature")
-			}
-			p.Log().Trace("Announce message content", "number", req.Number, "hash", req.Hash, "td", req.Td, "reorg", req.ReorgDepth)
-
-			// Update peer head information first and then notify the announcement
-			p.updateHead(req.Hash, req.Number, req.Td)
-		}
-	case msg.Code == BlockHeadersMsg:
-		p.Log().Trace("Received block header response message")
-		var resp struct {
-			ReqID, BV uint64
-			Headers   []*types.Header
-		}
-		if err := msg.Decode(&resp); err != nil {
-			return errResp(ErrDecode, "msg %v: %v", msg, err)
-		}
-		p.fcServer.ReceivedReply(resp.ReqID, resp.BV)
-		p.answeredRequest(resp.ReqID)
-
-		deliverMsg = &Msg{
-			MsgType: MsgBlockHeaders,
-			ReqID:   resp.ReqID,
-			Obj:     resp.Headers,
-		}
-	case msg.Code == BlockBodiesMsg:
-		p.Log().Trace("Received block bodies response")
-		var resp struct {
-			ReqID, BV uint64
-			Data      []*types.Body
-		}
-		if err := msg.Decode(&resp); err != nil {
-			return errResp(ErrDecode, "msg %v: %v", msg, err)
-		}
-		p.fcServer.ReceivedReply(resp.ReqID, resp.BV)
-		p.answeredRequest(resp.ReqID)
-		deliverMsg = &Msg{
-			MsgType: MsgBlockBodies,
-			ReqID:   resp.ReqID,
-			Obj:     resp.Data,
-		}
-	case msg.Code == CodeMsg:
-		p.Log().Trace("Received code response")
-		var resp struct {
-			ReqID, BV uint64
-			Data      [][]byte
-		}
-		if err := msg.Decode(&resp); err != nil {
-			return errResp(ErrDecode, "msg %v: %v", msg, err)
-		}
-		p.fcServer.ReceivedReply(resp.ReqID, resp.BV)
-		p.answeredRequest(resp.ReqID)
-		deliverMsg = &Msg{
-			MsgType: MsgCode,
-			ReqID:   resp.ReqID,
-			Obj:     resp.Data,
-		}
-	case msg.Code == ReceiptsMsg:
-		p.Log().Trace("Received receipts response")
-		var resp struct {
-			ReqID, BV uint64
-			Receipts  []types.Receipts
-		}
-		if err := msg.Decode(&resp); err != nil {
-			return errResp(ErrDecode, "msg %v: %v", msg, err)
-		}
-		p.fcServer.ReceivedReply(resp.ReqID, resp.BV)
-		p.answeredRequest(resp.ReqID)
-		deliverMsg = &Msg{
-			MsgType: MsgReceipts,
-			ReqID:   resp.ReqID,
-			Obj:     resp.Receipts,
-		}
-	case msg.Code == ProofsV2Msg:
-		p.Log().Trace("Received les/2 proofs response")
-		var resp struct {
-			ReqID, BV uint64
-			Data      trienode.ProofList
-		}
-		if err := msg.Decode(&resp); err != nil {
-			return errResp(ErrDecode, "msg %v: %v", msg, err)
-		}
-		p.fcServer.ReceivedReply(resp.ReqID, resp.BV)
-		p.answeredRequest(resp.ReqID)
-		deliverMsg = &Msg{
-			MsgType: MsgProofsV2,
-			ReqID:   resp.ReqID,
-			Obj:     resp.Data,
-		}
-	case msg.Code == HelperTrieProofsMsg:
-		p.Log().Trace("Received helper trie proof response")
-		var resp struct {
-			ReqID, BV uint64
-			Data      HelperTrieResps
-		}
-		if err := msg.Decode(&resp); err != nil {
-			return errResp(ErrDecode, "msg %v: %v", msg, err)
-		}
-		p.fcServer.ReceivedReply(resp.ReqID, resp.BV)
-		p.answeredRequest(resp.ReqID)
-		deliverMsg = &Msg{
-			MsgType: MsgHelperTrieProofs,
-			ReqID:   resp.ReqID,
-			Obj:     resp.Data,
-		}
-	case msg.Code == TxStatusMsg:
-		p.Log().Trace("Received tx status response")
-		var resp struct {
-			ReqID, BV uint64
-			Status    []light.TxStatus
-		}
-		if err := msg.Decode(&resp); err != nil {
-			return errResp(ErrDecode, "msg %v: %v", msg, err)
-		}
-		p.fcServer.ReceivedReply(resp.ReqID, resp.BV)
-		p.answeredRequest(resp.ReqID)
-		deliverMsg = &Msg{
-			MsgType: MsgTxStatus,
-			ReqID:   resp.ReqID,
-			Obj:     resp.Status,
-		}
-	case msg.Code == StopMsg && p.version >= lpv3:
-		p.freeze()
-		h.backend.retriever.frozen(p)
-		p.Log().Debug("Service stopped")
-	case msg.Code == ResumeMsg && p.version >= lpv3:
-		var bv uint64
-		if err := msg.Decode(&bv); err != nil {
-			return errResp(ErrDecode, "msg %v: %v", msg, err)
-		}
-		p.fcServer.ResumeFreeze(bv)
-		p.unfreeze()
-		p.Log().Debug("Service resumed")
-	default:
-		p.Log().Trace("Received invalid message", "code", msg.Code)
-		return errResp(ErrInvalidMsgCode, "%v", msg.Code)
-	}
-	// Deliver the received response to retriever.
-	if deliverMsg != nil {
-		if err := h.backend.retriever.deliver(p, deliverMsg); err != nil {
-			if val := p.errCount.Add(1, mclock.Now()); val > maxResponseErrors {
-				return err
-			}
-		}
-	}
-	return nil
-}

les/commons.go

@@ -1,99 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"fmt"
-	"math/big"
-	"sync"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/eth/ethconfig"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/params"
-)
-
-func errResp(code errCode, format string, v ...interface{}) error {
-	return fmt.Errorf("%v - %v", code, fmt.Sprintf(format, v...))
-}
-
-type chainReader interface {
-	CurrentHeader() *types.Header
-}
-
-// lesCommons contains fields needed by both server and client.
-type lesCommons struct {
-	genesis                      common.Hash
-	config                       *ethconfig.Config
-	chainConfig                  *params.ChainConfig
-	iConfig                      *light.IndexerConfig
-	chainDb, lesDb               ethdb.Database
-	chainReader                  chainReader
-	chtIndexer, bloomTrieIndexer *core.ChainIndexer
-
-	closeCh chan struct{}
-	wg      sync.WaitGroup
-}
-
-// NodeInfo represents a short summary of the Ethereum sub-protocol metadata
-// known about the host peer.
-type NodeInfo struct {
-	Network    uint64              `json:"network"`    // Ethereum network ID (1=Mainnet, Goerli=5)
-	Difficulty *big.Int            `json:"difficulty"` // Total difficulty of the host's blockchain
-	Genesis    common.Hash         `json:"genesis"`    // SHA3 hash of the host's genesis block
-	Config     *params.ChainConfig `json:"config"`     // Chain configuration for the fork rules
-	Head       common.Hash         `json:"head"`       // SHA3 hash of the host's best owned block
-}
-
-// makeProtocols creates protocol descriptors for the given LES versions.
-func (c *lesCommons) makeProtocols(versions []uint, runPeer func(version uint, p *p2p.Peer, rw p2p.MsgReadWriter) error, peerInfo func(id enode.ID) interface{}, dialCandidates enode.Iterator) []p2p.Protocol {
-	protos := make([]p2p.Protocol, len(versions))
-	for i, version := range versions {
-		version := version
-		protos[i] = p2p.Protocol{
-			Name:     "les",
-			Version:  version,
-			Length:   ProtocolLengths[version],
-			NodeInfo: c.nodeInfo,
-			Run: func(peer *p2p.Peer, rw p2p.MsgReadWriter) error {
-				return runPeer(version, peer, rw)
-			},
-			PeerInfo:       peerInfo,
-			DialCandidates: dialCandidates,
-		}
-	}
-	return protos
-}
-
-// nodeInfo retrieves some protocol metadata about the running host node.
-func (c *lesCommons) nodeInfo() interface{} {
-	head := c.chainReader.CurrentHeader()
-	hash := head.Hash()
-	return &NodeInfo{
-		Network:    c.config.NetworkId,
-		Difficulty: rawdb.ReadTd(c.chainDb, hash, head.Number.Uint64()),
-		Genesis:    c.genesis,
-		Config:     c.chainConfig,
-		Head:       hash,
-	}
-}

les/costtracker.go

@@ -1,517 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"encoding/binary"
-	"math"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/eth/ethconfig"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/les/flowcontrol"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/metrics"
-)
-
-const makeCostStats = false // make request cost statistics during operation
-
-var (
-	// average request cost estimates based on serving time
-	reqAvgTimeCost = requestCostTable{
-		GetBlockHeadersMsg:     {150000, 30000},
-		GetBlockBodiesMsg:      {0, 700000},
-		GetReceiptsMsg:         {0, 1000000},
-		GetCodeMsg:             {0, 450000},
-		GetProofsV2Msg:         {0, 600000},
-		GetHelperTrieProofsMsg: {0, 1000000},
-		SendTxV2Msg:            {0, 450000},
-		GetTxStatusMsg:         {0, 250000},
-	}
-	// maximum incoming message size estimates
-	reqMaxInSize = requestCostTable{
-		GetBlockHeadersMsg:     {40, 0},
-		GetBlockBodiesMsg:      {0, 40},
-		GetReceiptsMsg:         {0, 40},
-		GetCodeMsg:             {0, 80},
-		GetProofsV2Msg:         {0, 80},
-		GetHelperTrieProofsMsg: {0, 20},
-		SendTxV2Msg:            {0, 16500},
-		GetTxStatusMsg:         {0, 50},
-	}
-	// maximum outgoing message size estimates
-	reqMaxOutSize = requestCostTable{
-		GetBlockHeadersMsg:     {0, 556},
-		GetBlockBodiesMsg:      {0, 100000},
-		GetReceiptsMsg:         {0, 200000},
-		GetCodeMsg:             {0, 50000},
-		GetProofsV2Msg:         {0, 4000},
-		GetHelperTrieProofsMsg: {0, 4000},
-		SendTxV2Msg:            {0, 100},
-		GetTxStatusMsg:         {0, 100},
-	}
-	// request amounts that have to fit into the minimum buffer size minBufferMultiplier times
-	minBufferReqAmount = map[uint64]uint64{
-		GetBlockHeadersMsg:     192,
-		GetBlockBodiesMsg:      1,
-		GetReceiptsMsg:         1,
-		GetCodeMsg:             1,
-		GetProofsV2Msg:         1,
-		GetHelperTrieProofsMsg: 16,
-		SendTxV2Msg:            8,
-		GetTxStatusMsg:         64,
-	}
-	minBufferMultiplier = 3
-)
-
-const (
-	maxCostFactor    = 2    // ratio of maximum and average cost estimates
-	bufLimitRatio    = 6000 // fixed bufLimit/MRR ratio
-	gfUsageThreshold = 0.5
-	gfUsageTC        = time.Second
-	gfRaiseTC        = time.Second * 200
-	gfDropTC         = time.Second * 50
-	gfDbKey          = "_globalCostFactorV6"
-)
-
-// costTracker is responsible for calculating costs and cost estimates on the
-// server side. It continuously updates the global cost factor which is defined
-// as the number of cost units per nanosecond of serving time in a single thread.
-// It is based on statistics collected during serving requests in high-load periods
-// and practically acts as a one-dimension request price scaling factor over the
-// pre-defined cost estimate table.
-//
-// The reason for dynamically maintaining the global factor on the server side is:
-// the estimated time cost of the request is fixed(hardcoded) but the configuration
-// of the machine running the server is really different. Therefore, the request serving
-// time in different machine will vary greatly. And also, the request serving time
-// in same machine may vary greatly with different request pressure.
-//
-// In order to more effectively limit resources, we apply the global factor to serving
-// time to make the result as close as possible to the estimated time cost no matter
-// the server is slow or fast. And also we scale the totalRecharge with global factor
-// so that fast server can serve more requests than estimation and slow server can
-// reduce request pressure.
-//
-// Instead of scaling the cost values, the real value of cost units is changed by
-// applying the factor to the serving times. This is more convenient because the
-// changes in the cost factor can be applied immediately without always notifying
-// the clients about the changed cost tables.
-type costTracker struct {
-	db     ethdb.Database
-	stopCh chan chan struct{}
-
-	inSizeFactor  float64
-	outSizeFactor float64
-	factor        float64
-	utilTarget    float64
-	minBufLimit   uint64
-
-	gfLock          sync.RWMutex
-	reqInfoCh       chan reqInfo
-	totalRechargeCh chan uint64
-
-	stats map[uint64][]atomic.Uint64 // Used for testing purpose.
-
-	// TestHooks
-	testing      bool            // Disable real cost evaluation for testing purpose.
-	testCostList RequestCostList // Customized cost table for testing purpose.
-}
-
-// newCostTracker creates a cost tracker and loads the cost factor statistics from the database.
-// It also returns the minimum capacity that can be assigned to any peer.
-func newCostTracker(db ethdb.Database, config *ethconfig.Config) (*costTracker, uint64) {
-	utilTarget := float64(config.LightServ) * flowcontrol.FixedPointMultiplier / 100
-	ct := &costTracker{
-		db:         db,
-		stopCh:     make(chan chan struct{}),
-		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][]atomic.Uint64)
-		for code := range reqAvgTimeCost {
-			ct.stats[code] = make([]atomic.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
-}
-
-// stop stops the cost tracker and saves the cost factor statistics to the database
-func (ct *costTracker) stop() {
-	stopCh := make(chan struct{})
-	ct.stopCh <- stopCh
-	<-stopCh
-	if makeCostStats {
-		ct.printStats()
-	}
-}
-
-// makeCostList returns upper cost estimates based on the hardcoded cost estimate
-// tables and the optionally specified incoming/outgoing bandwidth limits
-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]
-			if maxCost > ct.minBufLimit {
-				mul := 0.999 * float64(ct.minBufLimit) / float64(maxCost)
-				baseCost = uint64(float64(baseCost) * mul)
-				reqCost = uint64(float64(reqCost) * mul)
-			}
-		}
-
-		list = append(list, requestCostListItem{
-			MsgCode:  code,
-			BaseCost: baseCost,
-			ReqCost:  reqCost,
-		})
-	}
-	return list
-}
-
-// reqInfo contains the estimated time cost and the actual request serving time
-// which acts as a feed source to update factor maintained by costTracker.
-type reqInfo struct {
-	// avgTimeCost is the estimated time cost corresponding to maxCostTable.
-	avgTimeCost float64
-
-	// servingTime is the CPU time corresponding to the actual processing of
-	// the request.
-	servingTime float64
-
-	// msgCode indicates the type of request.
-	msgCode uint64
-}
-
-// gfLoop starts an event loop which updates the global cost factor which is
-// calculated as a weighted average of the average estimate / serving time ratio.
-// The applied weight equals the serving time if gfUsage is over a threshold,
-// zero otherwise. gfUsage is the recent average serving time per time unit in
-// an exponential moving window. This ensures that statistics are collected only
-// under high-load circumstances where the measured serving times are relevant.
-// The total recharge parameter of the flow control system which controls the
-// total allowed serving time per second but nominated in cost units, should
-// also be scaled with the cost factor and is also updated by this loop.
-func (ct *costTracker) gfLoop() {
-	var (
-		factor, totalRecharge        float64
-		gfLog, recentTime, recentAvg float64
-
-		lastUpdate, expUpdate = mclock.Now(), mclock.Now()
-	)
-
-	// Load historical cost factor statistics from the database.
-	data, _ := ct.db.Get([]byte(gfDbKey))
-	if len(data) == 8 {
-		gfLog = math.Float64frombits(binary.BigEndian.Uint64(data[:]))
-	}
-	ct.factor = math.Exp(gfLog)
-	factor, totalRecharge = ct.factor, ct.utilTarget*ct.factor
-
-	// In order to perform factor data statistics under the high request pressure,
-	// we only adjust factor when recent factor usage beyond the threshold.
-	threshold := gfUsageThreshold * float64(gfUsageTC) * ct.utilTarget / flowcontrol.FixedPointMultiplier
-
-	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()
-
-		for {
-			select {
-			case r := <-ct.reqInfoCh:
-				relCost := int64(factor * r.servingTime * 100 / r.avgTimeCost) // Convert the value to a percentage form
-
-				// Record more metrics if we are debugging
-				if metrics.EnabledExpensive {
-					switch r.msgCode {
-					case GetBlockHeadersMsg:
-						relativeCostHeaderHistogram.Update(relCost)
-					case GetBlockBodiesMsg:
-						relativeCostBodyHistogram.Update(relCost)
-					case GetReceiptsMsg:
-						relativeCostReceiptHistogram.Update(relCost)
-					case GetCodeMsg:
-						relativeCostCodeHistogram.Update(relCost)
-					case GetProofsV2Msg:
-						relativeCostProofHistogram.Update(relCost)
-					case GetHelperTrieProofsMsg:
-						relativeCostHelperProofHistogram.Update(relCost)
-					case SendTxV2Msg:
-						relativeCostSendTxHistogram.Update(relCost)
-					case GetTxStatusMsg:
-						relativeCostTxStatusHistogram.Update(relCost)
-					}
-				}
-				// SendTxV2 and GetTxStatus requests are two special cases.
-				// All other requests will only put pressure on the database, and
-				// the corresponding delay is relatively stable. While these two
-				// requests involve txpool query, which is usually unstable.
-				//
-				// TODO(rjl493456442) fixes this.
-				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))
-				requestEstimatedTimer.Update(time.Duration(r.avgTimeCost / factor))
-				relativeCostHistogram.Update(relCost)
-
-				now := mclock.Now()
-				dt := float64(now - expUpdate)
-				expUpdate = now
-				exp := math.Exp(-dt / float64(gfUsageTC))
-
-				// calculate factor correction until now, based on previous values
-				var gfCorr float64
-				max := recentTime
-				if recentAvg > max {
-					max = recentAvg
-				}
-				// we apply continuous correction when MAX(recentTime, recentAvg) > threshold
-				if max > threshold {
-					// calculate correction time between last expUpdate and now
-					if max*exp >= threshold {
-						gfCorr = dt
-					} else {
-						gfCorr = math.Log(max/threshold) * float64(gfUsageTC)
-					}
-					// calculate log(factor) correction with the right direction and time constant
-					if recentTime > recentAvg {
-						// drop factor if actual serving times are larger than average estimates
-						gfCorr /= -float64(gfDropTC)
-					} else {
-						// raise factor if actual serving times are smaller than average estimates
-						gfCorr /= float64(gfRaiseTC)
-					}
-				}
-				// update recent cost values with current request
-				recentTime = recentTime*exp + r.servingTime
-				recentAvg = recentAvg*exp + r.avgTimeCost/factor
-
-				if gfCorr != 0 {
-					// Apply the correction to factor
-					gfLog += gfCorr
-					factor = math.Exp(gfLog)
-					// Notify outside modules the new factor and totalRecharge.
-					if time.Duration(now-lastUpdate) > time.Second {
-						totalRecharge, lastUpdate = ct.utilTarget*factor, now
-						ct.gfLock.Lock()
-						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))
-
-			case <-saveTicker.C:
-				saveCostFactor()
-
-			case stopCh := <-ct.stopCh:
-				saveCostFactor()
-				close(stopCh)
-				return
-			}
-		}
-	}()
-}
-
-// globalFactor returns the current value of the global cost factor
-func (ct *costTracker) globalFactor() float64 {
-	ct.gfLock.RLock()
-	defer ct.gfLock.RUnlock()
-
-	return ct.factor
-}
-
-// totalRecharge returns the current total recharge parameter which is used by
-// flowcontrol.ClientManager and is scaled by the global cost factor
-func (ct *costTracker) totalRecharge() uint64 {
-	ct.gfLock.RLock()
-	defer ct.gfLock.RUnlock()
-
-	return uint64(ct.factor * ct.utilTarget)
-}
-
-// subscribeTotalRecharge returns all future updates to the total recharge value
-// through a channel and also returns the current value
-func (ct *costTracker) subscribeTotalRecharge(ch chan uint64) uint64 {
-	ct.gfLock.Lock()
-	defer ct.gfLock.Unlock()
-
-	ct.totalRechargeCh = ch
-	return uint64(ct.factor * ct.utilTarget)
-}
-
-// updateStats updates the global cost factor and (if enabled) the real cost vs.
-// average estimate statistics
-func (ct *costTracker) updateStats(code, amount, servingTime, realCost uint64) {
-	avg := reqAvgTimeCost[code]
-	avgTimeCost := avg.baseCost + amount*avg.reqCost
-	select {
-	case ct.reqInfoCh <- reqInfo{float64(avgTimeCost), float64(servingTime), code}:
-	default:
-	}
-	if makeCostStats {
-		realCost <<= 4
-		l := 0
-		for l < 9 && realCost > avgTimeCost {
-			l++
-			realCost >>= 1
-		}
-		ct.stats[code][l].Add(1)
-	}
-}
-
-// realCost calculates the final cost of a request based on actual serving time,
-// incoming and outgoing message size
-//
-// Note: message size is only taken into account if bandwidth limitation is applied
-// and the cost based on either message size is greater than the cost based on
-// serving time. A maximum of the three costs is applied instead of their sum
-// because the three limited resources (serving thread time and i/o bandwidth) can
-// also be maxed out simultaneously.
-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())
-}
-
-// printStats prints the distribution of real request cost relative to the average estimates
-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].Load(), "1/8", arr[1].Load(), "1/4", arr[2].Load(), "1/2", arr[3].Load(), "1", arr[4].Load(), "2", arr[5].Load(), "4", arr[6].Load(), "8", arr[7].Load(), "16", arr[8].Load(), ">16", arr[9].Load())
-	}
-}
-
-type (
-	// requestCostTable assigns a cost estimate function to each request type
-	// which is a linear function of the requested amount
-	// (cost = baseCost + reqCost * amount)
-	requestCostTable map[uint64]*requestCosts
-	requestCosts     struct {
-		baseCost, reqCost uint64
-	}
-
-	// RequestCostList is a list representation of request costs which is used for
-	// database storage and communication through the network
-	RequestCostList     []requestCostListItem
-	requestCostListItem struct {
-		MsgCode, BaseCost, ReqCost uint64
-	}
-)
-
-// getMaxCost calculates the estimated cost for a given request type and amount
-func (table requestCostTable) getMaxCost(code, amount uint64) uint64 {
-	costs := table[code]
-	return costs.baseCost + amount*costs.reqCost
-}
-
-// 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{
-				baseCost: e.BaseCost,
-				reqCost:  e.ReqCost,
-			}
-		}
-	}
-	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
-			cl[i].BaseCost = testCost
-			cl[i].ReqCost = 0
-			i++
-		}
-	}
-	return cl
-}

les/distributor.go

@@ -1,313 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"container/list"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/les/utils"
-)
-
-// requestDistributor implements a mechanism that distributes requests to
-// suitable peers, obeying flow control rules and prioritizing them in creation
-// order (even when a resend is necessary).
-type requestDistributor struct {
-	clock        mclock.Clock
-	reqQueue     *list.List
-	lastReqOrder uint64
-	peers        map[distPeer]struct{}
-	peerLock     sync.RWMutex
-	loopChn      chan struct{}
-	loopNextSent bool
-	lock         sync.Mutex
-
-	closeCh chan struct{}
-	wg      sync.WaitGroup
-}
-
-// distPeer is an LES server peer interface for the request distributor.
-// waitBefore returns either the necessary waiting time before sending a request
-// with the given upper estimated cost or the estimated remaining relative buffer
-// value after sending such a request (in which case the request can be sent
-// immediately). At least one of these values is always zero.
-type distPeer interface {
-	waitBefore(uint64) (time.Duration, float64)
-	canQueue() bool
-	queueSend(f func()) bool
-}
-
-// distReq is the request abstraction used by the distributor. It is based on
-// three callback functions:
-// - getCost returns the upper estimate of the cost of sending the request to a given peer
-// - canSend tells if the server peer is suitable to serve the request
-// - request prepares sending the request to the given peer and returns a function that
-// does the actual sending. Request order should be preserved but the callback itself should not
-// block until it is sent because other peers might still be able to receive requests while
-// one of them is blocking. Instead, the returned function is put in the peer's send queue.
-type distReq struct {
-	getCost func(distPeer) uint64
-	canSend func(distPeer) bool
-	request func(distPeer) func()
-
-	reqOrder     uint64
-	sentChn      chan distPeer
-	element      *list.Element
-	waitForPeers mclock.AbsTime
-	enterQueue   mclock.AbsTime
-}
-
-// newRequestDistributor creates a new request distributor
-func newRequestDistributor(peers *serverPeerSet, clock mclock.Clock) *requestDistributor {
-	d := &requestDistributor{
-		clock:    clock,
-		reqQueue: list.New(),
-		loopChn:  make(chan struct{}, 2),
-		closeCh:  make(chan struct{}),
-		peers:    make(map[distPeer]struct{}),
-	}
-	if peers != nil {
-		peers.subscribe(d)
-	}
-	d.wg.Add(1)
-	go d.loop()
-	return d
-}
-
-// registerPeer implements peerSetNotify
-func (d *requestDistributor) registerPeer(p *serverPeer) {
-	d.peerLock.Lock()
-	d.peers[p] = struct{}{}
-	d.peerLock.Unlock()
-}
-
-// unregisterPeer implements peerSetNotify
-func (d *requestDistributor) unregisterPeer(p *serverPeer) {
-	d.peerLock.Lock()
-	delete(d.peers, p)
-	d.peerLock.Unlock()
-}
-
-// registerTestPeer adds a new test peer
-func (d *requestDistributor) registerTestPeer(p distPeer) {
-	d.peerLock.Lock()
-	d.peers[p] = struct{}{}
-	d.peerLock.Unlock()
-}
-
-var (
-	// distMaxWait is the maximum waiting time after which further necessary waiting
-	// times are recalculated based on new feedback from the servers
-	distMaxWait = time.Millisecond * 50
-
-	// waitForPeers is the time window in which a request does not fail even if it
-	// has no suitable peers to send to at the moment
-	waitForPeers = time.Second * 3
-)
-
-// 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)
-				close(req.sentChn)
-				req.sentChn = nil
-				elem = elem.Next()
-			}
-			d.lock.Unlock()
-			return
-		case <-d.loopChn:
-			d.lock.Lock()
-			d.loopNextSent = false
-		loop:
-			for {
-				peer, req, wait := d.nextRequest()
-				if req != nil && wait == 0 {
-					chn := req.sentChn // save sentChn because remove sets it to nil
-					d.remove(req)
-					send := req.request(peer)
-					if send != nil {
-						peer.queueSend(send)
-						requestSendDelay.Update(time.Duration(d.clock.Now() - req.enterQueue))
-					}
-					chn <- peer
-					close(chn)
-				} else {
-					if wait == 0 {
-						// no request to send and nothing to wait for; the next
-						// queued request will wake up the loop
-						break loop
-					}
-					d.loopNextSent = true // a "next" signal has been sent, do not send another one until this one has been received
-					if wait > distMaxWait {
-						// waiting times may be reduced by incoming request replies, if it is too long, recalculate it periodically
-						wait = distMaxWait
-					}
-					go func() {
-						d.clock.Sleep(wait)
-						d.loopChn <- struct{}{}
-					}()
-					break loop
-				}
-			}
-			d.lock.Unlock()
-		}
-	}
-}
-
-// selectPeerItem represents a peer to be selected for a request by weightedRandomSelect
-type selectPeerItem struct {
-	peer   distPeer
-	req    *distReq
-	weight uint64
-}
-
-func selectPeerWeight(i interface{}) uint64 {
-	return i.(selectPeerItem).weight
-}
-
-// nextRequest returns the next possible request from any peer, along with the
-// associated peer and necessary waiting time
-func (d *requestDistributor) nextRequest() (distPeer, *distReq, time.Duration) {
-	checkedPeers := make(map[distPeer]struct{})
-	elem := d.reqQueue.Front()
-	var (
-		bestWait time.Duration
-		sel      *utils.WeightedRandomSelect
-	)
-
-	d.peerLock.RLock()
-	defer d.peerLock.RUnlock()
-
-	peerCount := len(d.peers)
-	for (len(checkedPeers) < peerCount || elem == d.reqQueue.Front()) && elem != nil {
-		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
-	}
-
-	if sel != nil {
-		c := sel.Choose().(selectPeerItem)
-		return c.peer, c.req, 0
-	}
-	return nil, nil, bestWait
-}
-
-// queue adds a request to the distribution queue, returns a channel where the
-// receiving peer is sent once the request has been sent (request callback returned).
-// If the request is cancelled or timed out without suitable peers, the channel is
-// closed without sending any peer references to it.
-func (d *requestDistributor) queue(r *distReq) chan distPeer {
-	d.lock.Lock()
-	defer d.lock.Unlock()
-
-	if r.reqOrder == 0 {
-		d.lastReqOrder++
-		r.reqOrder = d.lastReqOrder
-		r.waitForPeers = d.clock.Now().Add(waitForPeers)
-	}
-	// Assign the timestamp when the request is queued no matter it's
-	// a new one or re-queued one.
-	r.enterQueue = d.clock.Now()
-
-	back := d.reqQueue.Back()
-	if back == nil || r.reqOrder > back.Value.(*distReq).reqOrder {
-		r.element = d.reqQueue.PushBack(r)
-	} else {
-		before := d.reqQueue.Front()
-		for before.Value.(*distReq).reqOrder < r.reqOrder {
-			before = before.Next()
-		}
-		r.element = d.reqQueue.InsertBefore(r, before)
-	}
-
-	if !d.loopNextSent {
-		d.loopNextSent = true
-		d.loopChn <- struct{}{}
-	}
-
-	r.sentChn = make(chan distPeer, 1)
-	return r.sentChn
-}
-
-// cancel removes a request from the queue if it has not been sent yet (returns
-// false if it has been sent already). It is guaranteed that the callback functions
-// will not be called after cancel returns.
-func (d *requestDistributor) cancel(r *distReq) bool {
-	d.lock.Lock()
-	defer d.lock.Unlock()
-
-	if r.sentChn == nil {
-		return false
-	}
-
-	close(r.sentChn)
-	d.remove(r)
-	return true
-}
-
-// remove removes a request from the queue
-func (d *requestDistributor) remove(r *distReq) {
-	r.sentChn = nil
-	if r.element != nil {
-		d.reqQueue.Remove(r.element)
-		r.element = nil
-	}
-}
-
-func (d *requestDistributor) close() {
-	close(d.closeCh)
-	d.wg.Wait()
-}

les/distributor_test.go

@@ -1,189 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"math/rand"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-)
-
-type testDistReq struct {
-	cost, procTime, order uint64
-	canSendTo             map[*testDistPeer]struct{}
-}
-
-func (r *testDistReq) getCost(dp distPeer) uint64 {
-	return r.cost
-}
-
-func (r *testDistReq) canSend(dp distPeer) bool {
-	_, ok := r.canSendTo[dp.(*testDistPeer)]
-	return ok
-}
-
-func (r *testDistReq) request(dp distPeer) func() {
-	return func() { dp.(*testDistPeer).send(r) }
-}
-
-type testDistPeer struct {
-	sent    []*testDistReq
-	sumCost uint64
-	lock    sync.RWMutex
-}
-
-func (p *testDistPeer) send(r *testDistReq) {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-
-	p.sent = append(p.sent, r)
-	p.sumCost += r.cost
-}
-
-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()
-		select {
-		case <-stop:
-			return
-		case <-time.After(wait):
-		}
-	}
-}
-
-const (
-	testDistBufLimit       = 10000000
-	testDistMaxCost        = 1000000
-	testDistPeerCount      = 2
-	testDistReqCount       = 10
-	testDistMaxResendCount = 3
-)
-
-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
-}
-
-func (p *testDistPeer) canQueue() bool {
-	return true
-}
-
-func (p *testDistPeer) queueSend(f func()) bool {
-	f()
-	return true
-}
-
-func TestRequestDistributor(t *testing.T) {
-	testRequestDistributor(t, false)
-}
-
-func TestRequestDistributorResend(t *testing.T) {
-	testRequestDistributor(t, true)
-}
-
-func testRequestDistributor(t *testing.T, resend bool) {
-	stop := make(chan struct{})
-	defer close(stop)
-
-	dist := newRequestDistributor(nil, &mclock.System{})
-	var peers [testDistPeerCount]*testDistPeer
-	for i := range peers {
-		peers[i] = &testDistPeer{}
-		go peers[i].worker(t, !resend, stop)
-		dist.registerTestPeer(peers[i])
-	}
-	// Disable the mechanism that we will wait a few time for request
-	// even there is no suitable peer to send right now.
-	waitForPeers = 0
-
-	var wg sync.WaitGroup
-
-	for i := 1; i <= testDistReqCount; i++ {
-		cost := uint64(rand.Int63n(testDistMaxCost))
-		procTime := uint64(rand.Int63n(int64(cost + 1)))
-		rq := &testDistReq{
-			cost:      cost,
-			procTime:  procTime,
-			order:     uint64(i),
-			canSendTo: make(map[*testDistPeer]struct{}),
-		}
-		for _, peer := range peers {
-			if rand.Intn(2) != 0 {
-				rq.canSendTo[peer] = struct{}{}
-			}
-		}
-
-		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 {
-						t.Errorf("Request that could have been sent was dropped")
-					}
-				} else {
-					peer := p.(*testDistPeer)
-					if _, ok := rq.canSendTo[peer]; !ok {
-						t.Errorf("Request sent to wrong peer")
-					}
-				}
-			}
-			wg.Done()
-		}()
-		if rand.Intn(1000) == 0 {
-			time.Sleep(time.Duration(rand.Intn(5000000)))
-		}
-	}
-
-	wg.Wait()
-}

les/enr_entry.go

@@ -1,72 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"github.com/ethereum/go-ethereum/core/forkid"
-	"github.com/ethereum/go-ethereum/p2p/dnsdisc"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-// lesEntry is the "les" ENR entry. This is set for LES servers only.
-type lesEntry struct {
-	// Ignore additional fields (for forward compatibility).
-	VfxVersion uint
-	Rest       []rlp.RawValue `rlp:"tail"`
-}
-
-func (lesEntry) ENRKey() string { return "les" }
-
-// ethEntry is the "eth" ENR entry. This is redeclared here to avoid depending on package eth.
-type ethEntry struct {
-	ForkID forkid.ID
-	Tail   []rlp.RawValue `rlp:"tail"`
-}
-
-func (ethEntry) ENRKey() string { return "eth" }
-
-// setupDiscovery creates the node discovery source for the eth protocol.
-func (eth *LightEthereum) setupDiscovery() (enode.Iterator, error) {
-	it := enode.NewFairMix(0)
-
-	// 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)
-	}
-
-	// Enable DHT.
-	if eth.udpEnabled {
-		it.AddSource(eth.p2pServer.DiscV5.RandomNodes())
-	}
-
-	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

@@ -1,433 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// Package flowcontrol implements a client side flow control mechanism
-package flowcontrol
-
-import (
-	"fmt"
-	"math"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-const (
-	// fcTimeConst is the time constant applied for MinRecharge during linear
-	// buffer recharge period
-	fcTimeConst = time.Millisecond
-	// DecParamDelay is applied at server side when decreasing capacity in order to
-	// avoid a buffer underrun error due to requests sent by the client before
-	// receiving the capacity update announcement
-	DecParamDelay = time.Second * 2
-	// keepLogs is the duration of keeping logs; logging is not used if zero
-	keepLogs = 0
-)
-
-// ServerParams are the flow control parameters specified by a server for a client
-//
-// Note: a server can assign different amounts of capacity to each client by giving
-// different parameters to them.
-type ServerParams struct {
-	BufLimit, MinRecharge uint64
-}
-
-// scheduledUpdate represents a delayed flow control parameter update
-type scheduledUpdate struct {
-	time   mclock.AbsTime
-	params ServerParams
-}
-
-// ClientNode is the flow control system's representation of a client
-// (used in server mode only)
-type ClientNode struct {
-	params         ServerParams
-	bufValue       int64
-	lastTime       mclock.AbsTime
-	updateSchedule []scheduledUpdate
-	sumCost        uint64            // sum of req costs received from this client
-	accepted       map[uint64]uint64 // value = sumCost after accepting the given req
-	connected      bool
-	lock           sync.Mutex
-	cm             *ClientManager
-	log            *logger
-	cmNodeFields
-}
-
-// NewClientNode returns a new ClientNode
-func NewClientNode(cm *ClientManager, params ServerParams) *ClientNode {
-	node := &ClientNode{
-		cm:        cm,
-		params:    params,
-		bufValue:  int64(params.BufLimit),
-		lastTime:  cm.clock.Now(),
-		accepted:  make(map[uint64]uint64),
-		connected: true,
-	}
-	if keepLogs > 0 {
-		node.log = newLogger(keepLogs)
-	}
-	cm.connect(node)
-	return node
-}
-
-// Disconnect should be called when a client is disconnected
-func (node *ClientNode) Disconnect() {
-	node.lock.Lock()
-	defer node.lock.Unlock()
-
-	node.connected = false
-	node.cm.disconnect(node)
-}
-
-// BufferStatus returns the current buffer value and limit
-func (node *ClientNode) BufferStatus() (uint64, uint64) {
-	node.lock.Lock()
-	defer node.lock.Unlock()
-
-	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
-}
-
-// OneTimeCost subtracts the given amount from the node's buffer.
-//
-// Note: this call can take the buffer into the negative region internally.
-// In this case zero buffer value is returned by exported calls and no requests
-// are accepted.
-func (node *ClientNode) OneTimeCost(cost uint64) {
-	node.lock.Lock()
-	defer node.lock.Unlock()
-
-	now := node.cm.clock.Now()
-	node.update(now)
-	node.bufValue -= int64(cost)
-	node.cm.updateBuffer(node, -int64(cost), now)
-}
-
-// Freeze notifies the client manager about a client freeze event in which case
-// the total capacity allowance is slightly reduced.
-func (node *ClientNode) Freeze() {
-	node.lock.Lock()
-	frozenCap := node.params.MinRecharge
-	node.lock.Unlock()
-	node.cm.reduceTotalCapacity(frozenCap)
-}
-
-// update recalculates the buffer value at a specified time while also performing
-// scheduled flow control parameter updates if necessary
-func (node *ClientNode) update(now mclock.AbsTime) {
-	for len(node.updateSchedule) > 0 && node.updateSchedule[0].time <= now {
-		node.recalcBV(node.updateSchedule[0].time)
-		node.updateParams(node.updateSchedule[0].params, now)
-		node.updateSchedule = node.updateSchedule[1:]
-	}
-	node.recalcBV(now)
-}
-
-// recalcBV recalculates the buffer value at a specified time
-func (node *ClientNode) recalcBV(now mclock.AbsTime) {
-	dt := uint64(now - node.lastTime)
-	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
-}
-
-// UpdateParams updates the flow control parameters of a client node
-func (node *ClientNode) UpdateParams(params ServerParams) {
-	node.lock.Lock()
-	defer node.lock.Unlock()
-
-	now := node.cm.clock.Now()
-	node.update(now)
-	if params.MinRecharge >= node.params.MinRecharge {
-		node.updateSchedule = nil
-		node.updateParams(params, now)
-	} else {
-		for i, s := range node.updateSchedule {
-			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})
-	}
-}
-
-// updateParams updates the flow control parameters of the node
-func (node *ClientNode) updateParams(params ServerParams, now mclock.AbsTime) {
-	diff := int64(params.BufLimit - node.params.BufLimit)
-	if diff > 0 {
-		node.bufValue += diff
-	} else if node.bufValue > int64(params.BufLimit) {
-		node.bufValue = int64(params.BufLimit)
-	}
-	node.cm.updateParams(node, params, now)
-}
-
-// AcceptRequest returns whether a new request can be accepted and the missing
-// buffer amount if it was rejected due to a buffer underrun. If accepted, maxCost
-// is deducted from the flow control buffer.
-func (node *ClientNode) AcceptRequest(reqID, index, maxCost uint64) (accepted bool, bufShort uint64, priority int64) {
-	node.lock.Lock()
-	defer node.lock.Unlock()
-
-	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)
-}
-
-// RequestProcessed should be called when the request has been processed
-func (node *ClientNode) RequestProcessed(reqID, index, maxCost, realCost uint64) uint64 {
-	node.lock.Lock()
-	defer node.lock.Unlock()
-
-	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)
-}
-
-// ServerNode is the flow control system's representation of a server
-// (used in client mode only)
-type ServerNode struct {
-	clock       mclock.Clock
-	bufEstimate uint64
-	bufRecharge bool
-	lastTime    mclock.AbsTime
-	params      ServerParams
-	sumCost     uint64            // sum of req costs sent to this server
-	pending     map[uint64]uint64 // value = sumCost after sending the given req
-	log         *logger
-	lock        sync.RWMutex
-}
-
-// NewServerNode returns a new ServerNode
-func NewServerNode(params ServerParams, clock mclock.Clock) *ServerNode {
-	node := &ServerNode{
-		clock:       clock,
-		bufEstimate: params.BufLimit,
-		bufRecharge: false,
-		lastTime:    clock.Now(),
-		params:      params,
-		pending:     make(map[uint64]uint64),
-	}
-	if keepLogs > 0 {
-		node.log = newLogger(keepLogs)
-	}
-	return node
-}
-
-// UpdateParams updates the flow control parameters of the node
-func (node *ServerNode) UpdateParams(params ServerParams) {
-	node.lock.Lock()
-	defer node.lock.Unlock()
-
-	node.recalcBLE(mclock.Now())
-	if params.BufLimit > node.params.BufLimit {
-		node.bufEstimate += params.BufLimit - node.params.BufLimit
-	} else {
-		if node.bufEstimate > params.BufLimit {
-			node.bufEstimate = params.BufLimit
-		}
-	}
-	node.params = params
-}
-
-// recalcBLE recalculates the lowest estimate for the client's buffer value at
-// the given server at the specified time
-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))
-	}
-}
-
-// safetyMargin is added to the flow control waiting time when estimated buffer value is low
-const safetyMargin = time.Millisecond
-
-// CanSend returns the minimum waiting time required before sending a request
-// with the given maximum estimated cost. Second return value is the relative
-// estimated buffer level after sending the request (divided by BufLimit).
-func (node *ServerNode) CanSend(maxCost uint64) (time.Duration, float64) {
-	node.lock.RLock()
-	defer node.lock.RUnlock()
-
-	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
-}
-
-// QueuedRequest should be called when the request has been assigned to the given
-// server node, before putting it in the send queue. It is mandatory that requests
-// are sent in the same order as the QueuedRequest calls are made.
-func (node *ServerNode) QueuedRequest(reqID, maxCost uint64) {
-	node.lock.Lock()
-	defer node.lock.Unlock()
-
-	now := node.clock.Now()
-	node.recalcBLE(now)
-	// Note: we do not know when requests actually arrive to the server so bufRecharge
-	// is not turned on here if buffer was full; in this case it is going to be turned
-	// on by the first reply's bufValue feedback
-	if node.bufEstimate >= maxCost {
-		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))
-	}
-}
-
-// ReceivedReply adjusts estimated buffer value according to the value included in
-// the latest request reply.
-func (node *ServerNode) ReceivedReply(reqID, bv uint64) {
-	node.lock.Lock()
-	defer node.lock.Unlock()
-
-	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.
-		// The lowest estimate based on the previous reply can still be considered valid.
-		node.bufEstimate = newEstimate
-	}
-
-	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))
-	}
-}
-
-// ResumeFreeze cleans all pending requests and sets the buffer estimate to the
-// reported value after resuming from a frozen state
-func (node *ServerNode) ResumeFreeze(bv uint64) {
-	node.lock.Lock()
-	defer node.lock.Unlock()
-
-	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))
-	}
-}
-
-// DumpLogs dumps the event log if logging is used
-func (node *ServerNode) DumpLogs() {
-	node.lock.Lock()
-	defer node.lock.Unlock()
-
-	if node.log != nil {
-		node.log.dump(node.clock.Now())
-	}
-}

les/flowcontrol/logger.go

@@ -1,65 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package flowcontrol
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-)
-
-// logger collects events in string format and discards events older than the
-// "keep" parameter
-type logger struct {
-	events           map[uint64]logEvent
-	writePtr, delPtr uint64
-	keep             time.Duration
-}
-
-// logEvent describes a single event
-type logEvent struct {
-	time  mclock.AbsTime
-	event string
-}
-
-// newLogger creates a new logger
-func newLogger(keep time.Duration) *logger {
-	return &logger{
-		events: make(map[uint64]logEvent),
-		keep:   keep,
-	}
-}
-
-// add adds a new event and discards old events if possible
-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++
-}
-
-// dump prints all stored events
-func (l *logger) dump(now mclock.AbsTime) {
-	for i := l.delPtr; i < l.writePtr; i++ {
-		e := l.events[i]
-		fmt.Println(time.Duration(e.time-now), e.event)
-	}
-}

les/flowcontrol/manager.go

@@ -1,476 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package flowcontrol
-
-import (
-	"fmt"
-	"math"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/common/prque"
-)
-
-// cmNodeFields are ClientNode fields used by the client manager
-// Note: these fields are locked by the client manager's mutex
-type cmNodeFields struct {
-	corrBufValue   int64 // buffer value adjusted with the extra recharge amount
-	rcLastIntValue int64 // past recharge integrator value when corrBufValue was last updated
-	rcFullIntValue int64 // future recharge integrator value when corrBufValue will reach maximum
-	queueIndex     int   // position in the recharge queue (-1 if not queued)
-}
-
-// FixedPointMultiplier is applied to the recharge integrator and the recharge curve.
-//
-// Note: fixed point arithmetic is required for the integrator because it is a
-// constantly increasing value that can wrap around int64 limits (which behavior is
-// also supported by the priority queue). A floating point value would gradually lose
-// precision in this application.
-// The recharge curve and all recharge values are encoded as fixed point because
-// sumRecharge is frequently updated by adding or subtracting individual recharge
-// values and perfect precision is required.
-const FixedPointMultiplier = 1000000
-
-var (
-	capacityDropFactor          = 0.1
-	capacityRaiseTC             = 1 / (3 * float64(time.Hour)) // time constant for raising the capacity factor
-	capacityRaiseThresholdRatio = 1.125                        // total/connected capacity ratio threshold for raising the capacity factor
-)
-
-// ClientManager controls the capacity assigned to the clients of a server.
-// Since ServerParams guarantee a safe lower estimate for processable requests
-// even in case of all clients being active, ClientManager calculates a
-// corrugated buffer value and usually allows a higher remaining buffer value
-// to be returned with each reply.
-type ClientManager struct {
-	clock mclock.Clock
-	lock  sync.Mutex
-	stop  chan chan struct{}
-
-	curve                                      PieceWiseLinear
-	sumRecharge, totalRecharge, totalConnected uint64
-	logTotalCap, totalCapacity                 float64
-	logTotalCapRaiseLimit                      float64
-	minLogTotalCap, maxLogTotalCap             float64
-	capacityRaiseThreshold                     uint64
-	capLastUpdate                              mclock.AbsTime
-	totalCapacityCh                            chan uint64
-
-	// recharge integrator is increasing in each moment with a rate of
-	// (totalRecharge / sumRecharge)*FixedPointMultiplier or 0 if sumRecharge==0
-	rcLastUpdate   mclock.AbsTime // last time the recharge integrator was updated
-	rcLastIntValue int64          // last updated value of the recharge integrator
-	priorityOffset int64          // offset for prque priority values ensures that all priorities stay in the int64 range
-	// recharge queue is a priority queue with currently recharging client nodes
-	// as elements. The priority value is rcFullIntValue which allows to quickly
-	// determine which client will first finish recharge.
-	rcQueue *prque.Prque[int64, *ClientNode]
-}
-
-// NewClientManager returns a new client manager.
-// Client manager enhances flow control performance by allowing client buffers
-// to recharge quicker than the minimum guaranteed recharge rate if possible.
-// The sum of all minimum recharge rates (sumRecharge) is updated each time
-// a clients starts or finishes buffer recharging. Then an adjusted total
-// recharge rate is calculated using a piecewise linear recharge curve:
-//
-// totalRecharge = curve(sumRecharge)
-// (totalRecharge >= sumRecharge is enforced)
-//
-// Then the "bonus" buffer recharge is distributed between currently recharging
-// clients proportionally to their minimum recharge rates.
-//
-// Note: total recharge is proportional to the average number of parallel running
-// serving threads. A recharge value of 1000000 corresponds to one thread in average.
-// The maximum number of allowed serving threads should always be considerably
-// higher than the targeted average number.
-//
-// Note 2: although it is possible to specify a curve allowing the total target
-// recharge starting from zero sumRecharge, it makes sense to add a linear ramp
-// starting from zero in order to not let a single low-priority client use up
-// the entire server capacity and thus ensure quick availability for others at
-// any moment.
-func NewClientManager(curve PieceWiseLinear, clock mclock.Clock) *ClientManager {
-	cm := &ClientManager{
-		clock:         clock,
-		rcQueue:       prque.New[int64, *ClientNode](func(a *ClientNode, i int) { a.queueIndex = i }),
-		capLastUpdate: clock.Now(),
-		stop:          make(chan chan struct{}),
-	}
-	if curve != nil {
-		cm.SetRechargeCurve(curve)
-	}
-	go func() {
-		// regularly recalculate and update total capacity
-		for {
-			select {
-			case <-time.After(time.Minute):
-				cm.lock.Lock()
-				cm.updateTotalCapacity(cm.clock.Now(), true)
-				cm.lock.Unlock()
-			case stop := <-cm.stop:
-				close(stop)
-				return
-			}
-		}
-	}()
-	return cm
-}
-
-// Stop stops the client manager
-func (cm *ClientManager) Stop() {
-	stop := make(chan struct{})
-	cm.stop <- stop
-	<-stop
-}
-
-// SetRechargeCurve updates the recharge curve
-func (cm *ClientManager) SetRechargeCurve(curve PieceWiseLinear) {
-	cm.lock.Lock()
-	defer cm.lock.Unlock()
-
-	now := cm.clock.Now()
-	cm.updateRecharge(now)
-	cm.curve = curve
-	if len(curve) > 0 {
-		cm.totalRecharge = curve[len(curve)-1].Y
-	} else {
-		cm.totalRecharge = 0
-	}
-}
-
-// SetCapacityLimits sets a threshold value used for raising capFactor.
-// Either if the difference between total allowed and connected capacity is less
-// than this threshold or if their ratio is less than capacityRaiseThresholdRatio
-// then capFactor is allowed to slowly raise.
-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
-	cm.refreshCapacity()
-}
-
-// connect should be called when a client is connected, before passing it to any
-// other ClientManager function
-func (cm *ClientManager) connect(node *ClientNode) {
-	cm.lock.Lock()
-	defer cm.lock.Unlock()
-
-	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()
-}
-
-// disconnect should be called when a client is disconnected
-func (cm *ClientManager) disconnect(node *ClientNode) {
-	cm.lock.Lock()
-	defer cm.lock.Unlock()
-
-	now := cm.clock.Now()
-	cm.updateRecharge(cm.clock.Now())
-	cm.updateTotalCapacity(now, true)
-	cm.totalConnected -= node.params.MinRecharge
-	cm.updateRaiseLimit()
-}
-
-// accepted is called when a request with given maximum cost is accepted.
-// It returns a priority indicator for the request which is used to determine placement
-// in the serving queue. Older requests have higher priority by default. If the client
-// is almost out of buffer, request priority is reduced.
-func (cm *ClientManager) accepted(node *ClientNode, maxCost uint64, now mclock.AbsTime) (priority int64) {
-	cm.lock.Lock()
-	defer cm.lock.Unlock()
-
-	cm.updateNodeRc(node, -int64(maxCost), &node.params, now)
-	rcTime := (node.params.BufLimit - uint64(node.corrBufValue)) * FixedPointMultiplier / node.params.MinRecharge
-	return -int64(now) - int64(rcTime)
-}
-
-// processed updates the client buffer according to actual request cost after
-// serving has been finished.
-//
-// Note: processed should always be called for all accepted requests
-func (cm *ClientManager) processed(node *ClientNode, maxCost, realCost uint64, now mclock.AbsTime) {
-	if realCost > maxCost {
-		realCost = maxCost
-	}
-	cm.updateBuffer(node, int64(maxCost-realCost), now)
-}
-
-// updateBuffer recalculates the corrected buffer value, adds the given value to it
-// and updates the node's actual buffer value if possible
-func (cm *ClientManager) updateBuffer(node *ClientNode, add int64, now mclock.AbsTime) {
-	cm.lock.Lock()
-	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
-	}
-}
-
-// updateParams updates the flow control parameters of a client node
-func (cm *ClientManager) updateParams(node *ClientNode, params ServerParams, now mclock.AbsTime) {
-	cm.lock.Lock()
-	defer cm.lock.Unlock()
-
-	cm.updateRecharge(now)
-	cm.updateTotalCapacity(now, true)
-	cm.totalConnected += params.MinRecharge - node.params.MinRecharge
-	cm.updateRaiseLimit()
-	cm.updateNodeRc(node, 0, &params, now)
-}
-
-// updateRaiseLimit recalculates the limiting value until which logTotalCap
-// can be raised when no client freeze events occur
-func (cm *ClientManager) updateRaiseLimit() {
-	if cm.capacityRaiseThreshold == 0 {
-		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)
-}
-
-// updateRecharge updates the recharge integrator and checks the recharge queue
-// for nodes with recently filled buffers
-func (cm *ClientManager) updateRecharge(now mclock.AbsTime) {
-	lastUpdate := cm.rcLastUpdate
-	cm.rcLastUpdate = now
-	// updating is done in multiple steps if node buffers are filled and sumRecharge
-	// is decreased before the given target time
-	for cm.sumRecharge > 0 {
-		sumRecharge := cm.sumRecharge
-		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
-		// check whether it has already finished
-		dtNext := mclock.AbsTime(float64(rcqNode.rcFullIntValue-cm.rcLastIntValue) / bonusRatio)
-		if dt < dtNext {
-			// not finished yet, put it back, update integrator according
-			// 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
-	}
-}
-
-func (cm *ClientManager) addToQueue(node *ClientNode) {
-	if cm.priorityOffset-node.rcFullIntValue < -0x4000000000000000 {
-		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)
-}
-
-// updateNodeRc updates a node's corrBufValue and adds an external correction value.
-// 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)
-	}
-}
-
-// reduceTotalCapacity reduces the total capacity allowance in case of a client freeze event
-func (cm *ClientManager) reduceTotalCapacity(frozenCap uint64) {
-	cm.lock.Lock()
-	defer cm.lock.Unlock()
-
-	ratio := float64(1)
-	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)
-}
-
-// updateTotalCapacity updates the total capacity factor. The capacity factor allows
-// the total capacity of the system to go over the allowed total recharge value
-// if clients go to frozen state sufficiently rarely.
-// The capacity factor is dropped instantly by a small amount if a clients is frozen.
-// It is raised slowly (with a large time constant) if the total connected capacity
-// is close to the total allowed amount and no clients are frozen.
-func (cm *ClientManager) updateTotalCapacity(now mclock.AbsTime, refresh bool) {
-	dt := now - cm.capLastUpdate
-	cm.capLastUpdate = now
-
-	if cm.logTotalCap < cm.logTotalCapRaiseLimit {
-		cm.logTotalCap += capacityRaiseTC * float64(dt)
-		if cm.logTotalCap > cm.logTotalCapRaiseLimit {
-			cm.logTotalCap = cm.logTotalCapRaiseLimit
-		}
-	}
-	if cm.logTotalCap > cm.maxLogTotalCap {
-		cm.logTotalCap = cm.maxLogTotalCap
-	}
-	if refresh {
-		cm.refreshCapacity()
-	}
-}
-
-// refreshCapacity recalculates the total capacity value and sends an update to the subscription
-// channel if the relative change of the value since the last update is more than 0.1 percent
-func (cm *ClientManager) refreshCapacity() {
-	totalCapacity := math.Exp(cm.logTotalCap)
-	if totalCapacity >= cm.totalCapacity*0.999 && totalCapacity <= cm.totalCapacity*1.001 {
-		return
-	}
-	cm.totalCapacity = totalCapacity
-	if cm.totalCapacityCh != nil {
-		select {
-		case cm.totalCapacityCh <- uint64(cm.totalCapacity):
-		default:
-		}
-	}
-}
-
-// SubscribeTotalCapacity returns all future updates to the total capacity value
-// through a channel and also returns the current value
-func (cm *ClientManager) SubscribeTotalCapacity(ch chan uint64) uint64 {
-	cm.lock.Lock()
-	defer cm.lock.Unlock()
-
-	cm.totalCapacityCh = ch
-	return uint64(cm.totalCapacity)
-}
-
-// PieceWiseLinear is used to describe recharge curves
-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 {
-			l = m + 1
-		} else {
-			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)
-}
-
-// Valid returns true if the X coordinates of the curve points are non-strictly monotonic
-func (pwl PieceWiseLinear) Valid() bool {
-	var lastX uint64
-	for _, i := range pwl {
-		if i.X < lastX {
-			return false
-		}
-		lastX = i.X
-	}
-	return true
-}

les/flowcontrol/manager_test.go

@@ -1,130 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package flowcontrol
-
-import (
-	"math"
-	"math/rand"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-)
-
-type testNode struct {
-	node               *ClientNode
-	bufLimit, capacity uint64
-	waitUntil          mclock.AbsTime
-	index, totalCost   uint64
-}
-
-const (
-	testMaxCost = 1000000
-	testLength  = 100000
-)
-
-// testConstantTotalCapacity simulates multiple request sender nodes and verifies
-// whether the total amount of served requests matches the expected value based on
-// the total capacity and the duration of the test.
-// Some nodes are sending requests occasionally so that their buffer should regularly
-// reach the maximum while other nodes (the "max capacity nodes") are sending at the
-// maximum permitted rate. The max capacity nodes are changed multiple times during
-// a single test.
-func TestConstantTotalCapacity(t *testing.T) {
-	testConstantTotalCapacity(t, 10, 1, 0, false)
-	testConstantTotalCapacity(t, 10, 1, 1, false)
-	testConstantTotalCapacity(t, 30, 1, 0, false)
-	testConstantTotalCapacity(t, 30, 2, 3, false)
-	testConstantTotalCapacity(t, 100, 1, 0, false)
-	testConstantTotalCapacity(t, 100, 3, 5, false)
-	testConstantTotalCapacity(t, 100, 5, 10, false)
-	testConstantTotalCapacity(t, 100, 3, 5, true)
-}
-
-func testConstantTotalCapacity(t *testing.T, nodeCount, maxCapacityNodes, randomSend int, priorityOverflow bool) {
-	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
-		// in that case we have fewer max nodes
-		maxNodes[i] = rand.Intn(nodeCount)
-	}
-
-	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--
-			} else {
-				failCount--
-			}
-		}
-		clock.Run(time.Millisecond)
-	}
-
-	var totalCost uint64
-	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)
-	}
-}
-
-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

@@ -1,754 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"encoding/binary"
-	"math/big"
-	"math/rand"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/consensus/ethash"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/txpool"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/eth/downloader"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/ethereum/go-ethereum/trie"
-	"github.com/ethereum/go-ethereum/trie/trienode"
-)
-
-func expectResponse(r p2p.MsgReader, msgcode, reqID, bv uint64, data interface{}) error {
-	type resp struct {
-		ReqID, BV uint64
-		Data      interface{}
-	}
-	return p2p.ExpectMsg(r, msgcode, resp{reqID, bv, data})
-}
-
-// Tests that block headers can be retrieved from a remote chain based on user queries.
-func TestGetBlockHeadersLes2(t *testing.T) { testGetBlockHeaders(t, 2) }
-func TestGetBlockHeadersLes3(t *testing.T) { testGetBlockHeaders(t, 3) }
-func TestGetBlockHeadersLes4(t *testing.T) { testGetBlockHeaders(t, 4) }
-
-func testGetBlockHeaders(t *testing.T, protocol int) {
-	netconfig := testnetConfig{
-		blocks:    downloader.MaxHeaderFetch + 15,
-		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
-	var unknown common.Hash
-	for i := range unknown {
-		unknown[i] = byte(i)
-	}
-	// Create a batch of tests for various scenarios
-	limit := uint64(MaxHeaderFetch)
-	tests := []struct {
-		query  *GetBlockHeadersData // The query to execute for header retrieval
-		expect []common.Hash        // The hashes of the block whose headers are expected
-	}{
-		// A single random block should be retrievable by hash and number too
-		{
-			&GetBlockHeadersData{Origin: hashOrNumber{Hash: bc.GetBlockByNumber(limit / 2).Hash()}, Amount: 1},
-			[]common.Hash{bc.GetBlockByNumber(limit / 2).Hash()},
-		}, {
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Amount: 1},
-			[]common.Hash{bc.GetBlockByNumber(limit / 2).Hash()},
-		},
-		// Multiple headers should be retrievable in both directions
-		{
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Amount: 3},
-			[]common.Hash{
-				bc.GetBlockByNumber(limit / 2).Hash(),
-				bc.GetBlockByNumber(limit/2 + 1).Hash(),
-				bc.GetBlockByNumber(limit/2 + 2).Hash(),
-			},
-		}, {
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Amount: 3, Reverse: true},
-			[]common.Hash{
-				bc.GetBlockByNumber(limit / 2).Hash(),
-				bc.GetBlockByNumber(limit/2 - 1).Hash(),
-				bc.GetBlockByNumber(limit/2 - 2).Hash(),
-			},
-		},
-		// Multiple headers with skip lists should be retrievable
-		{
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Skip: 3, Amount: 3},
-			[]common.Hash{
-				bc.GetBlockByNumber(limit / 2).Hash(),
-				bc.GetBlockByNumber(limit/2 + 4).Hash(),
-				bc.GetBlockByNumber(limit/2 + 8).Hash(),
-			},
-		}, {
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Skip: 3, Amount: 3, Reverse: true},
-			[]common.Hash{
-				bc.GetBlockByNumber(limit / 2).Hash(),
-				bc.GetBlockByNumber(limit/2 - 4).Hash(),
-				bc.GetBlockByNumber(limit/2 - 8).Hash(),
-			},
-		},
-		// The chain endpoints should be retrievable
-		{
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: 0}, Amount: 1},
-			[]common.Hash{bc.GetBlockByNumber(0).Hash()},
-		}, {
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: bc.CurrentBlock().Number.Uint64()}, Amount: 1},
-			[]common.Hash{bc.CurrentBlock().Hash()},
-		},
-		// Ensure protocol limits are honored
-		//{
-		//	&GetBlockHeadersData{Origin: hashOrNumber{Number: bc.CurrentBlock().Number.Uint64()() - 1}, Amount: limit + 10, Reverse: true},
-		//	[]common.Hash{},
-		//},
-		// Check that requesting more than available is handled gracefully
-		{
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: bc.CurrentBlock().Number.Uint64() - 4}, Skip: 3, Amount: 3},
-			[]common.Hash{
-				bc.GetBlockByNumber(bc.CurrentBlock().Number.Uint64() - 4).Hash(),
-				bc.GetBlockByNumber(bc.CurrentBlock().Number.Uint64()).Hash(),
-			},
-		}, {
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: 4}, Skip: 3, Amount: 3, Reverse: true},
-			[]common.Hash{
-				bc.GetBlockByNumber(4).Hash(),
-				bc.GetBlockByNumber(0).Hash(),
-			},
-		},
-		// Check that requesting more than available is handled gracefully, even if mid skip
-		{
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: bc.CurrentBlock().Number.Uint64() - 4}, Skip: 2, Amount: 3},
-			[]common.Hash{
-				bc.GetBlockByNumber(bc.CurrentBlock().Number.Uint64() - 4).Hash(),
-				bc.GetBlockByNumber(bc.CurrentBlock().Number.Uint64() - 1).Hash(),
-			},
-		}, {
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: 4}, Skip: 2, Amount: 3, Reverse: true},
-			[]common.Hash{
-				bc.GetBlockByNumber(4).Hash(),
-				bc.GetBlockByNumber(1).Hash(),
-			},
-		},
-		// Check that non existing headers aren't returned
-		{
-			&GetBlockHeadersData{Origin: hashOrNumber{Hash: unknown}, Amount: 1},
-			[]common.Hash{},
-		}, {
-			&GetBlockHeadersData{Origin: hashOrNumber{Number: bc.CurrentBlock().Number.Uint64() + 1}, Amount: 1},
-			[]common.Hash{},
-		},
-	}
-	// 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
-		for _, hash := range tt.expect {
-			headers = append(headers, bc.GetHeaderByHash(hash))
-		}
-		// Send the hash request and verify the response
-		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)
-		}
-	}
-}
-
-// Tests that block contents can be retrieved from a remote chain based on their hashes.
-func TestGetBlockBodiesLes2(t *testing.T) { testGetBlockBodies(t, 2) }
-func TestGetBlockBodiesLes3(t *testing.T) { testGetBlockBodies(t, 3) }
-func TestGetBlockBodiesLes4(t *testing.T) { testGetBlockBodies(t, 4) }
-
-func testGetBlockBodies(t *testing.T, protocol int) {
-	netconfig := testnetConfig{
-		blocks:    downloader.MaxHeaderFetch + 15,
-		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 batch of tests for various scenarios
-	limit := MaxBodyFetch
-	tests := []struct {
-		random    int           // Number of blocks to fetch randomly from the chain
-		explicit  []common.Hash // Explicitly requested blocks
-		available []bool        // Availability of explicitly requested blocks
-		expected  int           // Total number of existing blocks to expect
-	}{
-		{1, nil, nil, 1},         // A single random block should be retrievable
-		{10, nil, nil, 10},       // Multiple random blocks should be retrievable
-		{limit, nil, nil, limit}, // The maximum possible blocks should be retrievable
-		//{limit + 1, nil, nil, limit},                                  // No more than the possible block count should be returned
-		{0, []common.Hash{bc.Genesis().Hash()}, []bool{true}, 1},      // The genesis block should be retrievable
-		{0, []common.Hash{bc.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable
-		{0, []common.Hash{{}}, []bool{false}, 0},                      // A non existent block should not be returned
-
-		// Existing and non-existing blocks interleaved should not cause problems
-		{0, []common.Hash{
-			{},
-			bc.GetBlockByNumber(1).Hash(),
-			{},
-			bc.GetBlockByNumber(10).Hash(),
-			{},
-			bc.GetBlockByNumber(100).Hash(),
-			{},
-		}, []bool{false, true, false, true, false, true, false}, 3},
-	}
-	// 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++ {
-			for {
-				num := rand.Int63n(int64(bc.CurrentBlock().Number.Uint64()))
-				if !seen[num] {
-					seen[num] = true
-
-					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)
-		}
-	}
-}
-
-// Tests that the contract codes can be retrieved based on account addresses.
-func TestGetCodeLes2(t *testing.T) { testGetCode(t, 2) }
-func TestGetCodeLes3(t *testing.T) { testGetCode(t, 3) }
-func TestGetCodeLes4(t *testing.T) { testGetCode(t, 4) }
-
-func testGetCode(t *testing.T, protocol int) {
-	// Assemble the test environment
-	netconfig := testnetConfig{
-		blocks:    4,
-		protocol:  protocol,
-		nopruning: true,
-	}
-	server, _, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
-	defer closePeer()
-
-	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{
-			BHash:          header.Hash(),
-			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)
-	}
-}
-
-// Tests that the stale contract codes can't be retrieved based on account addresses.
-func TestGetStaleCodeLes2(t *testing.T) { testGetStaleCode(t, 2) }
-func TestGetStaleCodeLes3(t *testing.T) { testGetStaleCode(t, 3) }
-func TestGetStaleCodeLes4(t *testing.T) { testGetStaleCode(t, 4) }
-
-func testGetStaleCode(t *testing.T, protocol int) {
-	netconfig := testnetConfig{
-		blocks:    core.TriesInMemory + 4,
-		protocol:  protocol,
-		nopruning: true,
-	}
-	server, _, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
-	defer closePeer()
-
-	bc := server.handler.blockchain
-
-	check := func(number uint64, expected [][]byte) {
-		req := &CodeReq{
-			BHash:          bc.GetHeaderByNumber(number).Hash(),
-			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)
-		}
-	}
-	check(0, [][]byte{})                                                          // Non-exist contract
-	check(testContractDeployed, [][]byte{})                                       // Stale contract
-	check(bc.CurrentHeader().Number.Uint64(), [][]byte{testContractCodeDeployed}) // Fresh contract
-}
-
-// Tests that the transaction receipts can be retrieved based on hashes.
-func TestGetReceiptLes2(t *testing.T) { testGetReceipt(t, 2) }
-func TestGetReceiptLes3(t *testing.T) { testGetReceipt(t, 3) }
-func TestGetReceiptLes4(t *testing.T) { testGetReceipt(t, 4) }
-
-func testGetReceipt(t *testing.T, protocol int) {
-	// Assemble the test environment
-	netconfig := testnetConfig{
-		blocks:    4,
-		protocol:  protocol,
-		nopruning: true,
-	}
-	server, _, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
-	defer closePeer()
-
-	bc := server.handler.blockchain
-
-	// 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)
-
-		hashes = append(hashes, block.Hash())
-		receipts = append(receipts, rawdb.ReadReceipts(server.db, block.Hash(), block.NumberU64(), block.Time(), bc.Config()))
-	}
-	// 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)
-	}
-}
-
-// Tests that trie merkle proofs can be retrieved
-func TestGetProofsLes2(t *testing.T) { testGetProofs(t, 2) }
-func TestGetProofsLes3(t *testing.T) { testGetProofs(t, 3) }
-func TestGetProofsLes4(t *testing.T) { testGetProofs(t, 4) }
-
-func testGetProofs(t *testing.T, protocol int) {
-	// Assemble the test environment
-	netconfig := testnetConfig{
-		blocks:    4,
-		protocol:  protocol,
-		nopruning: true,
-	}
-	server, _, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
-	defer closePeer()
-
-	bc := server.handler.blockchain
-
-	var proofreqs []ProofReq
-	proofsV2 := trienode.NewProofSet()
-
-	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), server.backend.Blockchain().TrieDB())
-
-		for _, acc := range accounts {
-			req := ProofReq{
-				BHash: header.Hash(),
-				Key:   crypto.Keccak256(acc[:]),
-			}
-			proofreqs = append(proofreqs, req)
-			trie.Prove(crypto.Keccak256(acc[:]), proofsV2)
-		}
-	}
-	// Send the proof request and verify the response
-	sendRequest(rawPeer.app, GetProofsV2Msg, 42, proofreqs)
-	if err := expectResponse(rawPeer.app, ProofsV2Msg, 42, testBufLimit, proofsV2.List()); err != nil {
-		t.Errorf("proofs mismatch: %v", err)
-	}
-}
-
-// Tests that the stale contract codes can't be retrieved based on account addresses.
-func TestGetStaleProofLes2(t *testing.T) { testGetStaleProof(t, 2) }
-func TestGetStaleProofLes3(t *testing.T) { testGetStaleProof(t, 3) }
-func TestGetStaleProofLes4(t *testing.T) { testGetStaleProof(t, 4) }
-
-func testGetStaleProof(t *testing.T, protocol int) {
-	netconfig := testnetConfig{
-		blocks:    core.TriesInMemory + 4,
-		protocol:  protocol,
-		nopruning: true,
-	}
-	server, _, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
-	defer closePeer()
-
-	bc := server.handler.blockchain
-
-	check := func(number uint64, wantOK bool) {
-		var (
-			header  = bc.GetHeaderByNumber(number)
-			account = crypto.Keccak256(userAddr1.Bytes())
-		)
-		req := &ProofReq{
-			BHash: header.Hash(),
-			Key:   account,
-		}
-		sendRequest(rawPeer.app, GetProofsV2Msg, 42, []*ProofReq{req})
-
-		var expected []rlp.RawValue
-		if wantOK {
-			proofsV2 := trienode.NewProofSet()
-			t, _ := trie.New(trie.StateTrieID(header.Root), server.backend.Blockchain().TrieDB())
-			t.Prove(account, proofsV2)
-			expected = proofsV2.List()
-		}
-		if err := expectResponse(rawPeer.app, ProofsV2Msg, 42, testBufLimit, expected); err != nil {
-			t.Errorf("codes mismatch: %v", err)
-		}
-	}
-	check(0, false)                                 // Non-exist proof
-	check(2, false)                                 // Stale proof
-	check(bc.CurrentHeader().Number.Uint64(), true) // Fresh proof
-}
-
-// Tests that CHT proofs can be correctly retrieved.
-func TestGetCHTProofsLes2(t *testing.T) { testGetCHTProofs(t, 2) }
-func TestGetCHTProofsLes3(t *testing.T) { testGetCHTProofs(t, 3) }
-func TestGetCHTProofsLes4(t *testing.T) { testGetCHTProofs(t, 4) }
-
-func testGetCHTProofs(t *testing.T, protocol int) {
-	var (
-		config       = light.TestServerIndexerConfig
-		waitIndexers = func(cIndexer, bIndexer, btIndexer *core.ChainIndexer) {
-			for {
-				cs, _, _ := cIndexer.Sections()
-				if cs >= 1 {
-					break
-				}
-				time.Sleep(10 * time.Millisecond)
-			}
-		}
-		netconfig = testnetConfig{
-			blocks:    int(config.ChtSize + config.ChtConfirms),
-			protocol:  protocol,
-			indexFn:   waitIndexers,
-			nopruning: true,
-		}
-	)
-	server, _, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
-	defer closePeer()
-
-	bc := server.handler.blockchain
-
-	// Assemble the proofs from the different protocols
-	header := bc.GetHeaderByNumber(config.ChtSize - 1)
-	rlp, _ := rlp.EncodeToBytes(header)
-
-	key := make([]byte, 8)
-	binary.BigEndian.PutUint64(key, config.ChtSize-1)
-
-	proofsV2 := HelperTrieResps{
-		AuxData: [][]byte{rlp},
-	}
-	root := light.GetChtRoot(server.db, 0, bc.GetHeaderByNumber(config.ChtSize-1).Hash())
-	trie, _ := trie.New(trie.TrieID(root), trie.NewDatabase(rawdb.NewTable(server.db, string(rawdb.ChtTablePrefix)), trie.HashDefaults))
-	trie.Prove(key, &proofsV2.Proofs)
-	// Assemble the requests for the different protocols
-	requestsV2 := []HelperTrieReq{{
-		Type:    htCanonical,
-		TrieIdx: 0,
-		Key:     key,
-		AuxReq:  htAuxHeader,
-	}}
-	// 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)
-	}
-}
-
-func TestGetBloombitsProofsLes2(t *testing.T) { testGetBloombitsProofs(t, 2) }
-func TestGetBloombitsProofsLes3(t *testing.T) { testGetBloombitsProofs(t, 3) }
-func TestGetBloombitsProofsLes4(t *testing.T) { testGetBloombitsProofs(t, 4) }
-
-// Tests that bloombits proofs can be correctly retrieved.
-func testGetBloombitsProofs(t *testing.T, protocol int) {
-	var (
-		config       = light.TestServerIndexerConfig
-		waitIndexers = func(cIndexer, bIndexer, btIndexer *core.ChainIndexer) {
-			for {
-				bts, _, _ := btIndexer.Sections()
-				if bts >= 1 {
-					break
-				}
-				time.Sleep(10 * time.Millisecond)
-			}
-		}
-		netconfig = testnetConfig{
-			blocks:    int(config.BloomTrieSize + config.BloomTrieConfirms),
-			protocol:  protocol,
-			indexFn:   waitIndexers,
-			nopruning: true,
-		}
-	)
-	server, _, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
-	defer closePeer()
-
-	bc := server.handler.blockchain
-
-	// Request and verify each bit of the bloom bits proofs
-	for bit := 0; bit < 2048; bit++ {
-		// Assemble the request and proofs for the bloombits
-		key := make([]byte, 10)
-
-		binary.BigEndian.PutUint16(key[:2], uint16(bit))
-		// Only the first bloom section has data.
-		binary.BigEndian.PutUint64(key[2:], 0)
-
-		requests := []HelperTrieReq{{
-			Type:    htBloomBits,
-			TrieIdx: 0,
-			Key:     key,
-		}}
-		var proofs HelperTrieResps
-
-		root := light.GetBloomTrieRoot(server.db, 0, bc.GetHeaderByNumber(config.BloomTrieSize-1).Hash())
-		trie, _ := trie.New(trie.TrieID(root), trie.NewDatabase(rawdb.NewTable(server.db, string(rawdb.BloomTrieTablePrefix)), trie.HashDefaults))
-		trie.Prove(key, &proofs.Proofs)
-
-		// 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)
-		}
-	}
-}
-
-func TestTransactionStatusLes2(t *testing.T) { testTransactionStatus(t, lpv2) }
-func TestTransactionStatusLes3(t *testing.T) { testTransactionStatus(t, lpv3) }
-func TestTransactionStatusLes4(t *testing.T) { testTransactionStatus(t, lpv4) }
-
-func testTransactionStatus(t *testing.T, protocol int) {
-	netconfig := testnetConfig{
-		protocol:  protocol,
-		nopruning: true,
-	}
-	server, _, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
-	defer closePeer()
-
-	server.handler.addTxsSync = true
-
-	chain := server.handler.blockchain
-
-	var reqID uint64
-
-	test := func(tx *types.Transaction, send bool, expStatus light.TxStatus) {
-		t.Helper()
-
-		reqID++
-		if send {
-			sendRequest(rawPeer.app, SendTxV2Msg, reqID, types.Transactions{tx})
-		} else {
-			sendRequest(rawPeer.app, GetTxStatusMsg, reqID, []common.Hash{tx.Hash()})
-		}
-		if err := expectResponse(rawPeer.app, TxStatusMsg, reqID, testBufLimit, []light.TxStatus{expStatus}); err != nil {
-			t.Errorf("transaction status mismatch: %v", err)
-		}
-	}
-	signer := types.HomesteadSigner{}
-
-	// test error status by sending an underpriced transaction
-	tx0, _ := types.SignTx(types.NewTransaction(0, userAddr1, big.NewInt(10000), params.TxGas, nil, nil), signer, bankKey)
-	test(tx0, true, light.TxStatus{Status: txpool.TxStatusUnknown, Error: "transaction underpriced: tip needed 1, tip permitted 0"})
-
-	tx1, _ := types.SignTx(types.NewTransaction(0, userAddr1, big.NewInt(10000), params.TxGas, big.NewInt(100000000000), nil), signer, bankKey)
-	test(tx1, false, light.TxStatus{Status: txpool.TxStatusUnknown}) // query before sending, should be unknown
-	test(tx1, true, light.TxStatus{Status: txpool.TxStatusPending})  // send valid processable tx, should return pending
-	test(tx1, true, light.TxStatus{Status: txpool.TxStatusPending})  // adding it again should not return an error
-
-	tx2, _ := types.SignTx(types.NewTransaction(1, userAddr1, big.NewInt(10000), params.TxGas, big.NewInt(100000000000), nil), signer, bankKey)
-	tx3, _ := types.SignTx(types.NewTransaction(2, userAddr1, big.NewInt(10000), params.TxGas, big.NewInt(100000000000), nil), signer, bankKey)
-	// send transactions in the wrong order, tx3 should be queued
-	test(tx3, true, light.TxStatus{Status: txpool.TxStatusQueued})
-	test(tx2, true, light.TxStatus{Status: txpool.TxStatusPending})
-	// query again, now tx3 should be pending too
-	test(tx3, false, light.TxStatus{Status: txpool.TxStatusPending})
-
-	// generate and add a block with tx1 and tx2 included
-	gchain, _ := core.GenerateChain(params.TestChainConfig, chain.GetBlockByNumber(0), ethash.NewFaker(), server.db, 1, func(i int, block *core.BlockGen) {
-		block.AddTx(tx1)
-		block.AddTx(tx2)
-	})
-	if _, err := chain.InsertChain(gchain); err != nil {
-		panic(err)
-	}
-	// wait until TxPool processes the inserted block
-	for i := 0; i < 10; i++ {
-		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)
-	}
-	// Discard new block announcement
-	msg, _ := rawPeer.app.ReadMsg()
-	msg.Discard()
-
-	// 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}})
-
-	// create a reorg that rolls them back
-	gchain, _ = core.GenerateChain(params.TestChainConfig, chain.GetBlockByNumber(0), ethash.NewFaker(), server.db, 2, func(i int, block *core.BlockGen) {})
-	if _, err := chain.InsertChain(gchain); err != nil {
-		panic(err)
-	}
-	// wait until TxPool processes the reorg
-	for i := 0; i < 10; i++ {
-		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)
-	}
-	// Discard new block announcement
-	msg, _ = rawPeer.app.ReadMsg()
-	msg.Discard()
-
-	// check if their status is pending again
-	test(tx1, false, light.TxStatus{Status: txpool.TxStatusPending})
-	test(tx2, false, light.TxStatus{Status: txpool.TxStatusPending})
-}
-
-func TestStopResumeLES3(t *testing.T) { testStopResume(t, lpv3) }
-func TestStopResumeLES4(t *testing.T) { testStopResume(t, lpv4) }
-
-func testStopResume(t *testing.T, protocol int) {
-	netconfig := testnetConfig{
-		protocol:  protocol,
-		simClock:  true,
-		nopruning: true,
-	}
-	server, _, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	server.handler.server.costTracker.testing = true
-	server.handler.server.costTracker.testCostList = testCostList(testBufLimit / 10)
-
-	rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
-	defer closePeer()
-
-	var (
-		reqID    uint64
-		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)
-			}
-		}
-		// send some more requests in excess and expect a single StopMsg
-		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)
-		}
-		// wait until the buffer is recharged by half of the limit
-		wait := testBufLimit / testBufRecharge / 2
-		server.clock.(*mclock.Simulated).Run(time.Millisecond * time.Duration(wait))
-
-		// expect a ResumeMsg with the partially recharged buffer value
-		expBuf += testBufRecharge * wait
-		if err := p2p.ExpectMsg(rawPeer.app, ResumeMsg, expBuf); err != nil {
-			t.Errorf("expected ResumeMsg and failed: %v", err)
-		}
-	}
-}

les/metrics.go

@@ -1,151 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"github.com/ethereum/go-ethereum/metrics"
-	"github.com/ethereum/go-ethereum/p2p"
-)
-
-var (
-	miscInPacketsMeter           = metrics.NewRegisteredMeter("les/misc/in/packets/total", nil)
-	miscInTrafficMeter           = metrics.NewRegisteredMeter("les/misc/in/traffic/total", nil)
-	miscInHeaderPacketsMeter     = metrics.NewRegisteredMeter("les/misc/in/packets/header", nil)
-	miscInHeaderTrafficMeter     = metrics.NewRegisteredMeter("les/misc/in/traffic/header", nil)
-	miscInBodyPacketsMeter       = metrics.NewRegisteredMeter("les/misc/in/packets/body", nil)
-	miscInBodyTrafficMeter       = metrics.NewRegisteredMeter("les/misc/in/traffic/body", nil)
-	miscInCodePacketsMeter       = metrics.NewRegisteredMeter("les/misc/in/packets/code", nil)
-	miscInCodeTrafficMeter       = metrics.NewRegisteredMeter("les/misc/in/traffic/code", nil)
-	miscInReceiptPacketsMeter    = metrics.NewRegisteredMeter("les/misc/in/packets/receipt", nil)
-	miscInReceiptTrafficMeter    = metrics.NewRegisteredMeter("les/misc/in/traffic/receipt", nil)
-	miscInTrieProofPacketsMeter  = metrics.NewRegisteredMeter("les/misc/in/packets/proof", nil)
-	miscInTrieProofTrafficMeter  = metrics.NewRegisteredMeter("les/misc/in/traffic/proof", nil)
-	miscInHelperTriePacketsMeter = metrics.NewRegisteredMeter("les/misc/in/packets/helperTrie", nil)
-	miscInHelperTrieTrafficMeter = metrics.NewRegisteredMeter("les/misc/in/traffic/helperTrie", nil)
-	miscInTxsPacketsMeter        = metrics.NewRegisteredMeter("les/misc/in/packets/txs", nil)
-	miscInTxsTrafficMeter        = metrics.NewRegisteredMeter("les/misc/in/traffic/txs", nil)
-	miscInTxStatusPacketsMeter   = metrics.NewRegisteredMeter("les/misc/in/packets/txStatus", nil)
-	miscInTxStatusTrafficMeter   = metrics.NewRegisteredMeter("les/misc/in/traffic/txStatus", nil)
-
-	miscOutPacketsMeter           = metrics.NewRegisteredMeter("les/misc/out/packets/total", nil)
-	miscOutTrafficMeter           = metrics.NewRegisteredMeter("les/misc/out/traffic/total", nil)
-	miscOutHeaderPacketsMeter     = metrics.NewRegisteredMeter("les/misc/out/packets/header", nil)
-	miscOutHeaderTrafficMeter     = metrics.NewRegisteredMeter("les/misc/out/traffic/header", nil)
-	miscOutBodyPacketsMeter       = metrics.NewRegisteredMeter("les/misc/out/packets/body", nil)
-	miscOutBodyTrafficMeter       = metrics.NewRegisteredMeter("les/misc/out/traffic/body", nil)
-	miscOutCodePacketsMeter       = metrics.NewRegisteredMeter("les/misc/out/packets/code", nil)
-	miscOutCodeTrafficMeter       = metrics.NewRegisteredMeter("les/misc/out/traffic/code", nil)
-	miscOutReceiptPacketsMeter    = metrics.NewRegisteredMeter("les/misc/out/packets/receipt", nil)
-	miscOutReceiptTrafficMeter    = metrics.NewRegisteredMeter("les/misc/out/traffic/receipt", nil)
-	miscOutTrieProofPacketsMeter  = metrics.NewRegisteredMeter("les/misc/out/packets/proof", nil)
-	miscOutTrieProofTrafficMeter  = metrics.NewRegisteredMeter("les/misc/out/traffic/proof", nil)
-	miscOutHelperTriePacketsMeter = metrics.NewRegisteredMeter("les/misc/out/packets/helperTrie", nil)
-	miscOutHelperTrieTrafficMeter = metrics.NewRegisteredMeter("les/misc/out/traffic/helperTrie", nil)
-	miscOutTxsPacketsMeter        = metrics.NewRegisteredMeter("les/misc/out/packets/txs", nil)
-	miscOutTxsTrafficMeter        = metrics.NewRegisteredMeter("les/misc/out/traffic/txs", nil)
-	miscOutTxStatusPacketsMeter   = metrics.NewRegisteredMeter("les/misc/out/packets/txStatus", nil)
-	miscOutTxStatusTrafficMeter   = metrics.NewRegisteredMeter("les/misc/out/traffic/txStatus", nil)
-
-	miscServingTimeHeaderTimer     = metrics.NewRegisteredTimer("les/misc/serve/header", nil)
-	miscServingTimeBodyTimer       = metrics.NewRegisteredTimer("les/misc/serve/body", nil)
-	miscServingTimeCodeTimer       = metrics.NewRegisteredTimer("les/misc/serve/code", nil)
-	miscServingTimeReceiptTimer    = metrics.NewRegisteredTimer("les/misc/serve/receipt", nil)
-	miscServingTimeTrieProofTimer  = metrics.NewRegisteredTimer("les/misc/serve/proof", nil)
-	miscServingTimeHelperTrieTimer = metrics.NewRegisteredTimer("les/misc/serve/helperTrie", nil)
-	miscServingTimeTxTimer         = metrics.NewRegisteredTimer("les/misc/serve/txs", nil)
-	miscServingTimeTxStatusTimer   = metrics.NewRegisteredTimer("les/misc/serve/txStatus", nil)
-
-	connectionTimer       = metrics.NewRegisteredTimer("les/connection/duration", nil)
-	serverConnectionGauge = metrics.NewRegisteredGauge("les/connection/server", nil)
-
-	totalCapacityGauge   = metrics.NewRegisteredGauge("les/server/totalCapacity", nil)
-	totalRechargeGauge   = metrics.NewRegisteredGauge("les/server/totalRecharge", nil)
-	blockProcessingTimer = metrics.NewRegisteredTimer("les/server/blockProcessingTime", nil)
-
-	requestServedMeter               = metrics.NewRegisteredMeter("les/server/req/avgServedTime", nil)
-	requestServedTimer               = metrics.NewRegisteredTimer("les/server/req/servedTime", nil)
-	requestEstimatedMeter            = metrics.NewRegisteredMeter("les/server/req/avgEstimatedTime", nil)
-	requestEstimatedTimer            = metrics.NewRegisteredTimer("les/server/req/estimatedTime", nil)
-	relativeCostHistogram            = metrics.NewRegisteredHistogram("les/server/req/relative", nil, metrics.NewExpDecaySample(1028, 0.015))
-	relativeCostHeaderHistogram      = metrics.NewRegisteredHistogram("les/server/req/relative/header", nil, metrics.NewExpDecaySample(1028, 0.015))
-	relativeCostBodyHistogram        = metrics.NewRegisteredHistogram("les/server/req/relative/body", nil, metrics.NewExpDecaySample(1028, 0.015))
-	relativeCostReceiptHistogram     = metrics.NewRegisteredHistogram("les/server/req/relative/receipt", nil, metrics.NewExpDecaySample(1028, 0.015))
-	relativeCostCodeHistogram        = metrics.NewRegisteredHistogram("les/server/req/relative/code", nil, metrics.NewExpDecaySample(1028, 0.015))
-	relativeCostProofHistogram       = metrics.NewRegisteredHistogram("les/server/req/relative/proof", nil, metrics.NewExpDecaySample(1028, 0.015))
-	relativeCostHelperProofHistogram = metrics.NewRegisteredHistogram("les/server/req/relative/helperTrie", nil, metrics.NewExpDecaySample(1028, 0.015))
-	relativeCostSendTxHistogram      = metrics.NewRegisteredHistogram("les/server/req/relative/txs", nil, metrics.NewExpDecaySample(1028, 0.015))
-	relativeCostTxStatusHistogram    = metrics.NewRegisteredHistogram("les/server/req/relative/txStatus", nil, metrics.NewExpDecaySample(1028, 0.015))
-
-	globalFactorGauge    = metrics.NewRegisteredGauge("les/server/globalFactor", nil)
-	recentServedGauge    = metrics.NewRegisteredGauge("les/server/recentRequestServed", nil)
-	recentEstimatedGauge = metrics.NewRegisteredGauge("les/server/recentRequestEstimated", nil)
-	sqServedGauge        = metrics.NewRegisteredGauge("les/server/servingQueue/served", nil)
-	sqQueuedGauge        = metrics.NewRegisteredGauge("les/server/servingQueue/queued", nil)
-
-	clientFreezeMeter = metrics.NewRegisteredMeter("les/server/clientEvent/freeze", nil)
-	clientErrorMeter  = metrics.NewRegisteredMeter("les/server/clientEvent/error", nil)
-
-	requestRTT       = metrics.NewRegisteredTimer("les/client/req/rtt", nil)
-	requestSendDelay = metrics.NewRegisteredTimer("les/client/req/sendDelay", nil)
-
-	serverSelectableGauge = metrics.NewRegisteredGauge("les/client/serverPool/selectable", nil)
-	serverDialedMeter     = metrics.NewRegisteredMeter("les/client/serverPool/dialed", nil)
-	serverConnectedGauge  = metrics.NewRegisteredGauge("les/client/serverPool/connected", nil)
-	sessionValueMeter     = metrics.NewRegisteredMeter("les/client/serverPool/sessionValue", nil)
-	totalValueGauge       = metrics.NewRegisteredGauge("les/client/serverPool/totalValue", nil)
-	suggestedTimeoutGauge = metrics.NewRegisteredGauge("les/client/serverPool/timeout", nil)
-)
-
-// meteredMsgReadWriter is a wrapper around a p2p.MsgReadWriter, capable of
-// accumulating the above defined metrics based on the data stream contents.
-type meteredMsgReadWriter struct {
-	p2p.MsgReadWriter     // Wrapped message stream to meter
-	version           int // Protocol version to select correct meters
-}
-
-// newMeteredMsgWriter wraps a p2p MsgReadWriter with metering support. If the
-// metrics system is disabled, this function returns the original object.
-func newMeteredMsgWriter(rw p2p.MsgReadWriter, version int) p2p.MsgReadWriter {
-	if !metrics.Enabled {
-		return rw
-	}
-	return &meteredMsgReadWriter{MsgReadWriter: rw, version: version}
-}
-
-func (rw *meteredMsgReadWriter) ReadMsg() (p2p.Msg, error) {
-	// Read the message and short circuit in case of an error
-	msg, err := rw.MsgReadWriter.ReadMsg()
-	if err != nil {
-		return msg, err
-	}
-	// Account for the data traffic
-	packets, traffic := miscInPacketsMeter, miscInTrafficMeter
-	packets.Mark(1)
-	traffic.Mark(int64(msg.Size))
-
-	return msg, err
-}
-
-func (rw *meteredMsgReadWriter) WriteMsg(msg p2p.Msg) error {
-	// Account for the data traffic
-	packets, traffic := miscOutPacketsMeter, miscOutTrafficMeter
-	packets.Mark(1)
-	traffic.Mark(int64(msg.Size))
-
-	// Send the packet to the p2p layer
-	return rw.MsgReadWriter.WriteMsg(msg)
-}

les/odr.go

@@ -1,237 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"context"
-	"math/rand"
-	"sort"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/txpool"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/light"
-)
-
-// LesOdr implements light.OdrBackend
-type LesOdr struct {
-	db                                         ethdb.Database
-	indexerConfig                              *light.IndexerConfig
-	chtIndexer, bloomTrieIndexer, bloomIndexer *core.ChainIndexer
-	peers                                      *serverPeerSet
-	retriever                                  *retrieveManager
-	stop                                       chan struct{}
-}
-
-func NewLesOdr(db ethdb.Database, config *light.IndexerConfig, peers *serverPeerSet, retriever *retrieveManager) *LesOdr {
-	return &LesOdr{
-		db:            db,
-		indexerConfig: config,
-		peers:         peers,
-		retriever:     retriever,
-		stop:          make(chan struct{}),
-	}
-}
-
-// Stop cancels all pending retrievals
-func (odr *LesOdr) Stop() {
-	close(odr.stop)
-}
-
-// Database returns the backing database
-func (odr *LesOdr) Database() ethdb.Database {
-	return odr.db
-}
-
-// SetIndexers adds the necessary chain indexers to the ODR backend
-func (odr *LesOdr) SetIndexers(chtIndexer, bloomTrieIndexer, bloomIndexer *core.ChainIndexer) {
-	odr.chtIndexer = chtIndexer
-	odr.bloomTrieIndexer = bloomTrieIndexer
-	odr.bloomIndexer = bloomIndexer
-}
-
-// ChtIndexer returns the CHT chain indexer
-func (odr *LesOdr) ChtIndexer() *core.ChainIndexer {
-	return odr.chtIndexer
-}
-
-// BloomTrieIndexer returns the bloom trie chain indexer
-func (odr *LesOdr) BloomTrieIndexer() *core.ChainIndexer {
-	return odr.bloomTrieIndexer
-}
-
-// BloomIndexer returns the bloombits chain indexer
-func (odr *LesOdr) BloomIndexer() *core.ChainIndexer {
-	return odr.bloomIndexer
-}
-
-// IndexerConfig returns the indexer config.
-func (odr *LesOdr) IndexerConfig() *light.IndexerConfig {
-	return odr.indexerConfig
-}
-
-const (
-	MsgBlockHeaders = iota
-	MsgBlockBodies
-	MsgCode
-	MsgReceipts
-	MsgProofsV2
-	MsgHelperTrieProofs
-	MsgTxStatus
-)
-
-// Msg encodes a LES message that delivers reply data for a request
-type Msg struct {
-	MsgType int
-	ReqID   uint64
-	Obj     interface{}
-}
-
-// peerByTxHistory is a heap.Interface implementation which can sort
-// the peerset by transaction history.
-type peerByTxHistory []*serverPeer
-
-func (h peerByTxHistory) Len() int { return len(h) }
-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] }
-
-const (
-	maxTxStatusRetry      = 3 // The maximum retries will be made for tx status request.
-	maxTxStatusCandidates = 5 // The maximum les servers the tx status requests will be sent to.
-)
-
-// RetrieveTxStatus retrieves the transaction status from the LES network.
-// There is no guarantee in the LES protocol that the mined transaction will
-// be retrieved back for sure because of different reasons(the transaction
-// is unindexed, the malicious server doesn't reply it deliberately, etc).
-// Therefore, unretrieved transactions(UNKNOWN) will receive a certain number
-// of retries, thus giving a weak guarantee.
-func (odr *LesOdr) RetrieveTxStatus(ctx context.Context, req *light.TxStatusRequest) error {
-	// Sort according to the transaction history supported by the peer and
-	// select the peers with longest history.
-	var (
-		retries int
-		peers   []*serverPeer
-		missing = len(req.Hashes)
-		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
-	}
-	// Send out the request and assemble the result.
-	for {
-		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}
-			id      = rand.Uint64()
-			distreq = &distReq{
-				getCost: func(dp distPeer) uint64 { return req.GetCost(dp.(*serverPeer)) },
-				canSend: func(dp distPeer) bool { return canSend[dp.(*serverPeer).id] },
-				request: func(dp distPeer) func() {
-					p := dp.(*serverPeer)
-					p.fcServer.QueuedRequest(id, req.GetCost(p))
-					delete(canSend, p.id)
-					return func() { req.Request(id, p) }
-				},
-			}
-		)
-		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
-		}
-		// Collect the response and assemble them to the final result.
-		// All the response is not verifiable, so always pick the first
-		// one we get.
-		for index, status := range req.Status {
-			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
-}
-
-// Retrieve tries to fetch an object from the LES network. It's a common API
-// for most of the LES requests except for the TxStatusRequest which needs
-// the additional retry mechanism.
-// If the network retrieval was successful, it stores the object in local db.
-func (odr *LesOdr) Retrieve(ctx context.Context, req light.OdrRequest) (err error) {
-	lreq := LesRequest(req)
-
-	reqID := rand.Uint64()
-	rq := &distReq{
-		getCost: func(dp distPeer) uint64 {
-			return lreq.GetCost(dp.(*serverPeer))
-		},
-		canSend: func(dp distPeer) bool {
-			p := dp.(*serverPeer)
-			if !p.onlyAnnounce {
-				return lreq.CanSend(p)
-			}
-			return false
-		},
-		request: func(dp distPeer) func() {
-			p := dp.(*serverPeer)
-			cost := lreq.GetCost(p)
-			p.fcServer.QueuedRequest(reqID, cost)
-			return func() { lreq.Request(reqID, p) }
-		},
-	}
-
-	defer func(sent mclock.AbsTime) {
-		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

@@ -1,537 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"encoding/binary"
-	"errors"
-	"fmt"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/ethereum/go-ethereum/trie"
-	"github.com/ethereum/go-ethereum/trie/trienode"
-)
-
-var (
-	errInvalidMessageType  = errors.New("invalid message type")
-	errInvalidEntryCount   = errors.New("invalid number of response entries")
-	errHeaderUnavailable   = errors.New("header unavailable")
-	errTxHashMismatch      = errors.New("transaction hash mismatch")
-	errUncleHashMismatch   = errors.New("uncle hash mismatch")
-	errReceiptHashMismatch = errors.New("receipt hash mismatch")
-	errDataHashMismatch    = errors.New("data hash mismatch")
-	errCHTHashMismatch     = errors.New("cht hash mismatch")
-	errCHTNumberMismatch   = errors.New("cht number mismatch")
-	errUselessNodes        = errors.New("useless nodes in merkle proof nodeset")
-)
-
-type LesOdrRequest interface {
-	GetCost(*serverPeer) uint64
-	CanSend(*serverPeer) bool
-	Request(uint64, *serverPeer) error
-	Validate(ethdb.Database, *Msg) error
-}
-
-func LesRequest(req light.OdrRequest) LesOdrRequest {
-	switch r := req.(type) {
-	case *light.BlockRequest:
-		return (*BlockRequest)(r)
-	case *light.ReceiptsRequest:
-		return (*ReceiptsRequest)(r)
-	case *light.TrieRequest:
-		return (*TrieRequest)(r)
-	case *light.CodeRequest:
-		return (*CodeRequest)(r)
-	case *light.ChtRequest:
-		return (*ChtRequest)(r)
-	case *light.BloomRequest:
-		return (*BloomRequest)(r)
-	case *light.TxStatusRequest:
-		return (*TxStatusRequest)(r)
-	default:
-		return nil
-	}
-}
-
-// BlockRequest is the ODR request type for block bodies
-type BlockRequest light.BlockRequest
-
-// GetCost returns the cost of the given ODR request according to the serving
-// peer's cost table (implementation of LesOdrRequest)
-func (r *BlockRequest) GetCost(peer *serverPeer) uint64 {
-	return peer.getRequestCost(GetBlockBodiesMsg, 1)
-}
-
-// CanSend tells if a certain peer is suitable for serving the given request
-func (r *BlockRequest) CanSend(peer *serverPeer) bool {
-	return peer.HasBlock(r.Hash, r.Number, false)
-}
-
-// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
-func (r *BlockRequest) Request(reqID uint64, peer *serverPeer) error {
-	peer.Log().Debug("Requesting block body", "hash", r.Hash)
-	return peer.requestBodies(reqID, []common.Hash{r.Hash})
-}
-
-// Validate processes an ODR request reply message from the LES network
-// returns true and stores results in memory if the message was a valid reply
-// to the request (implementation of LesOdrRequest)
-func (r *BlockRequest) Validate(db ethdb.Database, msg *Msg) error {
-	log.Debug("Validating block body", "hash", r.Hash)
-
-	// Ensure we have a correct message with a single block body
-	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
-	}
-	// Validations passed, encode and store RLP
-	data, err := rlp.EncodeToBytes(body)
-	if err != nil {
-		return err
-	}
-	r.Rlp = data
-	return nil
-}
-
-// ReceiptsRequest is the ODR request type for block receipts by block hash
-type ReceiptsRequest light.ReceiptsRequest
-
-// GetCost returns the cost of the given ODR request according to the serving
-// peer's cost table (implementation of LesOdrRequest)
-func (r *ReceiptsRequest) GetCost(peer *serverPeer) uint64 {
-	return peer.getRequestCost(GetReceiptsMsg, 1)
-}
-
-// CanSend tells if a certain peer is suitable for serving the given request
-func (r *ReceiptsRequest) CanSend(peer *serverPeer) bool {
-	return peer.HasBlock(r.Hash, r.Number, false)
-}
-
-// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
-func (r *ReceiptsRequest) Request(reqID uint64, peer *serverPeer) error {
-	peer.Log().Debug("Requesting block receipts", "hash", r.Hash)
-	return peer.requestReceipts(reqID, []common.Hash{r.Hash})
-}
-
-// Validate processes an ODR request reply message from the LES network
-// returns true and stores results in memory if the message was a valid reply
-// to the request (implementation of LesOdrRequest)
-func (r *ReceiptsRequest) Validate(db ethdb.Database, msg *Msg) error {
-	log.Debug("Validating block receipts", "hash", r.Hash)
-
-	// Ensure we have a correct message with a single block receipt
-	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
-}
-
-type ProofReq struct {
-	BHash               common.Hash
-	AccountAddress, Key []byte
-	FromLevel           uint
-}
-
-// ODR request type for state/storage trie entries, see LesOdrRequest interface
-type TrieRequest light.TrieRequest
-
-// GetCost returns the cost of the given ODR request according to the serving
-// peer's cost table (implementation of LesOdrRequest)
-func (r *TrieRequest) GetCost(peer *serverPeer) uint64 {
-	return peer.getRequestCost(GetProofsV2Msg, 1)
-}
-
-// CanSend tells if a certain peer is suitable for serving the given request
-func (r *TrieRequest) CanSend(peer *serverPeer) bool {
-	return peer.HasBlock(r.Id.BlockHash, r.Id.BlockNumber, true)
-}
-
-// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
-func (r *TrieRequest) Request(reqID uint64, peer *serverPeer) error {
-	peer.Log().Debug("Requesting trie proof", "root", r.Id.Root, "key", r.Key)
-	req := ProofReq{
-		BHash:          r.Id.BlockHash,
-		AccountAddress: r.Id.AccountAddress,
-		Key:            r.Key,
-	}
-	return peer.requestProofs(reqID, []ProofReq{req})
-}
-
-// Validate processes an ODR request reply message from the LES network
-// returns true and stores results in memory if the message was a valid reply
-// to the request (implementation of LesOdrRequest)
-func (r *TrieRequest) Validate(db ethdb.Database, msg *Msg) error {
-	log.Debug("Validating trie proof", "root", r.Id.Root, "key", r.Key)
-
-	if msg.MsgType != MsgProofsV2 {
-		return errInvalidMessageType
-	}
-	proofs := msg.Obj.(trienode.ProofList)
-	// Verify the proof and store if checks out
-	nodeSet := proofs.Set()
-	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)
-	}
-	// check if all nodes have been read by VerifyProof
-	if len(reads.reads) != nodeSet.KeyCount() {
-		return errUselessNodes
-	}
-	r.Proof = nodeSet
-	return nil
-}
-
-type CodeReq struct {
-	BHash          common.Hash
-	AccountAddress []byte
-}
-
-// CodeRequest is the ODR request type for node data (used for retrieving contract code), see LesOdrRequest interface
-type CodeRequest light.CodeRequest
-
-// GetCost returns the cost of the given ODR request according to the serving
-// peer's cost table (implementation of LesOdrRequest)
-func (r *CodeRequest) GetCost(peer *serverPeer) uint64 {
-	return peer.getRequestCost(GetCodeMsg, 1)
-}
-
-// CanSend tells if a certain peer is suitable for serving the given request
-func (r *CodeRequest) CanSend(peer *serverPeer) bool {
-	return peer.HasBlock(r.Id.BlockHash, r.Id.BlockNumber, true)
-}
-
-// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
-func (r *CodeRequest) Request(reqID uint64, peer *serverPeer) error {
-	peer.Log().Debug("Requesting code data", "hash", r.Hash)
-	req := CodeReq{
-		BHash:          r.Id.BlockHash,
-		AccountAddress: r.Id.AccountAddress,
-	}
-	return peer.requestCode(reqID, []CodeReq{req})
-}
-
-// Validate processes an ODR request reply message from the LES network
-// returns true and stores results in memory if the message was a valid reply
-// to the request (implementation of LesOdrRequest)
-func (r *CodeRequest) Validate(db ethdb.Database, msg *Msg) error {
-	log.Debug("Validating code data", "hash", r.Hash)
-
-	// Ensure we have a correct message with a single code element
-	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
-}
-
-const (
-	// helper trie type constants
-	htCanonical = iota // Canonical hash trie
-	htBloomBits        // BloomBits trie
-
-	// helper trie auxiliary types
-	// htAuxNone = 1 ; deprecated number, used in les2/3 previously.
-	htAuxHeader = 2 // applicable for htCanonical, requests for relevant headers
-)
-
-type HelperTrieReq struct {
-	Type              uint
-	TrieIdx           uint64
-	Key               []byte
-	FromLevel, AuxReq uint
-}
-
-type HelperTrieResps struct { // describes all responses, not just a single one
-	Proofs  trienode.ProofList
-	AuxData [][]byte
-}
-
-// ChtRequest is the ODR request type for requesting headers by Canonical Hash Trie, see LesOdrRequest interface
-type ChtRequest light.ChtRequest
-
-// GetCost returns the cost of the given ODR request according to the serving
-// peer's cost table (implementation of LesOdrRequest)
-func (r *ChtRequest) GetCost(peer *serverPeer) uint64 {
-	return peer.getRequestCost(GetHelperTrieProofsMsg, 1)
-}
-
-// CanSend tells if a certain peer is suitable for serving the given request
-func (r *ChtRequest) CanSend(peer *serverPeer) bool {
-	peer.lock.RLock()
-	defer peer.lock.RUnlock()
-
-	return peer.headInfo.Number >= r.Config.ChtConfirms && r.ChtNum <= (peer.headInfo.Number-r.Config.ChtConfirms)/r.Config.ChtSize
-}
-
-// 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,
-		TrieIdx: r.ChtNum,
-		Key:     encNum[:],
-		AuxReq:  htAuxHeader,
-	}
-	return peer.requestHelperTrieProofs(reqID, []HelperTrieReq{req})
-}
-
-// Validate processes an ODR request reply message from the LES network
-// returns true and stores results in memory if the message was a valid reply
-// to the request (implementation of LesOdrRequest)
-func (r *ChtRequest) Validate(db ethdb.Database, msg *Msg) error {
-	log.Debug("Validating CHT", "cht", r.ChtNum, "block", r.BlockNum)
-
-	if msg.MsgType != MsgHelperTrieProofs {
-		return errInvalidMessageType
-	}
-	resp := msg.Obj.(HelperTrieResps)
-	if len(resp.AuxData) != 1 {
-		return errInvalidEntryCount
-	}
-	nodeSet := resp.Proofs.Set()
-	headerEnc := resp.AuxData[0]
-	if len(headerEnc) == 0 {
-		return errHeaderUnavailable
-	}
-	header := new(types.Header)
-	if err := rlp.DecodeBytes(headerEnc, header); err != nil {
-		return errHeaderUnavailable
-	}
-	// Verify the CHT
-	var (
-		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
-	}
-	// Verifications passed, store and return
-	r.Header = header
-	r.Proof = nodeSet
-	r.Td = node.Td
-	return nil
-}
-
-type BloomReq struct {
-	BloomTrieNum, BitIdx, SectionIndex, FromLevel uint64
-}
-
-// BloomRequest is the ODR request type for requesting headers by Canonical Hash Trie, see LesOdrRequest interface
-type BloomRequest light.BloomRequest
-
-// GetCost returns the cost of the given ODR request according to the serving
-// peer's cost table (implementation of LesOdrRequest)
-func (r *BloomRequest) GetCost(peer *serverPeer) uint64 {
-	return peer.getRequestCost(GetHelperTrieProofsMsg, len(r.SectionIndexList))
-}
-
-// CanSend tells if a certain peer is suitable for serving the given request
-func (r *BloomRequest) CanSend(peer *serverPeer) bool {
-	peer.lock.RLock()
-	defer peer.lock.RUnlock()
-
-	if peer.version < lpv2 {
-		return false
-	}
-	return peer.headInfo.Number >= r.Config.BloomTrieConfirms && r.BloomTrieNum <= (peer.headInfo.Number-r.Config.BloomTrieConfirms)/r.Config.BloomTrieSize
-}
-
-// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
-func (r *BloomRequest) Request(reqID uint64, peer *serverPeer) error {
-	peer.Log().Debug("Requesting BloomBits", "bloomTrie", r.BloomTrieNum, "bitIdx", r.BitIdx, "sections", r.SectionIndexList)
-	reqs := make([]HelperTrieReq, len(r.SectionIndexList))
-
-	var encNumber [10]byte
-	binary.BigEndian.PutUint16(encNumber[:2], uint16(r.BitIdx))
-
-	for i, sectionIdx := range r.SectionIndexList {
-		binary.BigEndian.PutUint64(encNumber[2:], sectionIdx)
-		reqs[i] = HelperTrieReq{
-			Type:    htBloomBits,
-			TrieIdx: r.BloomTrieNum,
-			Key:     common.CopyBytes(encNumber[:]),
-		}
-	}
-	return peer.requestHelperTrieProofs(reqID, reqs)
-}
-
-// Validate processes an ODR request reply message from the LES network
-// returns true and stores results in memory if the message was a valid reply
-// to the request (implementation of LesOdrRequest)
-func (r *BloomRequest) Validate(db ethdb.Database, msg *Msg) error {
-	log.Debug("Validating BloomBits", "bloomTrie", r.BloomTrieNum, "bitIdx", r.BitIdx, "sections", r.SectionIndexList)
-
-	// Ensure we have a correct message with a single proof element
-	if msg.MsgType != MsgHelperTrieProofs {
-		return errInvalidMessageType
-	}
-	resps := msg.Obj.(HelperTrieResps)
-	proofs := resps.Proofs
-	nodeSet := proofs.Set()
-	reads := &readTraceDB{db: nodeSet}
-
-	r.BloomBits = make([][]byte, len(r.SectionIndexList))
-
-	// 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
-}
-
-// TxStatusRequest is the ODR request type for transaction status
-type TxStatusRequest light.TxStatusRequest
-
-// GetCost returns the cost of the given ODR request according to the serving
-// peer's cost table (implementation of LesOdrRequest)
-func (r *TxStatusRequest) GetCost(peer *serverPeer) uint64 {
-	return peer.getRequestCost(GetTxStatusMsg, len(r.Hashes))
-}
-
-// CanSend tells if a certain peer is suitable for serving the given request
-func (r *TxStatusRequest) CanSend(peer *serverPeer) bool {
-	return peer.txHistory != txIndexDisabled
-}
-
-// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
-func (r *TxStatusRequest) Request(reqID uint64, peer *serverPeer) error {
-	peer.Log().Debug("Requesting transaction status", "count", len(r.Hashes))
-	return peer.requestTxStatus(reqID, r.Hashes)
-}
-
-// Validate processes an ODR request reply message from the LES network
-// returns true and stores results in memory if the message was a valid reply
-// to the request (implementation of LesOdrRequest)
-func (r *TxStatusRequest) Validate(db ethdb.Database, msg *Msg) error {
-	log.Debug("Validating transaction status", "count", len(r.Hashes))
-
-	if msg.MsgType != MsgTxStatus {
-		return errInvalidMessageType
-	}
-	status := msg.Obj.([]light.TxStatus)
-	if len(status) != len(r.Hashes) {
-		return errInvalidEntryCount
-	}
-	r.Status = status
-	return nil
-}
-
-// readTraceDB stores the keys of database reads. We use this to check that received node
-// sets contain only the trie nodes necessary to make proofs pass.
-type readTraceDB struct {
-	db    ethdb.KeyValueReader
-	reads map[string]struct{}
-}
-
-// Get returns a stored node
-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)
-}
-
-// Has returns true if the node set contains the given key
-func (db *readTraceDB) Has(key []byte) (bool, error) {
-	_, err := db.Get(key)
-	return err == nil, nil
-}

les/odr_test.go

@@ -1,458 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-// Note: these tests are disabled now because they cannot work with the old sync
-// mechanism removed but will be useful again once the PoS ultralight mode is implemented
-
-/*
-import (
-	"bytes"
-	"context"
-	"crypto/rand"
-	"fmt"
-	"math/big"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/math"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/state"
-	"github.com/ethereum/go-ethereum/core/txpool"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-type odrTestFn func(ctx context.Context, db ethdb.Database, config *params.ChainConfig, bc *core.BlockChain, lc *light.LightChain, bhash common.Hash) []byte
-
-func TestOdrGetBlockLes2(t *testing.T) { testOdr(t, 2, 1, true, odrGetBlock) }
-func TestOdrGetBlockLes3(t *testing.T) { testOdr(t, 3, 1, true, odrGetBlock) }
-func TestOdrGetBlockLes4(t *testing.T) { testOdr(t, 4, 1, true, odrGetBlock) }
-
-func odrGetBlock(ctx context.Context, db ethdb.Database, config *params.ChainConfig, bc *core.BlockChain, lc *light.LightChain, bhash common.Hash) []byte {
-	var block *types.Block
-	if bc != nil {
-		block = bc.GetBlockByHash(bhash)
-	} else {
-		block, _ = lc.GetBlockByHash(ctx, bhash)
-	}
-	if block == nil {
-		return nil
-	}
-	rlp, _ := rlp.EncodeToBytes(block)
-	return rlp
-}
-
-func TestOdrGetReceiptsLes2(t *testing.T) { testOdr(t, 2, 1, true, odrGetReceipts) }
-func TestOdrGetReceiptsLes3(t *testing.T) { testOdr(t, 3, 1, true, odrGetReceipts) }
-func TestOdrGetReceiptsLes4(t *testing.T) { testOdr(t, 4, 1, true, odrGetReceipts) }
-
-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 {
-				receipts = rawdb.ReadReceipts(db, bhash, *number, header.Time, config)
-			}
-		}
-	} else {
-		if number := rawdb.ReadHeaderNumber(db, bhash); number != nil {
-			receipts, _ = light.GetBlockReceipts(ctx, lc.Odr(), bhash, *number)
-		}
-	}
-	if receipts == nil {
-		return nil
-	}
-	rlp, _ := rlp.EncodeToBytes(receipts)
-	return rlp
-}
-
-func TestOdrAccountsLes2(t *testing.T) { testOdr(t, 2, 1, true, odrAccounts) }
-func TestOdrAccountsLes3(t *testing.T) { testOdr(t, 3, 1, true, odrAccounts) }
-func TestOdrAccountsLes4(t *testing.T) { testOdr(t, 4, 1, true, odrAccounts) }
-
-func odrAccounts(ctx context.Context, db ethdb.Database, config *params.ChainConfig, bc *core.BlockChain, lc *light.LightChain, bhash common.Hash) []byte {
-	dummyAddr := common.HexToAddress("1234567812345678123456781234567812345678")
-	acc := []common.Address{bankAddr, userAddr1, userAddr2, dummyAddr}
-
-	var (
-		res []byte
-		st  *state.StateDB
-		err error
-	)
-	for _, addr := range acc {
-		if bc != nil {
-			header := bc.GetHeaderByHash(bhash)
-			st, err = state.New(header.Root, bc.StateCache(), nil)
-		} else {
-			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
-}
-
-func TestOdrContractCallLes2(t *testing.T) { testOdr(t, 2, 2, true, odrContractCall) }
-func TestOdrContractCallLes3(t *testing.T) { testOdr(t, 3, 2, true, odrContractCall) }
-func TestOdrContractCallLes4(t *testing.T) { testOdr(t, 4, 2, true, odrContractCall) }
-
-func odrContractCall(ctx context.Context, db ethdb.Database, config *params.ChainConfig, bc *core.BlockChain, lc *light.LightChain, bhash common.Hash) []byte {
-	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)
-
-			if err == nil {
-				from := statedb.GetOrNewStateObject(bankAddr)
-				from.SetBalance(math.MaxBig256)
-
-				msg := &core.Message{
-					From:              from.Address(),
-					To:                &testContractAddr,
-					Value:             new(big.Int),
-					GasLimit:          100000,
-					GasPrice:          big.NewInt(params.InitialBaseFee),
-					GasFeeCap:         big.NewInt(params.InitialBaseFee),
-					GasTipCap:         new(big.Int),
-					Data:              data,
-					SkipAccountChecks: true,
-				}
-
-				context := core.NewEVMBlockContext(header, bc, nil)
-				txContext := core.NewEVMTxContext(msg)
-				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)
-				result, _ := core.ApplyMessage(vmenv, msg, gp)
-				res = append(res, result.Return()...)
-			}
-		} else {
-			header := lc.GetHeaderByHash(bhash)
-			state := light.NewState(ctx, header, lc.Odr())
-			state.SetBalance(bankAddr, math.MaxBig256)
-			msg := &core.Message{
-				From:              bankAddr,
-				To:                &testContractAddr,
-				Value:             new(big.Int),
-				GasLimit:          100000,
-				GasPrice:          big.NewInt(params.InitialBaseFee),
-				GasFeeCap:         big.NewInt(params.InitialBaseFee),
-				GasTipCap:         new(big.Int),
-				Data:              data,
-				SkipAccountChecks: true,
-			}
-			context := core.NewEVMBlockContext(header, lc, nil)
-			txContext := core.NewEVMTxContext(msg)
-			vmenv := vm.NewEVM(context, txContext, state, config, vm.Config{NoBaseFee: true})
-			gp := new(core.GasPool).AddGas(math.MaxUint64)
-			result, _ := core.ApplyMessage(vmenv, msg, gp)
-			if state.Error() == nil {
-				res = append(res, result.Return()...)
-			}
-		}
-	}
-	return res
-}
-
-func TestOdrTxStatusLes2(t *testing.T) { testOdr(t, 2, 1, false, odrTxStatus) }
-func TestOdrTxStatusLes3(t *testing.T) { testOdr(t, 3, 1, false, odrTxStatus) }
-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()
-	} else {
-		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
-				}
-			}
-		}
-	}
-	rlp, _ := rlp.EncodeToBytes(txs)
-	return rlp
-}
-
-// testOdr tests odr requests whose validation guaranteed by block headers.
-func testOdr(t *testing.T, protocol int, expFail uint64, checkCached bool, fn odrTestFn) {
-	// Assemble the test environment
-	netconfig := testnetConfig{
-		blocks:    4,
-		protocol:  protocol,
-		connect:   true,
-		nopruning: true,
-	}
-	server, client, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	// Ensure the client has synced all necessary data.
-	clientHead := client.handler.backend.blockchain.CurrentHeader()
-	if clientHead.Number.Uint64() != 4 {
-		t.Fatalf("Failed to sync the chain with server, head: %v", clientHead.Number.Uint64())
-	}
-	// Disable the mechanism that we will wait a few time for request
-	// even there is no suitable peer to send right now.
-	waitForPeers = 0
-
-	test := func(expFail uint64) {
-		// Mark this as a helper to put the failures at the correct lines
-		t.Helper()
-
-		for i := uint64(0); i <= server.handler.blockchain.CurrentHeader().Number.Uint64(); i++ {
-			bhash := rawdb.ReadCanonicalHash(server.db, i)
-			b1 := fn(light.NoOdr, server.db, server.handler.server.chainConfig, server.handler.blockchain, nil, bhash)
-
-			// Set the timeout as 1 second here, ensure there is enough time
-			// 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")
-			}
-		}
-	}
-
-	// expect retrievals to fail (except genesis block) without a les peer
-	client.handler.backend.peers.lock.Lock()
-	client.peer.speer.hasBlockHook = func(common.Hash, uint64, bool) bool { return false }
-	client.handler.backend.peers.lock.Unlock()
-	test(expFail)
-
-	// expect all retrievals to pass
-	client.handler.backend.peers.lock.Lock()
-	client.peer.speer.hasBlockHook = func(common.Hash, uint64, bool) bool { return true }
-	client.handler.backend.peers.lock.Unlock()
-	test(5)
-
-	// still expect all retrievals to pass, now data should be cached locally
-	if checkCached {
-		client.handler.backend.peers.unregister(client.peer.speer.id)
-		time.Sleep(time.Millisecond * 10) // ensure that all peerSetNotify callbacks are executed
-		test(5)
-	}
-}
-
-func TestGetTxStatusFromUnindexedPeersLES4(t *testing.T) { testGetTxStatusFromUnindexedPeers(t, lpv4) }
-
-func testGetTxStatusFromUnindexedPeers(t *testing.T, protocol int) {
-	var (
-		blocks    = 8
-		netconfig = testnetConfig{
-			blocks:    blocks,
-			protocol:  protocol,
-			nopruning: true,
-		}
-	)
-	server, client, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	// Iterate the chain, create the tx indexes locally
-	var (
-		testHash   common.Hash
-		testStatus light.TxStatus
-
-		txs          = make(map[common.Hash]*types.Transaction) // Transaction objects set
-		blockNumbers = make(map[common.Hash]uint64)             // Transaction hash to block number mappings
-		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
-			blockHashes[tx.Hash()] = block.Hash()
-			intraIndex[tx.Hash()] = uint64(index)
-
-			if testHash == (common.Hash{}) {
-				testHash = tx.Hash()
-				testStatus = light.TxStatus{
-					Status: txpool.TxStatusIncluded,
-					Lookup: &rawdb.LegacyTxLookupEntry{
-						BlockHash:  block.Hash(),
-						BlockIndex: block.NumberU64(),
-						Index:      uint64(index),
-					},
-				}
-			}
-		}
-	}
-	// serveMsg processes incoming GetTxStatusMsg and sends the response back.
-	serveMsg := func(peer *testPeer, txLookup uint64) error {
-		msg, err := peer.app.ReadMsg()
-		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],
-				BlockIndex: number,
-				Index:      intraIndex[hash],
-			}
-		}
-		data, _ := rlp.EncodeToBytes(stats)
-		reply := &reply{peer.app, TxStatusMsg, r.ReqID, data}
-		reply.send(testBufLimit)
-		return nil
-	}
-
-	var testspecs = []struct {
-		peers     int
-		txLookups []uint64
-		txs       []common.Hash
-		results   []light.TxStatus
-	}{
-		// Retrieve mined transaction from the empty peerset
-		{
-			peers:     0,
-			txLookups: []uint64{},
-			txs:       []common.Hash{testHash},
-			results:   []light.TxStatus{{}},
-		},
-		// Retrieve unknown transaction from the full peers
-		{
-			peers:     3,
-			txLookups: []uint64{txIndexUnlimited, txIndexUnlimited, txIndexUnlimited},
-			txs:       []common.Hash{randomHash()},
-			results:   []light.TxStatus{{}},
-		},
-		// Retrieve mined transaction from the full peers
-		{
-			peers:     3,
-			txLookups: []uint64{txIndexUnlimited, txIndexUnlimited, txIndexUnlimited},
-			txs:       []common.Hash{testHash},
-			results:   []light.TxStatus{testStatus},
-		},
-		// Retrieve mixed transactions from the full peers
-		{
-			peers:     3,
-			txLookups: []uint64{txIndexUnlimited, txIndexUnlimited, txIndexUnlimited},
-			txs:       []common.Hash{randomHash(), testHash},
-			results:   []light.TxStatus{{}, testStatus},
-		},
-		// Retrieve mixed transactions from unindexed peer(but the target is still available)
-		{
-			peers:     3,
-			txLookups: []uint64{uint64(blocks) - testStatus.Lookup.BlockIndex, uint64(blocks) - testStatus.Lookup.BlockIndex - 1, uint64(blocks) - testStatus.Lookup.BlockIndex - 2},
-			txs:       []common.Hash{randomHash(), testHash},
-			results:   []light.TxStatus{{}, testStatus},
-		},
-		// Retrieve mixed transactions from unindexed peer(but the target is not available)
-		{
-			peers:     3,
-			txLookups: []uint64{uint64(blocks) - testStatus.Lookup.BlockIndex - 1, uint64(blocks) - testStatus.Lookup.BlockIndex - 1, uint64(blocks) - testStatus.Lookup.BlockIndex - 2},
-			txs:       []common.Hash{randomHash(), testHash},
-			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)
-
-			// Create a one-time routine for serving message
-			go func(i int, peer *testPeer, lookup uint64) {
-				serveMsg(peer, lookup)
-			}(i, peer, testspec.txLookups[i])
-		}
-
-		// 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()
-
-		err := client.handler.backend.odr.RetrieveTxStatus(ctx, r)
-		if err != nil {
-			t.Errorf("Failed to retrieve tx status %v", err)
-		} else {
-			if !reflect.DeepEqual(testspec.results, r.Status) {
-				t.Errorf("Result mismatch, diff")
-			}
-		}
-
-		// Close all connected peers and start the next round
-		for _, closeFn := range closeFns {
-			closeFn()
-		}
-	}
-}
-
-// randomHash generates a random blob of data and returns it as a hash.
-func randomHash() common.Hash {
-	var hash common.Hash
-	if n, err := rand.Read(hash[:]); n != common.HashLength || err != nil {
-		panic(err)
-	}
-	return hash
-}
-*/

les/peer_test.go

@@ -1,166 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"crypto/rand"
-	"errors"
-	"math/big"
-	"reflect"
-	"sort"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/forkid"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/params"
-)
-
-type testServerPeerSub struct {
-	regCh   chan *serverPeer
-	unregCh chan *serverPeer
-}
-
-func newTestServerPeerSub() *testServerPeerSub {
-	return &testServerPeerSub{
-		regCh:   make(chan *serverPeer, 1),
-		unregCh: make(chan *serverPeer, 1),
-	}
-}
-
-func (t *testServerPeerSub) registerPeer(p *serverPeer)   { t.regCh <- p }
-func (t *testServerPeerSub) unregisterPeer(p *serverPeer) { t.unregCh <- p }
-
-func TestPeerSubscription(t *testing.T) {
-	peers := newServerPeerSet()
-	defer peers.close()
-
-	checkIds := func(expect []string) {
-		given := peers.ids()
-		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)
-		}
-	}
-	checkPeers := func(peerCh chan *serverPeer) {
-		select {
-		case <-peerCh:
-		case <-time.NewTimer(100 * time.Millisecond).C:
-			t.Fatalf("timeout, no event received")
-		}
-		select {
-		case <-peerCh:
-			t.Fatalf("unexpected event received")
-		case <-time.NewTimer(10 * time.Millisecond).C:
-		}
-	}
-	checkIds([]string{})
-
-	sub := newTestServerPeerSub()
-	peers.subscribe(sub)
-
-	// 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)
-
-	checkIds([]string{peer.id})
-	checkPeers(sub.regCh)
-
-	peers.unregister(peer.id)
-	checkIds([]string{})
-	checkPeers(sub.unregCh)
-}
-
-type fakeChain struct{}
-
-func (f *fakeChain) Config() *params.ChainConfig { return params.MainnetChainConfig }
-func (f *fakeChain) Genesis() *types.Block {
-	return core.DefaultGenesisBlock().ToBlock()
-}
-func (f *fakeChain) CurrentHeader() *types.Header { return &types.Header{Number: big.NewInt(10000000)} }
-
-func TestHandshake(t *testing.T) {
-	// Create a message pipe to communicate through
-	app, net := p2p.MsgPipe()
-
-	// 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)
-	peer2 := newServerPeer(2, NetworkId, true, p2p.NewPeer(id, "name", nil), app)
-
-	var (
-		errCh1 = make(chan error, 1)
-		errCh2 = make(chan error, 1)
-
-		td      = big.NewInt(100)
-		head    = common.HexToHash("deadbeef")
-		headNum = uint64(10)
-		genesis = common.HexToHash("cafebabe")
-
-		chain1, chain2   = &fakeChain{}, &fakeChain{}
-		forkID1          = forkid.NewID(chain1.Config(), chain1.Genesis(), chain1.CurrentHeader().Number.Uint64(), chain1.CurrentHeader().Time)
-		forkID2          = forkid.NewID(chain2.Config(), chain2.Genesis(), chain2.CurrentHeader().Number.Uint64(), chain2.CurrentHeader().Time)
-		filter1, filter2 = forkid.NewFilter(chain1), forkid.NewFilter(chain2)
-	)
-
-	go func() {
-		errCh1 <- peer1.handshake(td, head, headNum, genesis, forkID1, filter1, func(list *keyValueList) {
-			var announceType uint64 = announceTypeSigned
-			*list = (*list).add("announceType", announceType)
-		}, nil)
-	}()
-	go func() {
-		errCh2 <- peer2.handshake(td, head, headNum, genesis, forkID2, filter2, nil, func(recv keyValueMap) error {
-			var reqType uint64
-			err := recv.get("announceType", &reqType)
-			if err != nil {
-				return err
-			}
-			if reqType != announceTypeSigned {
-				return errors.New("expected announceTypeSigned")
-			}
-			return nil
-		})
-	}()
-
-	for i := 0; i < 2; i++ {
-		select {
-		case err := <-errCh1:
-			if err != nil {
-				t.Fatalf("handshake failed, %v", err)
-			}
-		case err := <-errCh2:
-			if err != nil {
-				t.Fatalf("handshake failed, %v", err)
-			}
-		case <-time.After(time.Second):
-			t.Fatalf("timeout")
-		}
-	}
-}

les/protocol.go

@@ -1,327 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"crypto/ecdsa"
-	"errors"
-	"fmt"
-	"io"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	vfc "github.com/ethereum/go-ethereum/les/vflux/client"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-// Constants to match up protocol versions and messages
-const (
-	lpv2 = 2
-	lpv3 = 3
-	lpv4 = 4
-)
-
-// Supported versions of the les protocol (first is primary)
-var (
-	ClientProtocolVersions = []uint{lpv2, lpv3, lpv4}
-	ServerProtocolVersions = []uint{lpv2, lpv3, lpv4}
-)
-
-// ProtocolLengths is the number of implemented message corresponding to different protocol versions.
-var ProtocolLengths = map[uint]uint64{lpv2: 22, lpv3: 24, lpv4: 24}
-
-const (
-	NetworkId          = 1
-	ProtocolMaxMsgSize = 10 * 1024 * 1024 // Maximum cap on the size of a protocol message
-	blockSafetyMargin  = 4                // safety margin applied to block ranges specified relative to head block
-
-	txIndexUnlimited    = 0 // this value in the "recentTxLookup" handshake field means the entire tx index history is served
-	txIndexDisabled     = 1 // this value means tx index is not served at all
-	txIndexRecentOffset = 1 // txIndexRecentOffset + N in the handshake field means then tx index of the last N blocks is supported
-)
-
-// les protocol message codes
-const (
-	// Protocol messages inherited from LPV1
-	StatusMsg          = 0x00
-	AnnounceMsg        = 0x01
-	GetBlockHeadersMsg = 0x02
-	BlockHeadersMsg    = 0x03
-	GetBlockBodiesMsg  = 0x04
-	BlockBodiesMsg     = 0x05
-	GetReceiptsMsg     = 0x06
-	ReceiptsMsg        = 0x07
-	GetCodeMsg         = 0x0a
-	CodeMsg            = 0x0b
-	// Protocol messages introduced in LPV2
-	GetProofsV2Msg         = 0x0f
-	ProofsV2Msg            = 0x10
-	GetHelperTrieProofsMsg = 0x11
-	HelperTrieProofsMsg    = 0x12
-	SendTxV2Msg            = 0x13
-	GetTxStatusMsg         = 0x14
-	TxStatusMsg            = 0x15
-	// Protocol messages introduced in LPV3
-	StopMsg   = 0x16
-	ResumeMsg = 0x17
-)
-
-// GetBlockHeadersData represents a block header query (the request ID is not included)
-type GetBlockHeadersData struct {
-	Origin  hashOrNumber // Block from which to retrieve headers
-	Amount  uint64       // Maximum number of headers to retrieve
-	Skip    uint64       // Blocks to skip between consecutive headers
-	Reverse bool         // Query direction (false = rising towards latest, true = falling towards genesis)
-}
-
-// GetBlockHeadersPacket represents a block header request
-type GetBlockHeadersPacket struct {
-	ReqID uint64
-	Query GetBlockHeadersData
-}
-
-// GetBlockBodiesPacket represents a block body request
-type GetBlockBodiesPacket struct {
-	ReqID  uint64
-	Hashes []common.Hash
-}
-
-// GetCodePacket represents a contract code request
-type GetCodePacket struct {
-	ReqID uint64
-	Reqs  []CodeReq
-}
-
-// GetReceiptsPacket represents a block receipts request
-type GetReceiptsPacket struct {
-	ReqID  uint64
-	Hashes []common.Hash
-}
-
-// GetProofsPacket represents a proof request
-type GetProofsPacket struct {
-	ReqID uint64
-	Reqs  []ProofReq
-}
-
-// GetHelperTrieProofsPacket represents a helper trie proof request
-type GetHelperTrieProofsPacket struct {
-	ReqID uint64
-	Reqs  []HelperTrieReq
-}
-
-// SendTxPacket represents a transaction propagation request
-type SendTxPacket struct {
-	ReqID uint64
-	Txs   []*types.Transaction
-}
-
-// GetTxStatusPacket represents a transaction status query
-type GetTxStatusPacket struct {
-	ReqID  uint64
-	Hashes []common.Hash
-}
-
-type requestInfo struct {
-	name                          string
-	maxCount                      uint64
-	refBasketFirst, refBasketRest float64
-}
-
-// reqMapping maps an LES request to one or two vflux service vector entries.
-// If rest != -1 and the request type is used with amounts larger than one then the
-// first one of the multi-request is mapped to first while the rest is mapped to rest.
-type reqMapping struct {
-	first, rest int
-}
-
-var (
-	// requests describes the available LES request types and their initializing amounts
-	// in the vfc.ValueTracker reference basket. Initial values are estimates
-	// based on the same values as the server's default cost estimates (reqAvgTimeCost).
-	requests = map[uint64]requestInfo{
-		GetBlockHeadersMsg:     {"GetBlockHeaders", MaxHeaderFetch, 10, 1000},
-		GetBlockBodiesMsg:      {"GetBlockBodies", MaxBodyFetch, 1, 0},
-		GetReceiptsMsg:         {"GetReceipts", MaxReceiptFetch, 1, 0},
-		GetCodeMsg:             {"GetCode", MaxCodeFetch, 1, 0},
-		GetProofsV2Msg:         {"GetProofsV2", MaxProofsFetch, 10, 0},
-		GetHelperTrieProofsMsg: {"GetHelperTrieProofs", MaxHelperTrieProofsFetch, 10, 100},
-		SendTxV2Msg:            {"SendTxV2", MaxTxSend, 1, 0},
-		GetTxStatusMsg:         {"GetTxStatus", MaxTxStatus, 10, 0},
-	}
-	requestList    []vfc.RequestInfo
-	requestMapping map[uint32]reqMapping
-)
-
-// init creates a request list and mapping between protocol message codes and vflux
-// service vector indices.
-func init() {
-	requestMapping = make(map[uint32]reqMapping)
-	for code, req := range requests {
-		cost := reqAvgTimeCost[code]
-		rm := reqMapping{len(requestList), -1}
-		requestList = append(requestList, vfc.RequestInfo{
-			Name:       req.name + ".first",
-			InitAmount: req.refBasketFirst,
-			InitValue:  float64(cost.baseCost + cost.reqCost),
-		})
-		if req.refBasketRest != 0 {
-			rm.rest = len(requestList)
-			requestList = append(requestList, vfc.RequestInfo{
-				Name:       req.name + ".rest",
-				InitAmount: req.refBasketRest,
-				InitValue:  float64(cost.reqCost),
-			})
-		}
-		requestMapping[uint32(code)] = rm
-	}
-}
-
-type errCode int
-
-const (
-	ErrMsgTooLarge = iota
-	ErrDecode
-	ErrInvalidMsgCode
-	ErrProtocolVersionMismatch
-	ErrNetworkIdMismatch
-	ErrGenesisBlockMismatch
-	ErrNoStatusMsg
-	ErrExtraStatusMsg
-	ErrSuspendedPeer
-	ErrUselessPeer
-	ErrRequestRejected
-	ErrUnexpectedResponse
-	ErrInvalidResponse
-	ErrTooManyTimeouts
-	ErrMissingKey
-	ErrForkIDRejected
-)
-
-func (e errCode) String() string {
-	return errorToString[int(e)]
-}
-
-// XXX change once legacy code is out
-var errorToString = map[int]string{
-	ErrMsgTooLarge:             "Message too long",
-	ErrDecode:                  "Invalid message",
-	ErrInvalidMsgCode:          "Invalid message code",
-	ErrProtocolVersionMismatch: "Protocol version mismatch",
-	ErrNetworkIdMismatch:       "NetworkId mismatch",
-	ErrGenesisBlockMismatch:    "Genesis block mismatch",
-	ErrNoStatusMsg:             "No status message",
-	ErrExtraStatusMsg:          "Extra status message",
-	ErrSuspendedPeer:           "Suspended peer",
-	ErrRequestRejected:         "Request rejected",
-	ErrUnexpectedResponse:      "Unexpected response",
-	ErrInvalidResponse:         "Invalid response",
-	ErrTooManyTimeouts:         "Too many request timeouts",
-	ErrMissingKey:              "Key missing from list",
-	ErrForkIDRejected:          "ForkID rejected",
-}
-
-// announceData is the network packet for the block announcements.
-type announceData struct {
-	Hash       common.Hash // Hash of one particular block being announced
-	Number     uint64      // Number of one particular block being announced
-	Td         *big.Int    // Total difficulty of one particular block being announced
-	ReorgDepth uint64
-	Update     keyValueList
-}
-
-// sanityCheck verifies that the values are reasonable, as a DoS protection
-func (a *announceData) sanityCheck() error {
-	if tdlen := a.Td.BitLen(); tdlen > 100 {
-		return fmt.Errorf("too large block TD: bitlen %d", tdlen)
-	}
-	return nil
-}
-
-// sign adds a signature to the block announcement by the given privKey
-func (a *announceData) sign(privKey *ecdsa.PrivateKey) {
-	rlp, _ := rlp.EncodeToBytes(blockInfo{a.Hash, a.Number, a.Td})
-	sig, _ := crypto.Sign(crypto.Keccak256(rlp), privKey)
-	a.Update = a.Update.add("sign", sig)
-}
-
-// checkSignature verifies if the block announcement has a valid signature by the given pubKey
-func (a *announceData) checkSignature(id enode.ID, update keyValueMap) error {
-	var sig []byte
-	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")
-}
-
-type blockInfo struct {
-	Hash   common.Hash // Hash of one particular block being announced
-	Number uint64      // Number of one particular block being announced
-	Td     *big.Int    // Total difficulty of one particular block being announced
-}
-
-// hashOrNumber is a combined field for specifying an origin block.
-type hashOrNumber struct {
-	Hash   common.Hash // Block hash from which to retrieve headers (excludes Number)
-	Number uint64      // Block hash from which to retrieve headers (excludes Hash)
-}
-
-// EncodeRLP is a specialized encoder for hashOrNumber to encode only one of the
-// two contained union fields.
-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)
-}
-
-// DecodeRLP is a specialized decoder for hashOrNumber to decode the contents
-// 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
-	case size == 32:
-		hn.Number = 0
-		return s.Decode(&hn.Hash)
-	case size <= 8:
-		hn.Hash = common.Hash{}
-		return s.Decode(&hn.Number)
-	default:
-		return fmt.Errorf("invalid input size %d for origin", size)
-	}
-}
-
-// CodeData is the network response packet for a node data retrieval.
-type CodeData []struct {
-	Value []byte
-}

les/request_test.go

@@ -1,129 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-// Note: these tests are disabled now because they cannot work with the old sync
-// mechanism removed but will be useful again once the PoS ultralight mode is implemented
-
-/*
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/light"
-)
-
-var testBankSecureTrieKey = secAddr(bankAddr)
-
-func secAddr(addr common.Address) []byte {
-	return crypto.Keccak256(addr[:])
-}
-
-type accessTestFn func(db ethdb.Database, bhash common.Hash, number uint64) light.OdrRequest
-
-func TestBlockAccessLes2(t *testing.T) { testAccess(t, 2, tfBlockAccess) }
-func TestBlockAccessLes3(t *testing.T) { testAccess(t, 3, tfBlockAccess) }
-func TestBlockAccessLes4(t *testing.T) { testAccess(t, 4, tfBlockAccess) }
-
-func tfBlockAccess(db ethdb.Database, bhash common.Hash, number uint64) light.OdrRequest {
-	return &light.BlockRequest{Hash: bhash, Number: number}
-}
-
-func TestReceiptsAccessLes2(t *testing.T) { testAccess(t, 2, tfReceiptsAccess) }
-func TestReceiptsAccessLes3(t *testing.T) { testAccess(t, 3, tfReceiptsAccess) }
-func TestReceiptsAccessLes4(t *testing.T) { testAccess(t, 4, tfReceiptsAccess) }
-
-func tfReceiptsAccess(db ethdb.Database, bhash common.Hash, number uint64) light.OdrRequest {
-	return &light.ReceiptsRequest{Hash: bhash, Number: number}
-}
-
-func TestTrieEntryAccessLes2(t *testing.T) { testAccess(t, 2, tfTrieEntryAccess) }
-func TestTrieEntryAccessLes3(t *testing.T) { testAccess(t, 3, tfTrieEntryAccess) }
-func TestTrieEntryAccessLes4(t *testing.T) { testAccess(t, 4, tfTrieEntryAccess) }
-
-func tfTrieEntryAccess(db ethdb.Database, bhash common.Hash, number uint64) light.OdrRequest {
-	if number := rawdb.ReadHeaderNumber(db, bhash); number != nil {
-		return &light.TrieRequest{Id: light.StateTrieID(rawdb.ReadHeader(db, bhash, *number)), Key: testBankSecureTrieKey}
-	}
-	return nil
-}
-
-func TestCodeAccessLes2(t *testing.T) { testAccess(t, 2, tfCodeAccess) }
-func TestCodeAccessLes3(t *testing.T) { testAccess(t, 3, tfCodeAccess) }
-func TestCodeAccessLes4(t *testing.T) { testAccess(t, 4, tfCodeAccess) }
-
-func tfCodeAccess(db ethdb.Database, bhash common.Hash, num uint64) light.OdrRequest {
-	number := rawdb.ReadHeaderNumber(db, bhash)
-	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, testContractAddr, types.EmptyRootHash)
-	return &light.CodeRequest{Id: ci, Hash: crypto.Keccak256Hash(testContractCodeDeployed)}
-}
-
-func testAccess(t *testing.T, protocol int, fn accessTestFn) {
-	// Assemble the test environment
-	netconfig := testnetConfig{
-		blocks:    4,
-		protocol:  protocol,
-		indexFn:   nil,
-		connect:   true,
-		nopruning: true,
-	}
-	server, client, tearDown := newClientServerEnv(t, netconfig)
-	defer tearDown()
-
-	// Ensure the client has synced all necessary data.
-	clientHead := client.handler.backend.blockchain.CurrentHeader()
-	if clientHead.Number.Uint64() != 4 {
-		t.Fatalf("Failed to sync the chain with server, head: %v", clientHead.Number.Uint64())
-	}
-
-	test := func(expFail uint64) {
-		for i := uint64(0); i <= server.handler.blockchain.CurrentHeader().Number.Uint64(); i++ {
-			bhash := rawdb.ReadCanonicalHash(server.db, i)
-			if req := fn(client.db, bhash, i); req != nil {
-				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")
-				}
-			}
-		}
-	}
-	test(5)
-}
-*/

les/retrieve.go

@@ -1,421 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"context"
-	"errors"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/light"
-)
-
-var (
-	retryQueue         = time.Millisecond * 100
-	hardRequestTimeout = time.Second * 10
-)
-
-// retrieveManager is a layer on top of requestDistributor which takes care of
-// matching replies by request ID and handles timeouts and resends if necessary.
-type retrieveManager struct {
-	dist               *requestDistributor
-	peers              *serverPeerSet
-	softRequestTimeout func() time.Duration
-
-	lock     sync.RWMutex
-	sentReqs map[uint64]*sentReq
-}
-
-// validatorFunc is a function that processes a reply message
-type validatorFunc func(distPeer, *Msg) error
-
-// sentReq represents a request sent and tracked by retrieveManager
-type sentReq struct {
-	rm       *retrieveManager
-	req      *distReq
-	id       uint64
-	validate validatorFunc
-
-	eventsCh chan reqPeerEvent
-	stopCh   chan struct{}
-	stopped  bool
-	err      error
-
-	lock   sync.RWMutex // protect access to sentTo map
-	sentTo map[distPeer]sentReqToPeer
-
-	lastReqQueued bool     // last request has been queued but not sent
-	lastReqSentTo distPeer // if not nil then last request has been sent to given peer but not timed out
-	reqSrtoCount  int      // number of requests that reached soft (but not hard) timeout
-}
-
-// sentReqToPeer notifies the request-from-peer goroutine (tryRequest) about a response
-// delivered by the given peer. Only one delivery is allowed per request per peer,
-// after which delivered is set to true, the validity of the response is sent on the
-// valid channel and no more responses are accepted.
-type sentReqToPeer struct {
-	delivered, frozen bool
-	event             chan int
-}
-
-// reqPeerEvent is sent by the request-from-peer goroutine (tryRequest) to the
-// request state machine (retrieveLoop) through the eventsCh channel.
-type reqPeerEvent struct {
-	event int
-	peer  distPeer
-}
-
-const (
-	rpSent = iota // if peer == nil, not sent (no suitable peers)
-	rpSoftTimeout
-	rpHardTimeout
-	rpDeliveredValid
-	rpDeliveredInvalid
-	rpNotDelivered
-)
-
-// newRetrieveManager creates the retrieve manager
-func newRetrieveManager(peers *serverPeerSet, dist *requestDistributor, srto func() time.Duration) *retrieveManager {
-	return &retrieveManager{
-		peers:              peers,
-		dist:               dist,
-		sentReqs:           make(map[uint64]*sentReq),
-		softRequestTimeout: srto,
-	}
-}
-
-// retrieve sends a request (to multiple peers if necessary) and waits for an answer
-// that is delivered through the deliver function and successfully validated by the
-// validator callback. It returns when a valid answer is delivered or the context is
-// cancelled.
-func (rm *retrieveManager) retrieve(ctx context.Context, reqID uint64, req *distReq, val validatorFunc, shutdown chan struct{}) error {
-	sentReq := rm.sendReq(reqID, req, val)
-	select {
-	case <-sentReq.stopCh:
-	case <-ctx.Done():
-		sentReq.stop(ctx.Err())
-	case <-shutdown:
-		sentReq.stop(errors.New("client is shutting down"))
-	}
-	return sentReq.getError()
-}
-
-// sendReq starts a process that keeps trying to retrieve a valid answer for a
-// request from any suitable peers until stopped or succeeded.
-func (rm *retrieveManager) sendReq(reqID uint64, req *distReq, val validatorFunc) *sentReq {
-	r := &sentReq{
-		rm:       rm,
-		req:      req,
-		id:       reqID,
-		sentTo:   make(map[distPeer]sentReqToPeer),
-		stopCh:   make(chan struct{}),
-		eventsCh: make(chan reqPeerEvent, 10),
-		validate: val,
-	}
-
-	canSend := req.canSend
-	req.canSend = func(p distPeer) bool {
-		// add an extra check to canSend: the request has not been sent to the same peer before
-		r.lock.RLock()
-		_, sent := r.sentTo[p]
-		r.lock.RUnlock()
-		return !sent && canSend(p)
-	}
-
-	request := req.request
-	req.request = func(p distPeer) func() {
-		// before actually sending the request, put an entry into the sentTo map
-		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
-}
-
-// 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()
-	req, ok := rm.sentReqs[msg.ReqID]
-	rm.lock.RUnlock()
-
-	if ok {
-		return req.deliver(peer, msg)
-	}
-	return errResp(ErrUnexpectedResponse, "reqID = %v", msg.ReqID)
-}
-
-// frozen is called by the LES protocol manager when a server has suspended its service and we
-// should not expect an answer for the requests already sent there
-func (rm *retrieveManager) frozen(peer distPeer) {
-	rm.lock.RLock()
-	defer rm.lock.RUnlock()
-
-	for _, req := range rm.sentReqs {
-		req.frozen(peer)
-	}
-}
-
-// reqStateFn represents a state of the retrieve loop state machine
-type reqStateFn func() reqStateFn
-
-// retrieveLoop is the retrieval state machine event loop
-func (r *sentReq) retrieveLoop() {
-	go r.tryRequest()
-	r.lastReqQueued = true
-	state := r.stateRequesting
-
-	for state != nil {
-		state = state()
-	}
-
-	r.rm.lock.Lock()
-	delete(r.rm.sentReqs, r.id)
-	r.rm.lock.Unlock()
-}
-
-// stateRequesting: a request has been queued or sent recently; when it reaches soft timeout,
-// a new request is sent to a new peer
-func (r *sentReq) stateRequesting() reqStateFn {
-	select {
-	case ev := <-r.eventsCh:
-		r.update(ev)
-		switch ev.event {
-		case rpSent:
-			if ev.peer == nil {
-				// request send failed, no more suitable peers
-				if r.waiting() {
-					// we are already waiting for sent requests which may succeed so keep waiting
-					return r.stateNoMorePeers
-				}
-				// nothing to wait for, no more peers to ask, return with error
-				r.stop(light.ErrNoPeers)
-				// no need to go to stopped state because waiting() already returned false
-				return nil
-			}
-		case rpSoftTimeout:
-			// 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
-			if !r.lastReqQueued && r.lastReqSentTo == nil {
-				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
-	}
-}
-
-// stateNoMorePeers: could not send more requests because no suitable peers are available.
-// Peers may become suitable for a certain request later or new peers may appear so we
-// keep trying.
-func (r *sentReq) stateNoMorePeers() reqStateFn {
-	select {
-	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
-	}
-}
-
-// stateStopped: request succeeded or cancelled, just waiting for some peers
-// to either answer or time out hard
-func (r *sentReq) stateStopped() reqStateFn {
-	for r.waiting() {
-		r.update(<-r.eventsCh)
-	}
-	return nil
-}
-
-// update updates the queued/sent flags and timed out peers counter according to the event
-func (r *sentReq) update(ev reqPeerEvent) {
-	switch ev.event {
-	case rpSent:
-		r.lastReqQueued = false
-		r.lastReqSentTo = ev.peer
-	case rpSoftTimeout:
-		r.lastReqSentTo = nil
-		r.reqSrtoCount++
-	case rpHardTimeout:
-		r.reqSrtoCount--
-	case rpDeliveredValid, rpDeliveredInvalid, rpNotDelivered:
-		if ev.peer == r.lastReqSentTo {
-			r.lastReqSentTo = nil
-		} else {
-			r.reqSrtoCount--
-		}
-	}
-}
-
-// waiting returns true if the retrieval mechanism is waiting for an answer from
-// any peer
-func (r *sentReq) waiting() bool {
-	return r.lastReqQueued || r.lastReqSentTo != nil || r.reqSrtoCount > 0
-}
-
-// tryRequest tries to send the request to a new peer and waits for it to either
-// succeed or time out if it has been sent. It also sends the appropriate reqPeerEvent
-// 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:
-	case <-r.stopCh:
-		if r.rm.dist.cancel(r.req) {
-			p = nil
-		} else {
-			p = <-sent
-		}
-	}
-
-	r.eventsCh <- reqPeerEvent{rpSent, p}
-	if p == nil {
-		return
-	}
-
-	hrto := false
-
-	r.lock.RLock()
-	s, ok := r.sentTo[p]
-	r.lock.RUnlock()
-	if !ok {
-		panic(nil)
-	}
-
-	defer func() {
-		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)
-			}
-		}
-	}()
-
-	select {
-	case event := <-s.event:
-		if event == rpNotDelivered {
-			r.lock.Lock()
-			delete(r.sentTo, p)
-			r.lock.Unlock()
-		}
-		r.eventsCh <- reqPeerEvent{event, p}
-		return
-	case <-time.After(r.rm.softRequestTimeout()):
-		r.eventsCh <- reqPeerEvent{rpSoftTimeout, p}
-	}
-
-	select {
-	case event := <-s.event:
-		if event == rpNotDelivered {
-			r.lock.Lock()
-			delete(r.sentTo, p)
-			r.lock.Unlock()
-		}
-		r.eventsCh <- reqPeerEvent{event, p}
-	case <-time.After(hardRequestTimeout):
-		hrto = true
-		r.eventsCh <- reqPeerEvent{rpHardTimeout, p}
-	}
-}
-
-// deliver a reply belonging to this request
-func (r *sentReq) deliver(peer distPeer, msg *Msg) error {
-	r.lock.Lock()
-	defer r.lock.Unlock()
-
-	s, ok := r.sentTo[peer]
-	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
-}
-
-// frozen sends a "not delivered" event to the peer event channel belonging to the
-// given peer if the request has been sent there, causing the state machine to not
-// expect an answer and potentially even send the request to the same peer again
-// when canSend allows it.
-func (r *sentReq) frozen(peer distPeer) {
-	r.lock.Lock()
-	defer r.lock.Unlock()
-
-	s, ok := r.sentTo[peer]
-	if ok && !s.delivered && !s.frozen {
-		r.sentTo[peer] = sentReqToPeer{delivered: false, frozen: true, event: s.event}
-		s.event <- rpNotDelivered
-	}
-}
-
-// stop stops the retrieval process and sets an error code that will be returned
-// by getError
-func (r *sentReq) stop(err error) {
-	r.lock.Lock()
-	if !r.stopped {
-		r.stopped = true
-		r.err = err
-		close(r.stopCh)
-	}
-	r.lock.Unlock()
-}
-
-// getError returns any retrieval error (either internally generated or set by the
-// stop function) after stopCh has been closed
-func (r *sentReq) getError() error {
-	return r.err
-}

les/server.go

@@ -1,281 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"crypto/ecdsa"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/txpool"
-	"github.com/ethereum/go-ethereum/eth/ethconfig"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/les/flowcontrol"
-	vfs "github.com/ethereum/go-ethereum/les/vflux/server"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/node"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/p2p/enr"
-	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/rpc"
-)
-
-var (
-	defaultPosFactors = vfs.PriceFactors{TimeFactor: 0, CapacityFactor: 1, RequestFactor: 1}
-	defaultNegFactors = vfs.PriceFactors{TimeFactor: 0, CapacityFactor: 1, RequestFactor: 1}
-)
-
-const defaultConnectedBias = time.Minute * 3
-
-type ethBackend interface {
-	ArchiveMode() bool
-	BlockChain() *core.BlockChain
-	BloomIndexer() *core.ChainIndexer
-	ChainDb() ethdb.Database
-	Synced() bool
-	TxPool() *txpool.TxPool
-}
-
-type LesServer struct {
-	lesCommons
-
-	archiveMode bool // Flag whether the ethereum node runs in archive mode.
-	handler     *serverHandler
-	peers       *clientPeerSet
-	serverset   *serverSet
-	vfluxServer *vfs.Server
-	privateKey  *ecdsa.PrivateKey
-
-	// Flow control and capacity management
-	fcManager    *flowcontrol.ClientManager
-	costTracker  *costTracker
-	defParams    flowcontrol.ServerParams
-	servingQueue *servingQueue
-	clientPool   *vfs.ClientPool
-
-	minCapacity, maxCapacity uint64
-	threadsIdle              int // Request serving threads count when system is idle.
-	threadsBusy              int // Request serving threads count when system is busy(block insertion).
-
-	p2pSrv *p2p.Server
-}
-
-func NewLesServer(node *node.Node, e ethBackend, config *ethconfig.Config) (*LesServer, error) {
-	lesDb, err := node.OpenDatabase("les.server", 0, 0, "eth/db/lesserver/", false)
-	if err != nil {
-		return nil, err
-	}
-	// Calculate the number of threads used to service the light client
-	// requests based on the user-specified value.
-	threads := config.LightServ * 4 / 100
-	if threads < 4 {
-		threads = 4
-	}
-	srv := &LesServer{
-		lesCommons: lesCommons{
-			genesis:          e.BlockChain().Genesis().Hash(),
-			config:           config,
-			chainConfig:      e.BlockChain().Config(),
-			iConfig:          light.DefaultServerIndexerConfig,
-			chainDb:          e.ChainDb(),
-			lesDb:            lesDb,
-			chainReader:      e.BlockChain(),
-			chtIndexer:       light.NewChtIndexer(e.ChainDb(), nil, params.CHTFrequency, params.HelperTrieProcessConfirmations, true),
-			bloomTrieIndexer: light.NewBloomTrieIndexer(e.ChainDb(), nil, params.BloomBitsBlocks, params.BloomTrieFrequency, true),
-			closeCh:          make(chan struct{}),
-		},
-		archiveMode:  e.ArchiveMode(),
-		peers:        newClientPeerSet(),
-		serverset:    newServerSet(),
-		vfluxServer:  vfs.NewServer(time.Millisecond * 10),
-		fcManager:    flowcontrol.NewClientManager(nil, &mclock.System{}),
-		servingQueue: newServingQueue(int64(time.Millisecond*10), float64(config.LightServ)/100),
-		threadsBusy:  config.LightServ/100 + 1,
-		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)
-
-	// Initialize the bloom trie indexer.
-	e.BloomIndexer().AddChildIndexer(srv.bloomTrieIndexer)
-
-	// Initialize server capacity management fields.
-	srv.defParams = flowcontrol.ServerParams{
-		BufLimit:    srv.minCapacity * bufLimitRatio,
-		MinRecharge: srv.minCapacity,
-	}
-	// LES flow control tries to more or less guarantee the possibility for the
-	// clients to send a certain amount of requests at any time and get a quick
-	// response. Most of the clients want this guarantee but don't actually need
-	// to send requests most of the time. Our goal is to serve as many clients as
-	// 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")
-	srv.chtIndexer.Start(e.BlockChain())
-
-	node.RegisterProtocols(srv.Protocols())
-	node.RegisterAPIs(srv.APIs())
-	node.RegisterLifecycle(srv)
-	return srv, nil
-}
-
-func (s *LesServer) APIs() []rpc.API {
-	return []rpc.API{
-		{
-			Namespace: "les",
-			Service:   NewLightServerAPI(s),
-		},
-		{
-			Namespace: "debug",
-			Service:   NewDebugAPI(s),
-		},
-	}
-}
-
-func (s *LesServer) Protocols() []p2p.Protocol {
-	ps := s.makeProtocols(ServerProtocolVersions, s.handler.runPeer, func(id enode.ID) interface{} {
-		if p := s.peers.peer(id); p != nil {
-			return p.Info()
-		}
-		return nil
-	}, nil)
-	// Add "les" ENR entries.
-	for i := range ps {
-		ps[i].Attributes = []enr.Entry{&lesEntry{
-			VfxVersion: 1,
-		}}
-	}
-	return ps
-}
-
-// Start starts the LES server
-func (s *LesServer) Start() error {
-	s.privateKey = s.p2pSrv.PrivateKey
-	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
-}
-
-// Stop stops the LES service
-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()
-	}
-
-	// Note, bloom trie indexer is closed by parent bloombits indexer.
-	if s.chtIndexer != nil {
-		s.chtIndexer.Close()
-	}
-	if s.lesDb != nil {
-		s.lesDb.Close()
-	}
-	s.wg.Wait()
-	log.Info("Les server stopped")
-
-	return nil
-}
-
-// capacityManagement starts an event handler loop that updates the recharge curve of
-// the client manager and adjusts the client pool's size according to the total
-// capacity updates coming from the client manager
-func (s *LesServer) capacityManagement() {
-	defer s.wg.Done()
-
-	processCh := make(chan bool, 100)
-	sub := s.handler.blockchain.SubscribeBlockProcessingEvent(processCh)
-	defer sub.Unsubscribe()
-
-	totalRechargeCh := make(chan uint64, 100)
-	totalRecharge := s.costTracker.subscribeTotalRecharge(totalRechargeCh)
-
-	totalCapacityCh := make(chan uint64, 100)
-	totalCapacity := s.fcManager.SubscribeTotalCapacity(totalCapacityCh)
-	s.clientPool.SetLimits(uint64(s.config.LightPeers), totalCapacity)
-
-	var (
-		busy         bool
-		freePeers    uint64
-		blockProcess mclock.AbsTime
-	)
-	updateRecharge := func() {
-		if busy {
-			s.servingQueue.setThreads(s.threadsBusy)
-			s.fcManager.SetRechargeCurve(flowcontrol.PieceWiseLinear{{0, 0}, {totalRecharge, totalRecharge}})
-		} else {
-			s.servingQueue.setThreads(s.threadsIdle)
-			s.fcManager.SetRechargeCurve(flowcontrol.PieceWiseLinear{{0, 0}, {totalRecharge / 10, totalRecharge}, {totalRecharge, totalRecharge}})
-		}
-	}
-	updateRecharge()
-
-	for {
-		select {
-		case busy = <-processCh:
-			if busy {
-				blockProcess = mclock.Now()
-			} 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

@@ -1,436 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"errors"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/forkid"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/txpool"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/les/flowcontrol"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/metrics"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/trie"
-)
-
-const (
-	softResponseLimit = 2 * 1024 * 1024 // Target maximum size of returned blocks, headers or node data.
-	estHeaderRlpSize  = 500             // Approximate size of an RLP encoded block header
-
-	MaxHeaderFetch           = 192 // Amount of block headers to be fetched per retrieval request
-	MaxBodyFetch             = 32  // Amount of block bodies to be fetched per retrieval request
-	MaxReceiptFetch          = 128 // Amount of transaction receipts to allow fetching per request
-	MaxCodeFetch             = 64  // Amount of contract codes to allow fetching per request
-	MaxProofsFetch           = 64  // Amount of merkle proofs to be fetched per retrieval request
-	MaxHelperTrieProofsFetch = 64  // Amount of helper tries to be fetched per retrieval request
-	MaxTxSend                = 64  // Amount of transactions to be send per request
-	MaxTxStatus              = 256 // Amount of transactions to queried per request
-)
-
-var (
-	errTooManyInvalidRequest = errors.New("too many invalid requests made")
-)
-
-// serverHandler is responsible for serving light client and process
-// all incoming light requests.
-type serverHandler struct {
-	forkFilter forkid.Filter
-	blockchain *core.BlockChain
-	chainDb    ethdb.Database
-	txpool     *txpool.TxPool
-	server     *LesServer
-
-	closeCh chan struct{}  // Channel used to exit all background routines of handler.
-	wg      sync.WaitGroup // WaitGroup used to track all background routines of handler.
-	synced  func() bool    // Callback function used to determine whether local node is synced.
-
-	// Testing fields
-	addTxsSync bool
-}
-
-func newServerHandler(server *LesServer, blockchain *core.BlockChain, chainDb ethdb.Database, txpool *txpool.TxPool, synced func() bool) *serverHandler {
-	handler := &serverHandler{
-		forkFilter: forkid.NewFilter(blockchain),
-		server:     server,
-		blockchain: blockchain,
-		chainDb:    chainDb,
-		txpool:     txpool,
-		closeCh:    make(chan struct{}),
-		synced:     synced,
-	}
-	return handler
-}
-
-// start starts the server handler.
-func (h *serverHandler) start() {
-	h.wg.Add(1)
-	go h.broadcastLoop()
-}
-
-// stop stops the server handler.
-func (h *serverHandler) stop() {
-	close(h.closeCh)
-	h.wg.Wait()
-}
-
-// runPeer is the p2p protocol run function for the given version.
-func (h *serverHandler) runPeer(version uint, p *p2p.Peer, rw p2p.MsgReadWriter) error {
-	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)
-}
-
-func (h *serverHandler) handle(p *clientPeer) error {
-	p.Log().Debug("Light Ethereum peer connected", "name", p.Name())
-
-	// Execute the LES handshake
-	var (
-		head   = h.blockchain.CurrentHeader()
-		hash   = head.Hash()
-		number = head.Number.Uint64()
-		td     = h.blockchain.GetTd(hash, number)
-		forkID = forkid.NewID(h.blockchain.Config(), h.blockchain.Genesis(), 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
-	}
-	// Connected to another server, no messages expected, just wait for disconnection
-	if p.server {
-		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
-	p.fcClient = flowcontrol.NewClientNode(h.server.fcManager, p.fcParams)
-	defer p.fcClient.Disconnect()
-
-	// Reject light clients if server is not synced. Put this checking here, so
-	// that "non-synced" les-server peers are still allowed to keep the connection.
-	if !h.synced() {
-		p.Log().Debug("Light server not synced, rejecting peer")
-		return p2p.DiscRequested
-	}
-
-	// Register the peer into the peerset and clientpool
-	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.
-	defer func() {
-		wg.Wait() // Ensure all background task routines have exited.
-		h.server.clientPool.Unregister(p)
-		h.server.peers.unregister(p.ID())
-		p.balance = nil
-		connectionTimer.Update(time.Duration(mclock.Now() - p.connectedAt))
-	}()
-
-	// Mark the peer as being served.
-	p.serving.Store(true)
-	defer p.serving.Store(false)
-
-	// Spawn a main loop to handle all incoming messages.
-	for {
-		select {
-		case err := <-p.errCh:
-			p.Log().Debug("Failed to send light ethereum response", "err", err)
-			return err
-		default:
-		}
-		if err := h.handleMsg(p, &wg); err != nil {
-			p.Log().Debug("Light Ethereum message handling failed", "err", err)
-			return err
-		}
-	}
-}
-
-// beforeHandle will do a series of prechecks before handling message.
-func (h *serverHandler) beforeHandle(p *clientPeer, reqID, responseCount uint64, msg p2p.Msg, reqCnt uint64, maxCount uint64) (*servingTask, uint64) {
-	// Ensure that the request sent by client peer is valid
-	inSizeCost := h.server.costTracker.realCost(0, msg.Size, 0)
-	if reqCnt == 0 || reqCnt > maxCount {
-		p.fcClient.OneTimeCost(inSizeCost)
-		return nil, 0
-	}
-	// Ensure that the client peer complies with the flow control
-	// rules agreed by both sides.
-	if p.isFrozen() {
-		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
-	// execute, and cache it in the request service queue.
-	factor := h.server.costTracker.globalFactor()
-	if factor < 0.001 {
-		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
-}
-
-// Afterhandle will perform a series of operations after message handling,
-// such as updating flow control data, sending reply, etc.
-func (h *serverHandler) afterHandle(p *clientPeer, reqID, responseCount uint64, msg p2p.Msg, maxCost uint64, reqCnt uint64, task *servingTask, reply *reply) {
-	if reply != nil {
-		task.done()
-	}
-	p.responseLock.Lock()
-	defer p.responseLock.Unlock()
-
-	// Short circuit if the client is already frozen.
-	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.
-	var replySize uint32
-	if reply != nil {
-		replySize = reply.size()
-	}
-	var realCost uint64
-	if h.server.costTracker.testing {
-		realCost = maxCost // Assign a fake cost for testing purpose
-	} else {
-		realCost = h.server.costTracker.realCost(task.servingTime, msg.Size, replySize)
-		if realCost > maxCost {
-			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)
-		// Reduce priority "balance" for the specific peer.
-		p.balance.RequestServed(realCost)
-		p.queueSend(func() {
-			if err := reply.send(bv); err != nil {
-				select {
-				case p.errCh <- err:
-				default:
-				}
-			}
-		})
-	}
-}
-
-// handleMsg is invoked whenever an inbound message is received from a remote
-// peer. The remote connection is torn down upon returning any error.
-func (h *serverHandler) handleMsg(p *clientPeer, wg *sync.WaitGroup) error {
-	// Read the next message from the remote peer, and ensure it's fully consumed
-	msg, err := p.rw.ReadMsg()
-	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.
-	if msg.Size > ProtocolMaxMsgSize {
-		clientErrorMeter.Mark(1)
-		return errResp(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize)
-	}
-	defer msg.Discard()
-
-	// Lookup the request handler table, ensure it's supported
-	// message type by the protocol.
-	req, ok := Les3[msg.Code]
-	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.
-	serve, reqID, reqCnt, err := req.Handle(msg)
-	if err != nil {
-		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
-
-	// First check this client message complies all rules before
-	// handling it and return a processor if all checks are passed.
-	task, maxCost := h.beforeHandle(p, reqID, responseCount, msg, reqCnt, req.MaxCount)
-	if task == nil {
-		return nil
-	}
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-
-		reply := serve(h, p, task.waitOrStop)
-		h.afterHandle(p, reqID, responseCount, msg, maxCost, reqCnt, task, reply)
-
-		if metrics.EnabledExpensive {
-			size := uint32(0)
-			if reply != nil {
-				size = reply.size()
-			}
-			req.OutPacketsMeter.Mark(1)
-			req.OutTrafficMeter.Mark(int64(size))
-			req.ServingTimeMeter.Update(time.Duration(task.servingTime))
-		}
-	}()
-	// If the client has made too much invalid request(e.g. request a non-existent data),
-	// reject them to prevent SPAM attack.
-	if p.getInvalid() > maxRequestErrors {
-		clientErrorMeter.Mark(1)
-		return errTooManyInvalidRequest
-	}
-	return nil
-}
-
-// BlockChain implements serverBackend
-func (h *serverHandler) BlockChain() *core.BlockChain {
-	return h.blockchain
-}
-
-// TxPool implements serverBackend
-func (h *serverHandler) TxPool() *txpool.TxPool {
-	return h.txpool
-}
-
-// ArchiveMode implements serverBackend
-func (h *serverHandler) ArchiveMode() bool {
-	return h.server.archiveMode
-}
-
-// AddTxsSync implements serverBackend
-func (h *serverHandler) AddTxsSync() bool {
-	return h.addTxsSync
-}
-
-// getAccount retrieves an account from the state based on root.
-func getAccount(triedb *trie.Database, root common.Hash, addr common.Address) (types.StateAccount, error) {
-	trie, err := trie.NewStateTrie(trie.StateTrieID(root), triedb)
-	if err != nil {
-		return types.StateAccount{}, err
-	}
-	acc, err := trie.GetAccount(addr)
-	if err != nil {
-		return types.StateAccount{}, err
-	}
-	if acc == nil {
-		return types.StateAccount{}, fmt.Errorf("account %#x is not present", addr)
-	}
-	return *acc, nil
-}
-
-// GetHelperTrie returns the post-processed trie root for the given trie ID and section index
-func (h *serverHandler) GetHelperTrie(typ uint, index uint64) *trie.Trie {
-	var (
-		root   common.Hash
-		prefix string
-	)
-	switch typ {
-	case htCanonical:
-		sectionHead := rawdb.ReadCanonicalHash(h.chainDb, (index+1)*h.server.iConfig.ChtSize-1)
-		root, prefix = light.GetChtRoot(h.chainDb, index, sectionHead), string(rawdb.ChtTablePrefix)
-	case htBloomBits:
-		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
-	}
-	triedb := trie.NewDatabase(rawdb.NewTable(h.chainDb, prefix), trie.HashDefaults)
-	trie, _ := trie.New(trie.TrieID(root), triedb)
-	return trie
-}
-
-// broadcastLoop broadcasts new block information to all connected light
-// clients. According to the agreement between client and server, server should
-// only broadcast new announcement if the total difficulty is higher than the
-// last one. Besides server will add the signature if client requires.
-func (h *serverHandler) broadcastLoop() {
-	defer h.wg.Done()
-
-	headCh := make(chan core.ChainHeadEvent, 10)
-	headSub := h.blockchain.SubscribeChainHeadEvent(headCh)
-	defer headSub.Unsubscribe()
-
-	var (
-		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})
-		case <-h.closeCh:
-			return
-		}
-	}
-}

les/server_requests.go

@@ -1,566 +0,0 @@
-// Copyright 2021 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"encoding/binary"
-	"encoding/json"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/state"
-	"github.com/ethereum/go-ethereum/core/txpool"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/metrics"
-	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/ethereum/go-ethereum/trie"
-	"github.com/ethereum/go-ethereum/trie/trienode"
-)
-
-// serverBackend defines the backend functions needed for serving LES requests
-type serverBackend interface {
-	ArchiveMode() bool
-	AddTxsSync() bool
-	BlockChain() *core.BlockChain
-	TxPool() *txpool.TxPool
-	GetHelperTrie(typ uint, index uint64) *trie.Trie
-}
-
-// Decoder is implemented by the messages passed to the handler functions
-type Decoder interface {
-	Decode(val interface{}) error
-}
-
-// RequestType is a static struct that describes an LES request type and references
-// its handler function.
-type RequestType struct {
-	Name                                                             string
-	MaxCount                                                         uint64
-	InPacketsMeter, InTrafficMeter, OutPacketsMeter, OutTrafficMeter metrics.Meter
-	ServingTimeMeter                                                 metrics.Timer
-	Handle                                                           func(msg Decoder) (serve serveRequestFn, reqID, amount uint64, err error)
-}
-
-// serveRequestFn is returned by the request handler functions after decoding the request.
-// This function does the actual request serving using the supplied backend. waitOrStop is
-// called between serving individual request items and may block if the serving process
-// needs to be throttled. If it returns false then the process is terminated.
-// The reply is not sent by this function yet. The flow control feedback value is supplied
-// by the protocol handler when calling the send function of the returned reply struct.
-type serveRequestFn func(backend serverBackend, peer *clientPeer, waitOrStop func() bool) *reply
-
-// Les3 contains the request types supported by les/2 and les/3
-var Les3 = map[uint64]RequestType{
-	GetBlockHeadersMsg: {
-		Name:             "block header request",
-		MaxCount:         MaxHeaderFetch,
-		InPacketsMeter:   miscInHeaderPacketsMeter,
-		InTrafficMeter:   miscInHeaderTrafficMeter,
-		OutPacketsMeter:  miscOutHeaderPacketsMeter,
-		OutTrafficMeter:  miscOutHeaderTrafficMeter,
-		ServingTimeMeter: miscServingTimeHeaderTimer,
-		Handle:           handleGetBlockHeaders,
-	},
-	GetBlockBodiesMsg: {
-		Name:             "block bodies request",
-		MaxCount:         MaxBodyFetch,
-		InPacketsMeter:   miscInBodyPacketsMeter,
-		InTrafficMeter:   miscInBodyTrafficMeter,
-		OutPacketsMeter:  miscOutBodyPacketsMeter,
-		OutTrafficMeter:  miscOutBodyTrafficMeter,
-		ServingTimeMeter: miscServingTimeBodyTimer,
-		Handle:           handleGetBlockBodies,
-	},
-	GetCodeMsg: {
-		Name:             "code request",
-		MaxCount:         MaxCodeFetch,
-		InPacketsMeter:   miscInCodePacketsMeter,
-		InTrafficMeter:   miscInCodeTrafficMeter,
-		OutPacketsMeter:  miscOutCodePacketsMeter,
-		OutTrafficMeter:  miscOutCodeTrafficMeter,
-		ServingTimeMeter: miscServingTimeCodeTimer,
-		Handle:           handleGetCode,
-	},
-	GetReceiptsMsg: {
-		Name:             "receipts request",
-		MaxCount:         MaxReceiptFetch,
-		InPacketsMeter:   miscInReceiptPacketsMeter,
-		InTrafficMeter:   miscInReceiptTrafficMeter,
-		OutPacketsMeter:  miscOutReceiptPacketsMeter,
-		OutTrafficMeter:  miscOutReceiptTrafficMeter,
-		ServingTimeMeter: miscServingTimeReceiptTimer,
-		Handle:           handleGetReceipts,
-	},
-	GetProofsV2Msg: {
-		Name:             "les/2 proofs request",
-		MaxCount:         MaxProofsFetch,
-		InPacketsMeter:   miscInTrieProofPacketsMeter,
-		InTrafficMeter:   miscInTrieProofTrafficMeter,
-		OutPacketsMeter:  miscOutTrieProofPacketsMeter,
-		OutTrafficMeter:  miscOutTrieProofTrafficMeter,
-		ServingTimeMeter: miscServingTimeTrieProofTimer,
-		Handle:           handleGetProofs,
-	},
-	GetHelperTrieProofsMsg: {
-		Name:             "helper trie proof request",
-		MaxCount:         MaxHelperTrieProofsFetch,
-		InPacketsMeter:   miscInHelperTriePacketsMeter,
-		InTrafficMeter:   miscInHelperTrieTrafficMeter,
-		OutPacketsMeter:  miscOutHelperTriePacketsMeter,
-		OutTrafficMeter:  miscOutHelperTrieTrafficMeter,
-		ServingTimeMeter: miscServingTimeHelperTrieTimer,
-		Handle:           handleGetHelperTrieProofs,
-	},
-	SendTxV2Msg: {
-		Name:             "new transactions",
-		MaxCount:         MaxTxSend,
-		InPacketsMeter:   miscInTxsPacketsMeter,
-		InTrafficMeter:   miscInTxsTrafficMeter,
-		OutPacketsMeter:  miscOutTxsPacketsMeter,
-		OutTrafficMeter:  miscOutTxsTrafficMeter,
-		ServingTimeMeter: miscServingTimeTxTimer,
-		Handle:           handleSendTx,
-	},
-	GetTxStatusMsg: {
-		Name:             "transaction status query request",
-		MaxCount:         MaxTxStatus,
-		InPacketsMeter:   miscInTxStatusPacketsMeter,
-		InTrafficMeter:   miscInTxStatusTrafficMeter,
-		OutPacketsMeter:  miscOutTxStatusPacketsMeter,
-		OutTrafficMeter:  miscOutTxStatusTrafficMeter,
-		ServingTimeMeter: miscServingTimeTxStatusTimer,
-		Handle:           handleGetTxStatus,
-	},
-}
-
-// handleGetBlockHeaders handles a block header request
-func handleGetBlockHeaders(msg Decoder) (serveRequestFn, uint64, uint64, error) {
-	var r GetBlockHeadersPacket
-	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 (
-			bc              = backend.BlockChain()
-			hashMode        = r.Query.Origin.Hash != (common.Hash{})
-			first           = true
-			maxNonCanonical = uint64(100)
-			bytes           common.StorageSize
-			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)
-					if origin != nil {
-						r.Query.Origin.Number = origin.Number.Uint64()
-					}
-				} else {
-					origin = bc.GetHeader(r.Query.Origin.Hash, r.Query.Origin.Number)
-				}
-			} else {
-				origin = bc.GetHeaderByNumber(r.Query.Origin.Number)
-			}
-			if origin == nil {
-				break
-			}
-			headers = append(headers, origin)
-			bytes += estHeaderRlpSize
-
-			// Advance to the next header of the r
-			switch {
-			case hashMode && r.Query.Reverse:
-				// Hash based traversal towards the genesis block
-				ancestor := r.Query.Skip + 1
-				if ancestor == 0 {
-					unknown = true
-				} else {
-					r.Query.Origin.Hash, r.Query.Origin.Number = bc.GetAncestor(r.Query.Origin.Hash, r.Query.Origin.Number, ancestor, &maxNonCanonical)
-					unknown = r.Query.Origin.Hash == common.Hash{}
-				}
-			case hashMode && !r.Query.Reverse:
-				// Hash based traversal towards the leaf block
-				var (
-					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 {
-							unknown = true
-						}
-					} else {
-						unknown = true
-					}
-				}
-			case r.Query.Reverse:
-				// Number based traversal towards the genesis block
-				if r.Query.Origin.Number >= r.Query.Skip+1 {
-					r.Query.Origin.Number -= r.Query.Skip + 1
-				} else {
-					unknown = true
-				}
-
-			case !r.Query.Reverse:
-				// 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
-}
-
-// handleGetBlockBodies handles a block body request
-func handleGetBlockBodies(msg Decoder) (serveRequestFn, uint64, uint64, error) {
-	var r GetBlockBodiesPacket
-	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
-}
-
-// handleGetCode handles a contract code request
-func handleGetCode(msg Decoder) (serveRequestFn, uint64, uint64, error) {
-	var r GetCodePacket
-	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
-			}
-			// Look up the root hash belonging to the request
-			header := bc.GetHeaderByHash(request.BHash)
-			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
-			// a non-exist key is kind of expensive.
-			local := bc.CurrentHeader().Number.Uint64()
-			if !backend.ArchiveMode() && header.Number.Uint64()+core.TriesInMemory <= local {
-				p.Log().Debug("Reject stale code request", "number", header.Number.Uint64(), "head", local)
-				p.bumpInvalid()
-				continue
-			}
-			address := common.BytesToAddress(request.AccountAddress)
-			account, err := getAccount(bc.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))
-			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
-}
-
-// handleGetReceipts handles a block receipts request
-func handleGetReceipts(msg Decoder) (serveRequestFn, uint64, uint64, error) {
-	var r GetReceiptsPacket
-	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
-			}
-			// Retrieve the requested block's receipts, skipping if unknown to us
-			results := bc.GetReceiptsByHash(hash)
-			if results == nil {
-				if header := bc.GetHeaderByHash(hash); header == nil || header.ReceiptHash != types.EmptyReceiptsHash {
-					p.bumpInvalid()
-					continue
-				}
-			}
-			// If known, encode and queue for response packet
-			if encoded, err := rlp.EncodeToBytes(results); err != nil {
-				log.Error("Failed to encode receipt", "err", err)
-			} else {
-				receipts = append(receipts, encoded)
-				bytes += len(encoded)
-			}
-		}
-		return p.replyReceiptsRLP(r.ReqID, receipts)
-	}, r.ReqID, uint64(len(r.Hashes)), nil
-}
-
-// handleGetProofs handles a proof request
-func handleGetProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
-	var r GetProofsPacket
-	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
-			root      common.Hash
-			header    *types.Header
-			err       error
-		)
-		bc := backend.BlockChain()
-		nodes := trienode.NewProofSet()
-
-		for i, request := range r.Reqs {
-			if i != 0 && !waitOrStop() {
-				return nil
-			}
-			// Look up the root hash belonging to the request
-			if request.BHash != lastBHash {
-				root, lastBHash = common.Hash{}, request.BHash
-
-				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
-				// a non-exist key is kind of expensive.
-				local := bc.CurrentHeader().Number.Uint64()
-				if !backend.ArchiveMode() && header.Number.Uint64()+core.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
-			if root == (common.Hash{}) {
-				p.bumpInvalid()
-				continue
-			}
-			// Open the account or storage trie for the request
-			statedb := bc.StateCache()
-
-			var trie state.Trie
-			switch len(request.AccountAddress) {
-			case 0:
-				// No account key specified, open an account trie
-				trie, err = statedb.OpenTrie(root)
-				if trie == nil || err != nil {
-					p.Log().Warn("Failed to open storage trie for proof", "block", header.Number, "hash", header.Hash(), "root", root, "err", err)
-					continue
-				}
-			default:
-				// Account key specified, open a storage trie
-				address := common.BytesToAddress(request.AccountAddress)
-				account, err := getAccount(bc.TrieDB(), root, address)
-				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, nil)
-				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
-				}
-			}
-			// Prove the user's request from the account or storage trie
-			if err := trie.Prove(request.Key, nodes); err != nil {
-				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.List())
-	}, r.ReqID, uint64(len(r.Reqs)), nil
-}
-
-// handleGetHelperTrieProofs handles a helper trie proof request
-func handleGetHelperTrieProofs(msg Decoder) (serveRequestFn, uint64, uint64, error) {
-	var r GetHelperTrieProofsPacket
-	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
-			lastType uint
-			auxTrie  *trie.Trie
-			auxBytes int
-			auxData  [][]byte
-		)
-		bc := backend.BlockChain()
-		nodes := trienode.NewProofSet()
-		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
-			}
-			// TODO(rjl493456442) short circuit if the proving is failed.
-			// The original client side code has a dirty hack to retrieve
-			// the headers with no valid proof. Keep the compatibility for
-			// legacy les protocol and drop this hack when the les2/3 are
-			// not supported.
-			err := auxTrie.Prove(request.Key, nodes)
-			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.List(), AuxData: auxData})
-	}, r.ReqID, uint64(len(r.Reqs)), nil
-}
-
-// handleSendTx handles a transaction propagation request
-func handleSendTx(msg Decoder) (serveRequestFn, uint64, uint64, error) {
-	var r SendTxPacket
-	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 {
-				if errs := backend.TxPool().Add([]*types.Transaction{tx}, false, backend.AddTxsSync()); 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
-}
-
-// handleGetTxStatus handles a transaction status query
-func handleGetTxStatus(msg Decoder) (serveRequestFn, uint64, uint64, error) {
-	var r GetTxStatusPacket
-	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
-}
-
-// txStatus returns the status of a specified transaction.
-func txStatus(b serverBackend, hash common.Hash) light.TxStatus {
-	var stat light.TxStatus
-	// Looking the transaction in txpool first.
-	stat.Status = b.TxPool().Status(hash)
-
-	// If the transaction is unknown to the pool, try looking it up locally.
-	if stat.Status == txpool.TxStatusUnknown {
-		lookup := b.BlockChain().GetTransactionLookup(hash)
-		if lookup != nil {
-			stat.Status = txpool.TxStatusIncluded
-			stat.Lookup = lookup
-		}
-	}
-	return stat
-}

les/servingqueue.go

@@ -1,365 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"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
-// waiting tasks in a priority queue
-type servingQueue struct {
-	recentTime, queuedTime     uint64
-	servingTimeDiff            atomic.Uint64
-	burstLimit, burstDropLimit uint64
-	burstDecRate               float64
-	lastUpdate                 mclock.AbsTime
-
-	queueAddCh, queueBestCh chan *servingTask
-	stopThreadCh, quit      chan struct{}
-	setThreadsCh            chan int
-
-	wg          sync.WaitGroup
-	threadCount int                               // number of currently running threads
-	queue       *prque.Prque[int64, *servingTask] // priority queue for waiting or suspended tasks
-	best        *servingTask                      // the highest priority task (not included in the queue)
-	suspendBias int64                             // priority bias against suspending an already running task
-}
-
-// servingTask represents a request serving task. Tasks can be implemented to
-// run in multiple steps, allowing the serving queue to suspend execution between
-// steps if higher priority tasks are entered. The creator of the task should
-// set the following fields:
-//
-// - priority: greater value means higher priority; values can wrap around the int64 range
-// - run: execute a single step; return true if finished
-// - after: executed after run finishes or returns an error, receives the total serving time
-type servingTask struct {
-	sq                                       *servingQueue
-	servingTime, timeAdded, maxTime, expTime uint64
-	peer                                     *clientPeer
-	priority                                 int64
-	biasAdded                                bool
-	token                                    runToken
-	tokenCh                                  chan runToken
-}
-
-// runToken received by servingTask.start allows the task to run. Closing the
-// channel by servingTask.stop signals the thread controller to allow a new task
-// to start running.
-type runToken chan struct{}
-
-// start blocks until the task can start and returns true if it is allowed to run.
-// Returning false means that the task should be cancelled.
-func (t *servingTask) start() bool {
-	if t.peer.isFrozen() {
-		return false
-	}
-	t.tokenCh = make(chan runToken, 1)
-	select {
-	case t.sq.queueAddCh <- t:
-	case <-t.sq.quit:
-		return false
-	}
-	select {
-	case t.token = <-t.tokenCh:
-	case <-t.sq.quit:
-		return false
-	}
-	if t.token == nil {
-		return false
-	}
-	t.servingTime -= uint64(mclock.Now())
-	return true
-}
-
-// done signals the thread controller about the task being finished and returns
-// the total serving time of the task in nanoseconds.
-func (t *servingTask) done() uint64 {
-	t.servingTime += uint64(mclock.Now())
-	close(t.token)
-	diff := t.servingTime - t.timeAdded
-	t.timeAdded = t.servingTime
-	if t.expTime > diff {
-		t.expTime -= diff
-		t.sq.servingTimeDiff.Add(t.expTime)
-	} else {
-		t.expTime = 0
-	}
-	return t.servingTime
-}
-
-// waitOrStop can be called during the execution of the task. It blocks if there
-// is a higher priority task waiting (a bias is applied in favor of the currently
-// running task). Returning true means that the execution can be resumed. False
-// 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()
-}
-
-// newServingQueue returns a new servingQueue
-func newServingQueue(suspendBias int64, utilTarget float64) *servingQueue {
-	sq := &servingQueue{
-		queue:          prque.New[int64, *servingTask](nil),
-		suspendBias:    suspendBias,
-		queueAddCh:     make(chan *servingTask, 100),
-		queueBestCh:    make(chan *servingTask),
-		stopThreadCh:   make(chan struct{}),
-		quit:           make(chan struct{}),
-		setThreadsCh:   make(chan int, 10),
-		burstLimit:     uint64(utilTarget * bufLimitRatio * 1200000),
-		burstDropLimit: uint64(utilTarget * bufLimitRatio * 1000000),
-		burstDecRate:   utilTarget,
-		lastUpdate:     mclock.Now(),
-	}
-	sq.wg.Add(2)
-	go sq.queueLoop()
-	go sq.threadCountLoop()
-	return sq
-}
-
-// newTask creates a new task with the given priority
-func (sq *servingQueue) newTask(peer *clientPeer, maxTime uint64, priority int64) *servingTask {
-	return &servingTask{
-		sq:       sq,
-		peer:     peer,
-		maxTime:  maxTime,
-		expTime:  maxTime,
-		priority: priority,
-	}
-}
-
-// threadController is started in multiple goroutines and controls the execution
-// of tasks. The number of active thread controllers equals the allowed number of
-// concurrently running threads. It tries to fetch the highest priority queued
-// task first. If there are no queued tasks waiting then it can directly catch
-// run tokens from the token channel and allow the corresponding tasks to run
-// without entering the priority queue.
-func (sq *servingQueue) threadController() {
-	defer sq.wg.Done()
-	for {
-		token := make(runToken)
-		select {
-		case best := <-sq.queueBestCh:
-			best.tokenCh <- token
-		case <-sq.stopThreadCh:
-			return
-		case <-sq.quit:
-			return
-		}
-		select {
-		case <-sq.stopThreadCh:
-			return
-		case <-sq.quit:
-			return
-		case <-token:
-		}
-	}
-}
-
-// peerTasks lists the tasks received from a given peer when selecting peers to freeze
-type peerTasks struct {
-	peer     *clientPeer
-	list     []*servingTask
-	sumTime  uint64
-	priority float64
-}
-
-// freezePeers selects the peers with the worst priority queued tasks and freezes
-// them until burstTime goes under burstDropLimit or all peers are frozen
-func (sq *servingQueue) freezePeers() {
-	peerMap := make(map[*clientPeer]*peerTasks)
-	var peerList []*peerTasks
-	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
-			}
-			peerMap[task.peer] = tasks
-			peerList = append(peerList, tasks)
-		}
-		tasks.list = append(tasks.list, task)
-		tasks.sumTime += task.expTime
-	}
-	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 {
-			tasks.peer.freeze()
-			tasks.peer.fcClient.Freeze()
-			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
-			}
-		} else {
-			for _, task := range tasks.list {
-				sq.queue.Push(task, task.priority)
-			}
-		}
-	}
-	if sq.queue.Size() > 0 {
-		sq.best = sq.queue.PopItem()
-	}
-}
-
-// updateRecentTime recalculates the recent serving time value
-func (sq *servingQueue) updateRecentTime() {
-	subTime := sq.servingTimeDiff.Swap(0)
-	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 {
-		sq.recentTime = 0
-	}
-}
-
-// addTask inserts a task into the priority queue
-func (sq *servingQueue) addTask(task *servingTask) {
-	if sq.best == nil {
-		sq.best = task
-	} else if task.priority-sq.best.priority > 0 {
-		sq.queue.Push(sq.best, sq.best.priority)
-		sq.best = task
-	} 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()
-	}
-}
-
-// queueLoop is an event loop running in a goroutine. It receives tasks from queueAddCh
-// and always tries to send the highest priority task to queueBestCh. Successfully sent
-// tasks are removed from the queue.
-func (sq *servingQueue) queueLoop() {
-	defer sq.wg.Done()
-	for {
-		if sq.best != nil {
-			expTime := sq.best.expTime
-			select {
-			case task := <-sq.queueAddCh:
-				sq.addTask(task)
-			case sq.queueBestCh <- sq.best:
-				sq.updateRecentTime()
-				sq.queuedTime -= expTime
-				sq.recentTime += expTime
-				sqServedGauge.Update(int64(sq.recentTime))
-				sqQueuedGauge.Update(int64(sq.queuedTime))
-				if sq.queue.Size() == 0 {
-					sq.best = nil
-				} else {
-					sq.best = sq.queue.PopItem()
-				}
-			case <-sq.quit:
-				return
-			}
-		} else {
-			select {
-			case task := <-sq.queueAddCh:
-				sq.addTask(task)
-			case <-sq.quit:
-				return
-			}
-		}
-	}
-}
-
-// threadCountLoop is an event loop running in a goroutine. It adjusts the number
-// 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:
-			case sq.stopThreadCh <- struct{}{}:
-				sq.threadCount--
-			case <-sq.quit:
-				return
-			}
-		} else {
-			select {
-			case threadCountTarget = <-sq.setThreadsCh:
-			case <-sq.quit:
-				return
-			}
-		}
-	}
-}
-
-// setThreads sets the allowed processing thread count, suspending tasks as soon as
-// possible if necessary.
-func (sq *servingQueue) setThreads(threadCount int) {
-	select {
-	case sq.setThreadsCh <- threadCount:
-	case <-sq.quit:
-		return
-	}
-}
-
-// stop stops task processing as soon as possible and shuts down the serving queue.
-func (sq *servingQueue) stop() {
-	close(sq.quit)
-	sq.wg.Wait()
-}

les/state_accessor.go

@@ -1,80 +0,0 @@
-// Copyright 2021 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package les
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/state"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/eth/tracers"
-	"github.com/ethereum/go-ethereum/light"
-)
-
-// noopReleaser is returned in case there is no operation expected
-// for releasing state.
-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, 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) {
-	// Short circuit if it's genesis block.
-	if block.NumberU64() == 0 {
-		return nil, vm.BlockContext{}, nil, nil, errors.New("no transaction in genesis")
-	}
-	// Create the parent state database
-	parent, err := leth.blockchain.GetBlock(ctx, block.ParentHash(), block.NumberU64()-1)
-	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
-	}
-	// Recompute transactions up to the target index.
-	signer := types.MakeSigner(leth.blockchain.Config(), block.Number(), block.Time())
-	for idx, tx := range block.Transactions() {
-		// Assemble the transaction call message and return if the requested offset
-		msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
-		txContext := core.NewEVMTxContext(msg)
-		context := core.NewEVMBlockContext(block.Header(), leth.blockchain, nil)
-		statedb.SetTxContext(tx.Hash(), idx)
-		if idx == txIndex {
-			return msg, context, statedb, release, nil
-		}
-		// Not yet the searched for transaction, execute on top of the current state
-		vmenv := vm.NewEVM(context, txContext, statedb, leth.blockchain.Config(), vm.Config{})
-		if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas())); 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

@@ -1,626 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// This file contains some shares testing functionality, common to multiple
-// different files and modules being tested. Client based network and Server
-// based network can be created easily with available APIs.
-
-package les
-
-import (
-	"context"
-	"crypto/rand"
-	"fmt"
-	"math/big"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/consensus"
-	"github.com/ethereum/go-ethereum/consensus/ethash"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/forkid"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/core/txpool"
-	"github.com/ethereum/go-ethereum/core/txpool/legacypool"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/eth/ethconfig"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/event"
-	"github.com/ethereum/go-ethereum/les/flowcontrol"
-	vfs "github.com/ethereum/go-ethereum/les/vflux/server"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/trie"
-)
-
-var (
-	bankKey, _ = crypto.GenerateKey()
-	bankAddr   = crypto.PubkeyToAddress(bankKey.PublicKey)
-	bankFunds  = big.NewInt(1_000_000_000_000_000_000)
-
-	userKey1, _ = crypto.GenerateKey()
-	userKey2, _ = crypto.GenerateKey()
-	userAddr1   = crypto.PubkeyToAddress(userKey1.PublicKey)
-	userAddr2   = crypto.PubkeyToAddress(userKey2.PublicKey)
-
-	testContractAddr         common.Address
-	testContractCode         = common.Hex2Bytes("606060405260cc8060106000396000f360606040526000357c01000000000000000000000000000000000000000000000000000000009004806360cd2685146041578063c16431b914606b57603f565b005b6055600480803590602001909190505060a9565b6040518082815260200191505060405180910390f35b60886004808035906020019091908035906020019091905050608a565b005b80600060005083606481101560025790900160005b50819055505b5050565b6000600060005082606481101560025790900160005b5054905060c7565b91905056")
-	testContractCodeDeployed = testContractCode[16:]
-	testContractDeployed     = uint64(2)
-
-	testEventEmitterCode = common.Hex2Bytes("60606040523415600e57600080fd5b7f57050ab73f6b9ebdd9f76b8d4997793f48cf956e965ee070551b9ca0bb71584e60405160405180910390a160358060476000396000f3006060604052600080fd00a165627a7a723058203f727efcad8b5811f8cb1fc2620ce5e8c63570d697aef968172de296ea3994140029")
-
-	// Checkpoint oracle relative fields
-	signerKey, _ = crypto.GenerateKey()
-	signerAddr   = crypto.PubkeyToAddress(signerKey.PublicKey)
-)
-
-var (
-	// The token bucket buffer limit for testing purpose.
-	testBufLimit = uint64(1000000)
-
-	// The buffer recharging speed for testing purpose.
-	testBufRecharge = uint64(1000)
-)
-
-/*
-contract test {
-
-    uint256[100] data;
-
-    function Put(uint256 addr, uint256 value) {
-        data[addr] = value;
-    }
-
-    function Get(uint256 addr) constant returns (uint256 value) {
-        return data[addr];
-    }
-}
-*/
-
-// prepare pre-commits specified number customized blocks into chain.
-func prepare(n int, backend *backends.SimulatedBackend) {
-	var (
-		ctx    = context.Background()
-		signer = types.HomesteadSigner{}
-	)
-	for i := 0; i < n; i++ {
-		switch i {
-		case 0:
-			// Builtin-block
-			//    number: 1
-			//    txs:    1
-
-			// bankUser transfers some ether to user1
-			nonce, _ := backend.PendingNonceAt(ctx, bankAddr)
-			tx, _ := types.SignTx(types.NewTransaction(nonce, userAddr1, big.NewInt(10_000_000_000_000_000), params.TxGas, big.NewInt(params.InitialBaseFee), nil), signer, bankKey)
-			backend.SendTransaction(ctx, tx)
-		case 1:
-			// Builtin-block
-			//    number: 2
-			//    txs:    4
-
-			bankNonce, _ := backend.PendingNonceAt(ctx, bankAddr)
-			userNonce1, _ := backend.PendingNonceAt(ctx, userAddr1)
-
-			// bankUser transfers more ether to user1
-			tx1, _ := types.SignTx(types.NewTransaction(bankNonce, userAddr1, big.NewInt(1_000_000_000_000_000), params.TxGas, big.NewInt(params.InitialBaseFee), nil), signer, bankKey)
-			backend.SendTransaction(ctx, tx1)
-
-			// user1 relays ether to user2
-			tx2, _ := types.SignTx(types.NewTransaction(userNonce1, userAddr2, big.NewInt(1_000_000_000_000_000), params.TxGas, big.NewInt(params.InitialBaseFee), nil), signer, userKey1)
-			backend.SendTransaction(ctx, tx2)
-
-			// user1 deploys a test contract
-			tx3, _ := types.SignTx(types.NewContractCreation(userNonce1+1, big.NewInt(0), 200000, big.NewInt(params.InitialBaseFee), testContractCode), signer, userKey1)
-			backend.SendTransaction(ctx, tx3)
-			testContractAddr = crypto.CreateAddress(userAddr1, userNonce1+1)
-
-			// user1 deploys a event contract
-			tx4, _ := types.SignTx(types.NewContractCreation(userNonce1+2, big.NewInt(0), 200000, big.NewInt(params.InitialBaseFee), testEventEmitterCode), signer, userKey1)
-			backend.SendTransaction(ctx, tx4)
-		case 2:
-			// Builtin-block
-			//    number: 3
-			//    txs:    2
-
-			// bankUser transfer some ether to signer
-			bankNonce, _ := backend.PendingNonceAt(ctx, bankAddr)
-			tx1, _ := types.SignTx(types.NewTransaction(bankNonce, signerAddr, big.NewInt(1000000000), params.TxGas, big.NewInt(params.InitialBaseFee), nil), signer, bankKey)
-			backend.SendTransaction(ctx, tx1)
-
-			// invoke test contract
-			data := common.Hex2Bytes("C16431B900000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001")
-			tx2, _ := types.SignTx(types.NewTransaction(bankNonce+1, testContractAddr, big.NewInt(0), 100000, big.NewInt(params.InitialBaseFee), data), signer, bankKey)
-			backend.SendTransaction(ctx, tx2)
-		case 3:
-			// Builtin-block
-			//    number: 4
-			//    txs:    1
-
-			// invoke test contract
-			bankNonce, _ := backend.PendingNonceAt(ctx, bankAddr)
-			data := common.Hex2Bytes("C16431B900000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002")
-			tx, _ := types.SignTx(types.NewTransaction(bankNonce, testContractAddr, big.NewInt(0), 100000, big.NewInt(params.InitialBaseFee), data), signer, bankKey)
-			backend.SendTransaction(ctx, tx)
-		}
-		backend.Commit()
-	}
-}
-
-// testIndexers creates a set of indexers with specified params for testing purpose.
-func testIndexers(db ethdb.Database, odr light.OdrBackend, config *light.IndexerConfig, disablePruning bool) []*core.ChainIndexer {
-	var indexers [3]*core.ChainIndexer
-	indexers[0] = light.NewChtIndexer(db, odr, config.ChtSize, config.ChtConfirms, disablePruning)
-	indexers[1] = core.NewBloomIndexer(db, config.BloomSize, config.BloomConfirms)
-	indexers[2] = light.NewBloomTrieIndexer(db, odr, config.BloomSize, config.BloomTrieSize, disablePruning)
-	// make bloomTrieIndexer as a child indexer of bloom indexer.
-	indexers[1].AddChildIndexer(indexers[2])
-	return indexers[:]
-}
-
-func newTestClientHandler(backend *backends.SimulatedBackend, odr *LesOdr, indexers []*core.ChainIndexer, db ethdb.Database, peers *serverPeerSet) (*clientHandler, func()) {
-	var (
-		evmux  = new(event.TypeMux)
-		engine = ethash.NewFaker()
-		gspec  = core.Genesis{
-			Config:   params.AllEthashProtocolChanges,
-			Alloc:    core.GenesisAlloc{bankAddr: {Balance: bankFunds}},
-			GasLimit: 100000000,
-			BaseFee:  big.NewInt(params.InitialBaseFee),
-		}
-	)
-	genesis := gspec.MustCommit(db, trie.NewDatabase(db, trie.HashDefaults))
-	chain, _ := light.NewLightChain(odr, gspec.Config, engine)
-
-	client := &LightEthereum{
-		lesCommons: lesCommons{
-			genesis:     genesis.Hash(),
-			config:      &ethconfig.Config{LightPeers: 100, NetworkId: NetworkId},
-			chainConfig: params.AllEthashProtocolChanges,
-			iConfig:     light.TestClientIndexerConfig,
-			chainDb:     db,
-			chainReader: chain,
-			closeCh:     make(chan struct{}),
-		},
-		peers:      peers,
-		reqDist:    odr.retriever.dist,
-		retriever:  odr.retriever,
-		odr:        odr,
-		engine:     engine,
-		blockchain: chain,
-		eventMux:   evmux,
-		merger:     consensus.NewMerger(rawdb.NewMemoryDatabase()),
-	}
-	client.handler = newClientHandler(client)
-
-	return client.handler, func() {
-		client.handler.stop()
-	}
-}
-
-func newTestServerHandler(blocks int, indexers []*core.ChainIndexer, db ethdb.Database, clock mclock.Clock) (*serverHandler, *backends.SimulatedBackend, func()) {
-	var (
-		gspec = core.Genesis{
-			Config:   params.AllEthashProtocolChanges,
-			Alloc:    core.GenesisAlloc{bankAddr: {Balance: bankFunds}},
-			GasLimit: 100000000,
-			BaseFee:  big.NewInt(params.InitialBaseFee),
-		}
-	)
-	genesis := gspec.MustCommit(db, trie.NewDatabase(db, trie.HashDefaults))
-
-	// create a simulation backend and pre-commit several customized block to the database.
-	simulation := backends.NewSimulatedBackendWithDatabase(db, gspec.Alloc, 100000000)
-	prepare(blocks, simulation)
-
-	txpoolConfig := legacypool.DefaultConfig
-	txpoolConfig.Journal = ""
-
-	pool := legacypool.New(txpoolConfig, simulation.Blockchain())
-	txpool, _ := txpool.New(new(big.Int).SetUint64(txpoolConfig.PriceLimit), simulation.Blockchain(), []txpool.SubPool{pool})
-
-	server := &LesServer{
-		lesCommons: lesCommons{
-			genesis:     genesis.Hash(),
-			config:      &ethconfig.Config{LightPeers: 100, NetworkId: NetworkId},
-			chainConfig: params.AllEthashProtocolChanges,
-			iConfig:     light.TestServerIndexerConfig,
-			chainDb:     db,
-			chainReader: simulation.Blockchain(),
-			closeCh:     make(chan struct{}),
-		},
-		peers:        newClientPeerSet(),
-		servingQueue: newServingQueue(int64(time.Millisecond*10), 1),
-		defParams: flowcontrol.ServerParams{
-			BufLimit:    testBufLimit,
-			MinRecharge: testBufRecharge,
-		},
-		fcManager: flowcontrol.NewClientManager(nil, clock),
-	}
-	server.costTracker, server.minCapacity = newCostTracker(db, server.config)
-	server.costTracker.testCostList = testCostList(0) // Disable flow control mechanism.
-	server.clientPool = vfs.NewClientPool(db, testBufRecharge, defaultConnectedBias, clock, alwaysTrueFn)
-	server.clientPool.Start()
-	server.clientPool.SetLimits(10000, 10000) // Assign enough capacity for clientpool
-	server.handler = newServerHandler(server, simulation.Blockchain(), db, txpool, func() bool { return true })
-	server.servingQueue.setThreads(4)
-	server.handler.start()
-	closer := func() { server.Stop() }
-	return server.handler, simulation, closer
-}
-
-func alwaysTrueFn() bool {
-	return true
-}
-
-// testPeer is a simulated peer to allow testing direct network calls.
-type testPeer struct {
-	cpeer *clientPeer
-	speer *serverPeer
-
-	net p2p.MsgReadWriter // Network layer reader/writer to simulate remote messaging
-	app *p2p.MsgPipeRW    // Application layer reader/writer to simulate the local side
-}
-
-// handshakeWithServer executes the handshake with the remote server peer.
-func (p *testPeer) handshakeWithServer(t *testing.T, td *big.Int, head common.Hash, headNum uint64, genesis common.Hash, forkID forkid.ID) {
-	// It only works for the simulated client peer
-	if p.cpeer == nil {
-		t.Fatal("handshake for client peer only")
-	}
-	var sendList keyValueList
-	sendList = sendList.add("protocolVersion", uint64(p.cpeer.version))
-	sendList = sendList.add("networkId", uint64(NetworkId))
-	sendList = sendList.add("headTd", td)
-	sendList = sendList.add("headHash", head)
-	sendList = sendList.add("headNum", headNum)
-	sendList = sendList.add("genesisHash", genesis)
-	if p.cpeer.version >= lpv4 {
-		sendList = sendList.add("forkID", &forkID)
-	}
-	if err := p2p.ExpectMsg(p.app, StatusMsg, nil); err != nil {
-		t.Fatalf("status recv: %v", err)
-	}
-	if err := p2p.Send(p.app, StatusMsg, &sendList); err != nil {
-		t.Fatalf("status send: %v", err)
-	}
-}
-
-// handshakeWithClient executes the handshake with the remote client peer.
-// (used by temporarily disabled tests)
-/*func (p *testPeer) handshakeWithClient(t *testing.T, td *big.Int, head common.Hash, headNum uint64, genesis common.Hash, forkID forkid.ID, costList RequestCostList, recentTxLookup uint64) {
-	// It only works for the simulated client peer
-	if p.speer == nil {
-		t.Fatal("handshake for server peer only")
-	}
-	var sendList keyValueList
-	sendList = sendList.add("protocolVersion", uint64(p.speer.version))
-	sendList = sendList.add("networkId", uint64(NetworkId))
-	sendList = sendList.add("headTd", td)
-	sendList = sendList.add("headHash", head)
-	sendList = sendList.add("headNum", headNum)
-	sendList = sendList.add("genesisHash", genesis)
-	sendList = sendList.add("serveHeaders", nil)
-	sendList = sendList.add("serveChainSince", uint64(0))
-	sendList = sendList.add("serveStateSince", uint64(0))
-	sendList = sendList.add("serveRecentState", uint64(core.TriesInMemory-4))
-	sendList = sendList.add("txRelay", nil)
-	sendList = sendList.add("flowControl/BL", testBufLimit)
-	sendList = sendList.add("flowControl/MRR", testBufRecharge)
-	sendList = sendList.add("flowControl/MRC", costList)
-	if p.speer.version >= lpv4 {
-		sendList = sendList.add("forkID", &forkID)
-		sendList = sendList.add("recentTxLookup", recentTxLookup)
-	}
-	if err := p2p.ExpectMsg(p.app, StatusMsg, nil); err != nil {
-		t.Fatalf("status recv: %v", err)
-	}
-	if err := p2p.Send(p.app, StatusMsg, &sendList); err != nil {
-		t.Fatalf("status send: %v", err)
-	}
-}*/
-
-// close terminates the local side of the peer, notifying the remote protocol
-// manager of termination.
-func (p *testPeer) close() {
-	p.app.Close()
-}
-
-func newTestPeerPair(name string, version int, server *serverHandler, client *clientHandler, noInitAnnounce bool) (*testPeer, *testPeer, error) {
-	// Create a message pipe to communicate through
-	app, net := p2p.MsgPipe()
-
-	// Generate a random id and create the peer
-	var id enode.ID
-	rand.Read(id[:])
-
-	peer1 := newClientPeer(version, NetworkId, p2p.NewPeer(id, name, nil), net)
-	peer2 := newServerPeer(version, NetworkId, false, p2p.NewPeer(id, name, nil), app)
-
-	// Start the peer on a new thread
-	errc1 := make(chan error, 1)
-	errc2 := make(chan error, 1)
-	go func() {
-		select {
-		case <-server.closeCh:
-			errc1 <- p2p.DiscQuitting
-		case errc1 <- server.handle(peer1):
-		}
-	}()
-	go func() {
-		select {
-		case <-client.closeCh:
-			errc2 <- p2p.DiscQuitting
-		case errc2 <- client.handle(peer2, noInitAnnounce):
-		}
-	}()
-	// Ensure the connection is established or exits when any error occurs
-	for {
-		select {
-		case err := <-errc1:
-			return nil, nil, fmt.Errorf("failed to establish protocol connection %v", err)
-		case err := <-errc2:
-			return nil, nil, fmt.Errorf("failed to establish protocol connection %v", err)
-		default:
-		}
-		if peer1.serving.Load() && peer2.serving.Load() {
-			break
-		}
-		time.Sleep(50 * time.Millisecond)
-	}
-	return &testPeer{cpeer: peer1, net: net, app: app}, &testPeer{speer: peer2, net: app, app: net}, nil
-}
-
-type indexerCallback func(*core.ChainIndexer, *core.ChainIndexer, *core.ChainIndexer)
-
-// testClient represents a client object for testing with necessary auxiliary fields.
-type testClient struct {
-	clock   mclock.Clock
-	db      ethdb.Database
-	peer    *testPeer
-	handler *clientHandler
-
-	chtIndexer       *core.ChainIndexer
-	bloomIndexer     *core.ChainIndexer
-	bloomTrieIndexer *core.ChainIndexer
-}
-
-// newRawPeer creates a new server peer connects to the server and do the handshake.
-// (used by temporarily disabled tests)
-/*func (client *testClient) newRawPeer(t *testing.T, name string, version int, recentTxLookup uint64) (*testPeer, func(), <-chan error) {
-	// Create a message pipe to communicate through
-	app, net := p2p.MsgPipe()
-
-	// Generate a random id and create the peer
-	var id enode.ID
-	rand.Read(id[:])
-	peer := newServerPeer(version, NetworkId, false, p2p.NewPeer(id, name, nil), net)
-
-	// Start the peer on a new thread
-	errCh := make(chan error, 1)
-	go func() {
-		select {
-		case <-client.handler.closeCh:
-			errCh <- p2p.DiscQuitting
-		case errCh <- client.handler.handle(peer, false):
-		}
-	}()
-	tp := &testPeer{
-		app:   app,
-		net:   net,
-		speer: peer,
-	}
-	var (
-		genesis = client.handler.backend.blockchain.Genesis()
-		head    = client.handler.backend.blockchain.CurrentHeader()
-		td      = client.handler.backend.blockchain.GetTd(head.Hash(), head.Number.Uint64())
-	)
-	forkID := forkid.NewID(client.handler.backend.blockchain.Config(), genesis.Hash(), head.Number.Uint64(), head.Time)
-	tp.handshakeWithClient(t, td, head.Hash(), head.Number.Uint64(), genesis.Hash(), forkID, testCostList(0), recentTxLookup) // disable flow control by default
-
-	// Ensure the connection is established or exits when any error occurs
-	for {
-		select {
-		case <-errCh:
-			return nil, nil, nil
-		default:
-		}
-		if peer.serving.Load() {
-			break
-		}
-		time.Sleep(50 * time.Millisecond)
-	}
-	closePeer := func() {
-		tp.speer.close()
-		tp.close()
-	}
-	return tp, closePeer, errCh
-}*/
-
-// testServer represents a server object for testing with necessary auxiliary fields.
-type testServer struct {
-	clock   mclock.Clock
-	backend *backends.SimulatedBackend
-	db      ethdb.Database
-	peer    *testPeer
-	handler *serverHandler
-
-	chtIndexer       *core.ChainIndexer
-	bloomIndexer     *core.ChainIndexer
-	bloomTrieIndexer *core.ChainIndexer
-}
-
-// newRawPeer creates a new client peer connects to the server and do the handshake.
-func (server *testServer) newRawPeer(t *testing.T, name string, version int) (*testPeer, func(), <-chan error) {
-	// Create a message pipe to communicate through
-	app, net := p2p.MsgPipe()
-
-	// Generate a random id and create the peer
-	var id enode.ID
-	rand.Read(id[:])
-	peer := newClientPeer(version, NetworkId, p2p.NewPeer(id, name, nil), net)
-
-	// Start the peer on a new thread
-	errCh := make(chan error, 1)
-	go func() {
-		select {
-		case <-server.handler.closeCh:
-			errCh <- p2p.DiscQuitting
-		case errCh <- server.handler.handle(peer):
-		}
-	}()
-	tp := &testPeer{
-		app:   app,
-		net:   net,
-		cpeer: peer,
-	}
-	var (
-		genesis = server.handler.blockchain.Genesis()
-		head    = server.handler.blockchain.CurrentHeader()
-		td      = server.handler.blockchain.GetTd(head.Hash(), head.Number.Uint64())
-	)
-	forkID := forkid.NewID(server.handler.blockchain.Config(), genesis, head.Number.Uint64(), head.Time)
-	tp.handshakeWithServer(t, td, head.Hash(), head.Number.Uint64(), genesis.Hash(), forkID)
-
-	// Ensure the connection is established or exits when any error occurs
-	for {
-		select {
-		case <-errCh:
-			return nil, nil, nil
-		default:
-		}
-		if peer.serving.Load() {
-			break
-		}
-		time.Sleep(50 * time.Millisecond)
-	}
-	closePeer := func() {
-		tp.cpeer.close()
-		tp.close()
-	}
-	return tp, closePeer, errCh
-}
-
-// testnetConfig wraps all the configurations for testing network.
-type testnetConfig struct {
-	blocks    int
-	protocol  int
-	indexFn   indexerCallback
-	simClock  bool
-	connect   bool
-	nopruning bool
-}
-
-func newClientServerEnv(t *testing.T, config testnetConfig) (*testServer, *testClient, func()) {
-	var (
-		sdb    = rawdb.NewMemoryDatabase()
-		cdb    = rawdb.NewMemoryDatabase()
-		speers = newServerPeerSet()
-	)
-	var clock mclock.Clock = &mclock.System{}
-	if config.simClock {
-		clock = &mclock.Simulated{}
-	}
-	dist := newRequestDistributor(speers, clock)
-	rm := newRetrieveManager(speers, dist, func() time.Duration { return time.Millisecond * 500 })
-	odr := NewLesOdr(cdb, light.TestClientIndexerConfig, speers, rm)
-
-	sindexers := testIndexers(sdb, nil, light.TestServerIndexerConfig, true)
-	cIndexers := testIndexers(cdb, odr, light.TestClientIndexerConfig, config.nopruning)
-
-	scIndexer, sbIndexer, sbtIndexer := sindexers[0], sindexers[1], sindexers[2]
-	ccIndexer, cbIndexer, cbtIndexer := cIndexers[0], cIndexers[1], cIndexers[2]
-	odr.SetIndexers(ccIndexer, cbIndexer, cbtIndexer)
-
-	server, b, serverClose := newTestServerHandler(config.blocks, sindexers, sdb, clock)
-	client, clientClose := newTestClientHandler(b, odr, cIndexers, cdb, speers)
-
-	scIndexer.Start(server.blockchain)
-	sbIndexer.Start(server.blockchain)
-	ccIndexer.Start(client.backend.blockchain)
-	cbIndexer.Start(client.backend.blockchain)
-
-	if config.indexFn != nil {
-		config.indexFn(scIndexer, sbIndexer, sbtIndexer)
-	}
-	var (
-		err          error
-		speer, cpeer *testPeer
-	)
-	if config.connect {
-		done := make(chan struct{})
-		cpeer, speer, err = newTestPeerPair("peer", config.protocol, server, client, false)
-		if err != nil {
-			t.Fatalf("Failed to connect testing peers %v", err)
-		}
-		select {
-		case <-done:
-		case <-time.After(10 * time.Second):
-			t.Fatal("test peer did not connect and sync within 3s")
-		}
-	}
-	s := &testServer{
-		clock:            clock,
-		backend:          b,
-		db:               sdb,
-		peer:             cpeer,
-		handler:          server,
-		chtIndexer:       scIndexer,
-		bloomIndexer:     sbIndexer,
-		bloomTrieIndexer: sbtIndexer,
-	}
-	c := &testClient{
-		clock:            clock,
-		db:               cdb,
-		peer:             speer,
-		handler:          client,
-		chtIndexer:       ccIndexer,
-		bloomIndexer:     cbIndexer,
-		bloomTrieIndexer: cbtIndexer,
-	}
-	teardown := func() {
-		if config.connect {
-			speer.close()
-			cpeer.close()
-			cpeer.cpeer.close()
-			speer.speer.close()
-		}
-		ccIndexer.Close()
-		cbIndexer.Close()
-		scIndexer.Close()
-		sbIndexer.Close()
-		dist.close()
-		serverClose()
-		b.Close()
-		clientClose()
-	}
-	return s, c, teardown
-}
-
-// NewFuzzerPeer creates a client peer for test purposes, and also returns
-// a function to close the peer: this is needed to avoid goroutine leaks in the
-// exec queue.
-func NewFuzzerPeer(version int) (p *clientPeer, closer func()) {
-	p = newClientPeer(version, 0, p2p.NewPeer(enode.ID{}, "", nil), nil)
-	return p, func() { p.peerCommons.close() }
-}