eth/gasprice: lighter gas price oracle for light client (#20409)

This PR reduces the bandwidth used by the light client to compute the
recommended gas price. The current mechanism for suggesting the price is:

- retrieve recent 20 blocks
- get the lowest gas price of these blocks
- sort the price array and return the middle(60%) one

This works for full nodes, which have all blocks available locally.
However, this is very expensive for the light client because the light
client needs to retrieve block bodies from the network.

The PR changes the default options for light client. With the new config,
the light client only retrieves the two latest blocks, but in order to
collect more sample transactions, the 3 lowest prices are collected from
each block.

This PR also changes the behavior for empty blocks. If the block is empty,
the lastest price is reused for sampling.

cmd/utils/flags.go

@@ -1286,7 +1286,13 @@ func setDataDir(ctx *cli.Context, cfg *node.Config) {
 	}
 }
 
-func setGPO(ctx *cli.Context, cfg *gasprice.Config) {
+func setGPO(ctx *cli.Context, cfg *gasprice.Config, light bool) {
+	// If we are running the light client, apply another group
+	// settings for gas oracle.
+	if light {
+		cfg.Blocks = eth.DefaultLightGPOConfig.Blocks
+		cfg.Percentile = eth.DefaultLightGPOConfig.Percentile
+	}
 	if ctx.GlobalIsSet(LegacyGpoBlocksFlag.Name) {
 		cfg.Blocks = ctx.GlobalInt(LegacyGpoBlocksFlag.Name)
 		log.Warn("The flag --gpoblocks is deprecated and will be removed in the future, please use --gpo.blocks")
@@ -1294,7 +1300,6 @@ func setGPO(ctx *cli.Context, cfg *gasprice.Config) {
 	if ctx.GlobalIsSet(GpoBlocksFlag.Name) {
 		cfg.Blocks = ctx.GlobalInt(GpoBlocksFlag.Name)
 	}
-
 	if ctx.GlobalIsSet(LegacyGpoPercentileFlag.Name) {
 		cfg.Percentile = ctx.GlobalInt(LegacyGpoPercentileFlag.Name)
 		log.Warn("The flag --gpopercentile is deprecated and will be removed in the future, please use --gpo.percentile")
@@ -1503,7 +1508,7 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) {
 		ks = keystores[0].(*keystore.KeyStore)
 	}
 	setEtherbase(ctx, ks, cfg)
-	setGPO(ctx, &cfg.GPO)
+	setGPO(ctx, &cfg.GPO, ctx.GlobalString(SyncModeFlag.Name) == "light")
 	setTxPool(ctx, &cfg.TxPool)
 	setEthash(ctx, cfg)
 	setMiner(ctx, &cfg.Miner)

eth/config.go

@@ -33,6 +33,18 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 )
 
+// DefaultFullGPOConfig contains default gasprice oracle settings for full node.
+var DefaultFullGPOConfig = gasprice.Config{
+	Blocks:     20,
+	Percentile: 60,
+}
+
+// DefaultLightGPOConfig contains default gasprice oracle settings for light client.
+var DefaultLightGPOConfig = gasprice.Config{
+	Blocks:     2,
+	Percentile: 60,
+}
+
 // DefaultConfig contains default settings for use on the Ethereum main net.
 var DefaultConfig = Config{
 	SyncMode: downloader.FastSync,
@@ -59,12 +71,9 @@ var DefaultConfig = Config{
 		GasPrice: big.NewInt(params.GWei),
 		Recommit: 3 * time.Second,
 	},
-	TxPool:    core.DefaultTxPoolConfig,
+	TxPool:      core.DefaultTxPoolConfig,
-	RPCGasCap: 25000000,
+	RPCGasCap:   25000000,
-	GPO: gasprice.Config{
+	GPO:         DefaultFullGPOConfig,
-		Blocks:     20,
-		Percentile: 60,
-	},
 	RPCTxFeeCap: 1, // 1 ether
 }
 

eth/gasprice/gasprice.go

@@ -24,11 +24,12 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/internal/ethapi"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
+const sampleNumber = 3 // Number of transactions sampled in a block
+
 var maxPrice = big.NewInt(500 * params.GWei)
 
 type Config struct {
@@ -37,21 +38,29 @@ type Config struct {
 	Default    *big.Int `toml:",omitempty"`
 }
 
+// OracleBackend includes all necessary background APIs for oracle.
+type OracleBackend interface {
+	HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error)
+	BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error)
+	ChainConfig() *params.ChainConfig
+}
+
 // Oracle recommends gas prices based on the content of recent
 // blocks. Suitable for both light and full clients.
 type Oracle struct {
-	backend   ethapi.Backend
+	backend   OracleBackend
 	lastHead  common.Hash
 	lastPrice *big.Int
 	cacheLock sync.RWMutex
 	fetchLock sync.Mutex
 
-	checkBlocks, maxEmpty, maxBlocks int
+	checkBlocks int
-	percentile                       int
+	percentile  int
 }
 
-// NewOracle returns a new oracle.
+// NewOracle returns a new gasprice oracle which can recommend suitable
-func NewOracle(backend ethapi.Backend, params Config) *Oracle {
+// gasprice for newly created transaction.
+func NewOracle(backend OracleBackend, params Config) *Oracle {
 	blocks := params.Blocks
 	if blocks < 1 {
 		blocks = 1
@@ -67,79 +76,79 @@ func NewOracle(backend ethapi.Backend, params Config) *Oracle {
 		backend:     backend,
 		lastPrice:   params.Default,
 		checkBlocks: blocks,
-		maxEmpty:    blocks / 2,
-		maxBlocks:   blocks * 5,
 		percentile:  percent,
 	}
 }
 
-// SuggestPrice returns the recommended gas price.
+// SuggestPrice returns a gasprice so that newly created transaction can
+// have a very high chance to be included in the following blocks.
 func (gpo *Oracle) SuggestPrice(ctx context.Context) (*big.Int, error) {
-	gpo.cacheLock.RLock()
-	lastHead := gpo.lastHead
-	lastPrice := gpo.lastPrice
-	gpo.cacheLock.RUnlock()
-
 	head, _ := gpo.backend.HeaderByNumber(ctx, rpc.LatestBlockNumber)
 	headHash := head.Hash()
+
+	// If the latest gasprice is still available, return it.
+	gpo.cacheLock.RLock()
+	lastHead, lastPrice := gpo.lastHead, gpo.lastPrice
+	gpo.cacheLock.RUnlock()
 	if headHash == lastHead {
 		return lastPrice, nil
 	}
-
 	gpo.fetchLock.Lock()
 	defer gpo.fetchLock.Unlock()
 
-	// try checking the cache again, maybe the last fetch fetched what we need
+	// Try checking the cache again, maybe the last fetch fetched what we need
 	gpo.cacheLock.RLock()
-	lastHead = gpo.lastHead
+	lastHead, lastPrice = gpo.lastHead, gpo.lastPrice
-	lastPrice = gpo.lastPrice
 	gpo.cacheLock.RUnlock()
 	if headHash == lastHead {
 		return lastPrice, nil
 	}
-
+	var (
-	blockNum := head.Number.Uint64()
+		sent, exp int
-	ch := make(chan getBlockPricesResult, gpo.checkBlocks)
+		number    = head.Number.Uint64()
-	sent := 0
+		result    = make(chan getBlockPricesResult, gpo.checkBlocks)
-	exp := 0
+		quit      = make(chan struct{})
-	var blockPrices []*big.Int
+		txPrices  []*big.Int
-	for sent < gpo.checkBlocks && blockNum > 0 {
+	)
-		go gpo.getBlockPrices(ctx, types.MakeSigner(gpo.backend.ChainConfig(), big.NewInt(int64(blockNum))), blockNum, ch)
+	for sent < gpo.checkBlocks && number > 0 {
+		go gpo.getBlockPrices(ctx, types.MakeSigner(gpo.backend.ChainConfig(), big.NewInt(int64(number))), number, sampleNumber, result, quit)
 		sent++
 		exp++
-		blockNum--
+		number--
 	}
-	maxEmpty := gpo.maxEmpty
 	for exp > 0 {
-		res := <-ch
+		res := <-result
 		if res.err != nil {
+			close(quit)
 			return lastPrice, res.err
 		}
 		exp--
-		if res.price != nil {
+		// Nothing returned. There are two special cases here:
-			blockPrices = append(blockPrices, res.price)
+		// - The block is empty
-			continue
+		// - All the transactions included are sent by the miner itself.
-		}
+		// In these cases, use the latest calculated price for samping.
-		if maxEmpty > 0 {
+		if len(res.prices) == 0 {
-			maxEmpty--
+			res.prices = []*big.Int{lastPrice}
-			continue
 		}
-		if blockNum > 0 && sent < gpo.maxBlocks {
+		// Besides, in order to collect enough data for sampling, if nothing
-			go gpo.getBlockPrices(ctx, types.MakeSigner(gpo.backend.ChainConfig(), big.NewInt(int64(blockNum))), blockNum, ch)
+		// meaningful returned, try to query more blocks. But the maximum
+		// is 2*checkBlocks.
+		if len(res.prices) == 1 && len(txPrices)+1+exp < gpo.checkBlocks*2 && number > 0 {
+			go gpo.getBlockPrices(ctx, types.MakeSigner(gpo.backend.ChainConfig(), big.NewInt(int64(number))), number, sampleNumber, result, quit)
 			sent++
 			exp++
-			blockNum--
+			number--
 		}
+		txPrices = append(txPrices, res.prices...)
 	}
 	price := lastPrice
-	if len(blockPrices) > 0 {
+	if len(txPrices) > 0 {
-		sort.Sort(bigIntArray(blockPrices))
+		sort.Sort(bigIntArray(txPrices))
-		price = blockPrices[(len(blockPrices)-1)*gpo.percentile/100]
+		price = txPrices[(len(txPrices)-1)*gpo.percentile/100]
 	}
 	if price.Cmp(maxPrice) > 0 {
 		price = new(big.Int).Set(maxPrice)
 	}
-
 	gpo.cacheLock.Lock()
 	gpo.lastHead = headHash
 	gpo.lastPrice = price
@@ -148,8 +157,8 @@ func (gpo *Oracle) SuggestPrice(ctx context.Context) (*big.Int, error) {
 }
 
 type getBlockPricesResult struct {
-	price *big.Int
+	prices []*big.Int
-	err   error
+	err    error
 }
 
 type transactionsByGasPrice []*types.Transaction
@@ -159,27 +168,37 @@ func (t transactionsByGasPrice) Swap(i, j int)      { t[i], t[j] = t[j], t[i] }
 func (t transactionsByGasPrice) Less(i, j int) bool { return t[i].GasPriceCmp(t[j]) < 0 }
 
 // getBlockPrices calculates the lowest transaction gas price in a given block
-// and sends it to the result channel. If the block is empty, price is nil.
+// and sends it to the result channel. If the block is empty or all transactions
-func (gpo *Oracle) getBlockPrices(ctx context.Context, signer types.Signer, blockNum uint64, ch chan getBlockPricesResult) {
+// are sent by the miner itself(it doesn't make any sense to include this kind of
+// transaction prices for sampling), nil gasprice is returned.
+func (gpo *Oracle) getBlockPrices(ctx context.Context, signer types.Signer, blockNum uint64, limit int, result chan getBlockPricesResult, quit chan struct{}) {
 	block, err := gpo.backend.BlockByNumber(ctx, rpc.BlockNumber(blockNum))
 	if block == nil {
-		ch <- getBlockPricesResult{nil, err}
+		select {
+		case result <- getBlockPricesResult{nil, err}:
+		case <-quit:
+		}
 		return
 	}
-
 	blockTxs := block.Transactions()
 	txs := make([]*types.Transaction, len(blockTxs))
 	copy(txs, blockTxs)
 	sort.Sort(transactionsByGasPrice(txs))
 
+	var prices []*big.Int
 	for _, tx := range txs {
 		sender, err := types.Sender(signer, tx)
 		if err == nil && sender != block.Coinbase() {
-			ch <- getBlockPricesResult{tx.GasPrice(), nil}
+			prices = append(prices, tx.GasPrice())
-			return
+			if len(prices) >= limit {
+				break
+			}
 		}
 	}
-	ch <- getBlockPricesResult{nil, nil}
+	select {
+	case result <- getBlockPricesResult{prices, nil}:
+	case <-quit:
+	}
 }
 
 type bigIntArray []*big.Int

eth/gasprice/gasprice_test.go

@@ -0,0 +1,118 @@
+// Copyright 2020 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 gasprice
+
+import (
+	"context"
+	"math"
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"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/types"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+type testBackend struct {
+	chain *core.BlockChain
+}
+
+func (b *testBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
+	if number == rpc.LatestBlockNumber {
+		return b.chain.CurrentBlock().Header(), nil
+	}
+	return b.chain.GetHeaderByNumber(uint64(number)), nil
+}
+
+func (b *testBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
+	if number == rpc.LatestBlockNumber {
+		return b.chain.CurrentBlock(), nil
+	}
+	return b.chain.GetBlockByNumber(uint64(number)), nil
+}
+
+func (b *testBackend) ChainConfig() *params.ChainConfig {
+	return b.chain.Config()
+}
+
+func newTestBackend(t *testing.T) *testBackend {
+	var (
+		key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+		addr   = crypto.PubkeyToAddress(key.PublicKey)
+		gspec  = &core.Genesis{
+			Config: params.TestChainConfig,
+			Alloc:  core.GenesisAlloc{addr: {Balance: big.NewInt(math.MaxInt64)}},
+		}
+		signer = types.NewEIP155Signer(gspec.Config.ChainID)
+	)
+	engine := ethash.NewFaker()
+	db := rawdb.NewMemoryDatabase()
+	genesis, _ := gspec.Commit(db)
+
+	// Generate testing blocks
+	blocks, _ := core.GenerateChain(params.TestChainConfig, genesis, engine, db, 32, func(i int, b *core.BlockGen) {
+		b.SetCoinbase(common.Address{1})
+		tx, err := types.SignTx(types.NewTransaction(b.TxNonce(addr), common.HexToAddress("deadbeef"), big.NewInt(100), 21000, big.NewInt(int64(i+1)*params.GWei), nil), signer, key)
+		if err != nil {
+			t.Fatalf("failed to create tx: %v", err)
+		}
+		b.AddTx(tx)
+	})
+	// Construct testing chain
+	diskdb := rawdb.NewMemoryDatabase()
+	gspec.Commit(diskdb)
+	chain, err := core.NewBlockChain(diskdb, nil, params.TestChainConfig, engine, vm.Config{}, nil, nil)
+	if err != nil {
+		t.Fatalf("Failed to create local chain, %v", err)
+	}
+	chain.InsertChain(blocks)
+	return &testBackend{chain: chain}
+}
+
+func (b *testBackend) CurrentHeader() *types.Header {
+	return b.chain.CurrentHeader()
+}
+
+func (b *testBackend) GetBlockByNumber(number uint64) *types.Block {
+	return b.chain.GetBlockByNumber(number)
+}
+
+func TestSuggestPrice(t *testing.T) {
+	config := Config{
+		Blocks:     3,
+		Percentile: 60,
+		Default:    big.NewInt(params.GWei),
+	}
+	backend := newTestBackend(t)
+	oracle := NewOracle(backend, config)
+
+	// The gas price sampled is: 32G, 31G, 30G, 29G, 28G, 27G
+	got, err := oracle.SuggestPrice(context.Background())
+	if err != nil {
+		t.Fatalf("Failed to retrieve recommended gas price: %v", err)
+	}
+	expect := big.NewInt(params.GWei * int64(30))
+	if got.Cmp(expect) != 0 {
+		t.Fatalf("Gas price mismatch, want %d, got %d", expect, got)
+	}
+}