You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
272 lines
9.0 KiB
272 lines
9.0 KiB
// Copyright 2015 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 hmy
|
|
|
|
import (
|
|
"context"
|
|
"math/big"
|
|
"sort"
|
|
"sync"
|
|
|
|
"github.com/harmony-one/harmony/block"
|
|
"github.com/harmony-one/harmony/common/denominations"
|
|
"github.com/harmony-one/harmony/eth/rpc"
|
|
"github.com/harmony-one/harmony/internal/configs/harmony"
|
|
"github.com/harmony-one/harmony/internal/utils"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/params"
|
|
"github.com/harmony-one/harmony/core/types"
|
|
)
|
|
|
|
// OracleBackend includes all necessary background APIs for oracle.
|
|
type OracleBackend interface {
|
|
HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*block.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.
|
|
type Oracle struct {
|
|
backend *Harmony
|
|
lastHead common.Hash
|
|
lastPrice *big.Int
|
|
maxPrice *big.Int
|
|
cacheLock sync.RWMutex
|
|
fetchLock sync.Mutex
|
|
|
|
checkBlocks int
|
|
percentile int
|
|
checkTxs int
|
|
lowUsageThreshold float64
|
|
blockGasLimit int
|
|
defaultPrice *big.Int
|
|
}
|
|
|
|
var DefaultGPOConfig = harmony.GasPriceOracleConfig{
|
|
Blocks: 20,
|
|
Transactions: 3,
|
|
Percentile: 60,
|
|
DefaultPrice: 100 * denominations.Nano, // 100 gwei
|
|
MaxPrice: 1000 * denominations.Nano, // 1000 gwei
|
|
LowUsageThreshold: 50,
|
|
BlockGasLimit: 0, // TODO should we set default to 30M?
|
|
}
|
|
|
|
// NewOracle returns a new gasprice oracle which can recommend suitable
|
|
// gasprice for newly created transaction.
|
|
func NewOracle(backend *Harmony, params *harmony.GasPriceOracleConfig) *Oracle {
|
|
blocks := params.Blocks
|
|
if blocks < 1 {
|
|
blocks = DefaultGPOConfig.Blocks
|
|
utils.Logger().Warn().
|
|
Int("provided", params.Blocks).
|
|
Int("updated", blocks).
|
|
Msg("Sanitizing invalid gasprice oracle sample blocks")
|
|
}
|
|
txs := params.Transactions
|
|
if txs < 1 {
|
|
txs = DefaultGPOConfig.Transactions
|
|
utils.Logger().Warn().
|
|
Int("provided", params.Transactions).
|
|
Int("updated", txs).
|
|
Msg("Sanitizing invalid gasprice oracle sample transactions")
|
|
}
|
|
percentile := params.Percentile
|
|
if percentile < 0 || percentile > 100 {
|
|
percentile = DefaultGPOConfig.Percentile
|
|
utils.Logger().Warn().
|
|
Int("provided", params.Percentile).
|
|
Int("updated", percentile).
|
|
Msg("Sanitizing invalid gasprice oracle percentile")
|
|
}
|
|
// no sanity check done, simply convert it
|
|
defaultPrice := big.NewInt(params.DefaultPrice)
|
|
maxPrice := big.NewInt(params.MaxPrice)
|
|
lowUsageThreshold := float64(params.LowUsageThreshold) / 100.0
|
|
if lowUsageThreshold < 0 || lowUsageThreshold > 1 {
|
|
lowUsageThreshold = float64(DefaultGPOConfig.LowUsageThreshold) / 100.0
|
|
utils.Logger().Warn().
|
|
Float64("provided", float64(params.LowUsageThreshold)/100.0).
|
|
Float64("updated", lowUsageThreshold).
|
|
Msg("Sanitizing invalid gasprice oracle lowUsageThreshold")
|
|
}
|
|
blockGasLimit := params.BlockGasLimit
|
|
return &Oracle{
|
|
backend: backend,
|
|
lastPrice: defaultPrice,
|
|
maxPrice: maxPrice,
|
|
checkBlocks: blocks,
|
|
percentile: percentile,
|
|
checkTxs: txs,
|
|
lowUsageThreshold: lowUsageThreshold,
|
|
blockGasLimit: blockGasLimit,
|
|
// do not reference lastPrice
|
|
defaultPrice: new(big.Int).Set(defaultPrice),
|
|
}
|
|
}
|
|
|
|
// 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) {
|
|
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
|
|
gpo.cacheLock.RLock()
|
|
lastHead, lastPrice = gpo.lastHead, gpo.lastPrice
|
|
gpo.cacheLock.RUnlock()
|
|
if headHash == lastHead {
|
|
return lastPrice, nil
|
|
}
|
|
var (
|
|
sent, exp int
|
|
number = head.Number().Uint64()
|
|
result = make(chan getBlockPricesResult, gpo.checkBlocks)
|
|
quit = make(chan struct{})
|
|
txPrices []*big.Int
|
|
usageSum float64
|
|
)
|
|
for sent < gpo.checkBlocks && number > 0 {
|
|
go gpo.getBlockPrices(ctx, types.MakeSigner(gpo.backend.ChainConfig(), big.NewInt(int64(number))), number, gpo.checkTxs, result, quit)
|
|
sent++
|
|
exp++
|
|
number--
|
|
}
|
|
for exp > 0 {
|
|
res := <-result
|
|
if res.err != nil {
|
|
close(quit)
|
|
return lastPrice, res.err
|
|
}
|
|
exp--
|
|
// Nothing returned. There are two special cases here:
|
|
// - The block is empty
|
|
// - 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}
|
|
}
|
|
// Besides, in order to collect enough data for sampling, if nothing
|
|
// 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, gpo.checkTxs, result, quit)
|
|
sent++
|
|
exp++
|
|
number--
|
|
}
|
|
txPrices = append(txPrices, res.prices...)
|
|
usageSum += res.usage
|
|
}
|
|
price := lastPrice
|
|
if len(txPrices) > 0 {
|
|
sort.Sort(bigIntArray(txPrices))
|
|
price = txPrices[(len(txPrices)-1)*gpo.percentile/100]
|
|
}
|
|
// `sent` is the number of queries that are sent, while `exp` and `number` count down at query resolved, and sent respectively
|
|
// each query is per block, therefore `sent` is the number of blocks for which the usage was (successfully) determined
|
|
// approximation that only holds when the gas limits, of all blocks that are sampled, are equal
|
|
usage := usageSum / float64(sent)
|
|
if usage < gpo.lowUsageThreshold {
|
|
price = new(big.Int).Set(gpo.defaultPrice)
|
|
}
|
|
if price.Cmp(gpo.maxPrice) > 0 {
|
|
price = new(big.Int).Set(gpo.maxPrice)
|
|
}
|
|
gpo.cacheLock.Lock()
|
|
gpo.lastHead = headHash
|
|
gpo.lastPrice = price
|
|
gpo.cacheLock.Unlock()
|
|
return price, nil
|
|
}
|
|
|
|
type getBlockPricesResult struct {
|
|
prices []*big.Int
|
|
usage float64
|
|
err error
|
|
}
|
|
|
|
type transactionsByGasPrice []*types.Transaction
|
|
|
|
func (t transactionsByGasPrice) Len() int { return len(t) }
|
|
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].GasPrice().Cmp(t[j].GasPrice()) < 0
|
|
}
|
|
|
|
// getBlockPrices calculates the lowest transaction gas price in a given block
|
|
// and sends it to the result channel. If the block is empty or all transactions
|
|
// 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 {
|
|
select {
|
|
// when no block is found, `err` is returned which short-circuits the oracle entirely
|
|
// therefore the `usage` becomes irrelevant
|
|
case result <- getBlockPricesResult{nil, 2.0, 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() {
|
|
prices = append(prices, tx.GasPrice())
|
|
if len(prices) >= limit {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
// HACK
|
|
var gasLimit float64
|
|
if gpo.blockGasLimit == 0 {
|
|
gasLimit = float64(block.GasLimit())
|
|
} else {
|
|
gasLimit = float64(gpo.blockGasLimit)
|
|
}
|
|
// if `gasLimit` is 0, no crash. +Inf is returned and percentile is applied
|
|
// this usage includes any transactions from the miner, which are excluded by the `prices` slice
|
|
usage := float64(block.GasUsed()) / gasLimit
|
|
select {
|
|
case result <- getBlockPricesResult{prices, usage, nil}:
|
|
case <-quit:
|
|
}
|
|
}
|
|
|
|
type bigIntArray []*big.Int
|
|
|
|
func (s bigIntArray) Len() int { return len(s) }
|
|
func (s bigIntArray) Less(i, j int) bool { return s[i].Cmp(s[j]) < 0 }
|
|
func (s bigIntArray) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
|
|
|