plugeth/eth/gasprice.go

213 lines
5.4 KiB
Go
Raw Normal View History

2015-07-07 00:54:22 +00:00
// Copyright 2015 The go-ethereum Authors
// This file is part of the go-ethereum library.
2015-07-07 00:54:22 +00:00
//
// The go-ethereum library is free software: you can redistribute it and/or modify
2015-07-07 00:54:22 +00:00
// 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,
2015-07-07 00:54:22 +00:00
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2015-07-07 00:54:22 +00:00
// 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/>.
2015-07-07 00:54:22 +00:00
2015-05-26 12:28:32 +00:00
package eth
import (
"math/big"
"math/rand"
"sync"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
)
const (
gpoProcessPastBlocks = 100
// for testing
gpoDefaultBaseCorrectionFactor = 110
gpoDefaultMinGasPrice = 10000000000000
)
2015-05-26 12:28:32 +00:00
type blockPriceInfo struct {
baseGasPrice *big.Int
}
// GasPriceOracle recommends gas prices based on the content of recent
// blocks.
2015-05-26 12:28:32 +00:00
type GasPriceOracle struct {
eth *Ethereum
initOnce sync.Once
minPrice *big.Int
lastBaseMutex sync.Mutex
lastBase *big.Int
// state of listenLoop
2015-05-26 12:28:32 +00:00
blocks map[uint64]*blockPriceInfo
firstProcessed, lastProcessed uint64
minBase *big.Int
}
// NewGasPriceOracle returns a new oracle.
func NewGasPriceOracle(eth *Ethereum) *GasPriceOracle {
minprice := eth.GpoMinGasPrice
if minprice == nil {
minprice = big.NewInt(gpoDefaultMinGasPrice)
}
minbase := new(big.Int).Mul(minprice, big.NewInt(100))
if eth.GpobaseCorrectionFactor > 0 {
minbase = minbase.Div(minbase, big.NewInt(int64(eth.GpobaseCorrectionFactor)))
}
return &GasPriceOracle{
eth: eth,
blocks: make(map[uint64]*blockPriceInfo),
minBase: minbase,
minPrice: minprice,
lastBase: minprice,
}
2015-05-26 12:28:32 +00:00
}
func (gpo *GasPriceOracle) init() {
gpo.initOnce.Do(func() {
gpo.processPastBlocks(gpo.eth.BlockChain())
go gpo.listenLoop()
})
2015-05-26 12:28:32 +00:00
}
func (self *GasPriceOracle) processPastBlocks(chain *core.BlockChain) {
2015-06-29 11:48:10 +00:00
last := int64(-1)
cblock := chain.CurrentBlock()
2015-06-29 11:48:10 +00:00
if cblock != nil {
last = int64(cblock.NumberU64())
}
first := int64(0)
2015-05-26 12:28:32 +00:00
if last > gpoProcessPastBlocks {
first = last - gpoProcessPastBlocks
}
2015-06-29 11:48:10 +00:00
self.firstProcessed = uint64(first)
2015-05-26 12:28:32 +00:00
for i := first; i <= last; i++ {
block := chain.GetBlockByNumber(uint64(i))
2015-06-29 11:48:10 +00:00
if block != nil {
self.processBlock(block)
}
2015-05-26 12:28:32 +00:00
}
}
func (self *GasPriceOracle) listenLoop() {
events := self.eth.EventMux().Subscribe(core.ChainEvent{}, core.ChainSplitEvent{})
defer events.Unsubscribe()
for event := range events.Chan() {
switch event := event.Data.(type) {
2015-05-26 12:28:32 +00:00
case core.ChainEvent:
self.processBlock(event.Block)
2015-05-26 12:28:32 +00:00
case core.ChainSplitEvent:
self.processBlock(event.Block)
2015-05-26 12:28:32 +00:00
}
}
}
func (self *GasPriceOracle) processBlock(block *types.Block) {
i := block.NumberU64()
if i > self.lastProcessed {
self.lastProcessed = i
}
lastBase := self.minPrice
2015-05-26 12:28:32 +00:00
bpl := self.blocks[i-1]
if bpl != nil {
lastBase = bpl.baseGasPrice
}
if lastBase == nil {
return
}
var corr int
lp := self.lowestPrice(block)
if lp == nil {
return
}
if lastBase.Cmp(lp) < 0 {
corr = self.eth.GpobaseStepUp
} else {
corr = -self.eth.GpobaseStepDown
}
crand := int64(corr * (900 + rand.Intn(201)))
newBase := new(big.Int).Mul(lastBase, big.NewInt(1000000+crand))
newBase.Div(newBase, big.NewInt(1000000))
2015-08-09 00:13:15 +00:00
if newBase.Cmp(self.minBase) < 0 {
newBase = self.minBase
}
2015-05-26 12:28:32 +00:00
bpi := self.blocks[i]
if bpi == nil {
bpi = &blockPriceInfo{}
self.blocks[i] = bpi
}
bpi.baseGasPrice = newBase
self.lastBaseMutex.Lock()
self.lastBase = newBase
self.lastBaseMutex.Unlock()
glog.V(logger.Detail).Infof("Processed block #%v, base price is %v\n", block.NumberU64(), newBase.Int64())
}
// returns the lowers possible price with which a tx was or could have been included
func (self *GasPriceOracle) lowestPrice(block *types.Block) *big.Int {
2015-08-09 00:13:15 +00:00
gasUsed := big.NewInt(0)
2015-05-26 12:28:32 +00:00
receipts := core.GetBlockReceipts(self.eth.ChainDb(), block.Hash())
if len(receipts) > 0 {
if cgu := receipts[len(receipts)-1].CumulativeGasUsed; cgu != nil {
gasUsed = receipts[len(receipts)-1].CumulativeGasUsed
}
2015-05-26 12:28:32 +00:00
}
if new(big.Int).Mul(gasUsed, big.NewInt(100)).Cmp(new(big.Int).Mul(block.GasLimit(),
2015-05-26 12:28:32 +00:00
big.NewInt(int64(self.eth.GpoFullBlockRatio)))) < 0 {
// block is not full, could have posted a tx with MinGasPrice
2015-08-09 00:13:15 +00:00
return big.NewInt(0)
2015-05-26 12:28:32 +00:00
}
txs := block.Transactions()
if len(txs) == 0 {
2015-08-09 00:13:15 +00:00
return big.NewInt(0)
2015-05-26 12:28:32 +00:00
}
// block is full, find smallest gasPrice
minPrice := txs[0].GasPrice()
for i := 1; i < len(txs); i++ {
price := txs[i].GasPrice()
2015-05-26 12:28:32 +00:00
if price.Cmp(minPrice) < 0 {
minPrice = price
}
}
return minPrice
}
// SuggestPrice returns the recommended gas price.
2015-05-26 12:28:32 +00:00
func (self *GasPriceOracle) SuggestPrice() *big.Int {
self.init()
2015-05-26 12:28:32 +00:00
self.lastBaseMutex.Lock()
price := new(big.Int).Set(self.lastBase)
2015-05-26 12:28:32 +00:00
self.lastBaseMutex.Unlock()
price.Mul(price, big.NewInt(int64(self.eth.GpobaseCorrectionFactor)))
price.Div(price, big.NewInt(100))
if price.Cmp(self.minPrice) < 0 {
price.Set(self.minPrice)
} else if self.eth.GpoMaxGasPrice != nil && price.Cmp(self.eth.GpoMaxGasPrice) > 0 {
price.Set(self.eth.GpoMaxGasPrice)
2015-05-26 12:39:13 +00:00
}
return price
2015-05-26 12:28:32 +00:00
}