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.
This commit is contained in:
gary rong 2020-07-03 20:50:35 +08:00 committed by GitHub
parent 07a95ce571
commit 61270e5e1c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 212 additions and 61 deletions

View File

@ -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) { if ctx.GlobalIsSet(LegacyGpoBlocksFlag.Name) {
cfg.Blocks = ctx.GlobalInt(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") 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) { if ctx.GlobalIsSet(GpoBlocksFlag.Name) {
cfg.Blocks = ctx.GlobalInt(GpoBlocksFlag.Name) cfg.Blocks = ctx.GlobalInt(GpoBlocksFlag.Name)
} }
if ctx.GlobalIsSet(LegacyGpoPercentileFlag.Name) { if ctx.GlobalIsSet(LegacyGpoPercentileFlag.Name) {
cfg.Percentile = ctx.GlobalInt(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") 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) ks = keystores[0].(*keystore.KeyStore)
} }
setEtherbase(ctx, ks, cfg) setEtherbase(ctx, ks, cfg)
setGPO(ctx, &cfg.GPO) setGPO(ctx, &cfg.GPO, ctx.GlobalString(SyncModeFlag.Name) == "light")
setTxPool(ctx, &cfg.TxPool) setTxPool(ctx, &cfg.TxPool)
setEthash(ctx, cfg) setEthash(ctx, cfg)
setMiner(ctx, &cfg.Miner) setMiner(ctx, &cfg.Miner)

View File

@ -33,6 +33,18 @@ import (
"github.com/ethereum/go-ethereum/params" "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. // DefaultConfig contains default settings for use on the Ethereum main net.
var DefaultConfig = Config{ var DefaultConfig = Config{
SyncMode: downloader.FastSync, SyncMode: downloader.FastSync,
@ -59,12 +71,9 @@ var DefaultConfig = Config{
GasPrice: big.NewInt(params.GWei), GasPrice: big.NewInt(params.GWei),
Recommit: 3 * time.Second, 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 RPCTxFeeCap: 1, // 1 ether
} }

View File

@ -24,11 +24,12 @@ import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types" "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/params"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
) )
const sampleNumber = 3 // Number of transactions sampled in a block
var maxPrice = big.NewInt(500 * params.GWei) var maxPrice = big.NewInt(500 * params.GWei)
type Config struct { type Config struct {
@ -37,21 +38,29 @@ type Config struct {
Default *big.Int `toml:",omitempty"` 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 // Oracle recommends gas prices based on the content of recent
// blocks. Suitable for both light and full clients. // blocks. Suitable for both light and full clients.
type Oracle struct { type Oracle struct {
backend ethapi.Backend backend OracleBackend
lastHead common.Hash lastHead common.Hash
lastPrice *big.Int lastPrice *big.Int
cacheLock sync.RWMutex cacheLock sync.RWMutex
fetchLock sync.Mutex 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 blocks := params.Blocks
if blocks < 1 { if blocks < 1 {
blocks = 1 blocks = 1
@ -67,79 +76,79 @@ func NewOracle(backend ethapi.Backend, params Config) *Oracle {
backend: backend, backend: backend,
lastPrice: params.Default, lastPrice: params.Default,
checkBlocks: blocks, checkBlocks: blocks,
maxEmpty: blocks / 2,
maxBlocks: blocks * 5,
percentile: percent, 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) { 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) head, _ := gpo.backend.HeaderByNumber(ctx, rpc.LatestBlockNumber)
headHash := head.Hash() 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 { if headHash == lastHead {
return lastPrice, nil return lastPrice, nil
} }
gpo.fetchLock.Lock() gpo.fetchLock.Lock()
defer gpo.fetchLock.Unlock() 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() gpo.cacheLock.RLock()
lastHead = gpo.lastHead lastHead, lastPrice = gpo.lastHead, gpo.lastPrice
lastPrice = gpo.lastPrice
gpo.cacheLock.RUnlock() gpo.cacheLock.RUnlock()
if headHash == lastHead { if headHash == lastHead {
return lastPrice, nil 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++ sent++
exp++ exp++
blockNum-- number--
} }
maxEmpty := gpo.maxEmpty
for exp > 0 { for exp > 0 {
res := <-ch res := <-result
if res.err != nil { if res.err != nil {
close(quit)
return lastPrice, res.err return lastPrice, res.err
} }
exp-- 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 len(res.prices) == 0 {
res.prices = []*big.Int{lastPrice}
} }
if maxEmpty > 0 { // Besides, in order to collect enough data for sampling, if nothing
maxEmpty-- // meaningful returned, try to query more blocks. But the maximum
continue // is 2*checkBlocks.
} if len(res.prices) == 1 && len(txPrices)+1+exp < gpo.checkBlocks*2 && number > 0 {
if blockNum > 0 && sent < gpo.maxBlocks { go gpo.getBlockPrices(ctx, types.MakeSigner(gpo.backend.ChainConfig(), big.NewInt(int64(number))), number, sampleNumber, result, quit)
go gpo.getBlockPrices(ctx, types.MakeSigner(gpo.backend.ChainConfig(), big.NewInt(int64(blockNum))), blockNum, ch)
sent++ sent++
exp++ exp++
blockNum-- number--
} }
txPrices = append(txPrices, res.prices...)
} }
price := lastPrice 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 { if price.Cmp(maxPrice) > 0 {
price = new(big.Int).Set(maxPrice) price = new(big.Int).Set(maxPrice)
} }
gpo.cacheLock.Lock() gpo.cacheLock.Lock()
gpo.lastHead = headHash gpo.lastHead = headHash
gpo.lastPrice = price gpo.lastPrice = price
@ -148,8 +157,8 @@ func (gpo *Oracle) SuggestPrice(ctx context.Context) (*big.Int, error) {
} }
type getBlockPricesResult struct { type getBlockPricesResult struct {
price *big.Int prices []*big.Int
err error err error
} }
type transactionsByGasPrice []*types.Transaction 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 } 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 // 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)) block, err := gpo.backend.BlockByNumber(ctx, rpc.BlockNumber(blockNum))
if block == nil { if block == nil {
ch <- getBlockPricesResult{nil, err} select {
case result <- getBlockPricesResult{nil, err}:
case <-quit:
}
return return
} }
blockTxs := block.Transactions() blockTxs := block.Transactions()
txs := make([]*types.Transaction, len(blockTxs)) txs := make([]*types.Transaction, len(blockTxs))
copy(txs, blockTxs) copy(txs, blockTxs)
sort.Sort(transactionsByGasPrice(txs)) sort.Sort(transactionsByGasPrice(txs))
var prices []*big.Int
for _, tx := range txs { for _, tx := range txs {
sender, err := types.Sender(signer, tx) sender, err := types.Sender(signer, tx)
if err == nil && sender != block.Coinbase() { 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 type bigIntArray []*big.Int

View File

@ -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)
}
}