2016-11-09 01:01:56 +00:00
|
|
|
// Copyright 2016 The go-ethereum Authors
|
|
|
|
// This file is part of the go-ethereum library.
|
2016-10-14 03:51:29 +00:00
|
|
|
//
|
2016-11-09 01:01:56 +00:00
|
|
|
// 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
|
2016-10-14 03:51:29 +00:00
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
2016-11-09 01:01:56 +00:00
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
2016-10-14 03:51:29 +00:00
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2016-11-09 01:01:56 +00:00
|
|
|
// GNU Lesser General Public License for more details.
|
2016-10-14 03:51:29 +00:00
|
|
|
//
|
2016-11-09 01:01:56 +00:00
|
|
|
// 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/>.
|
2016-10-14 03:51:29 +00:00
|
|
|
|
|
|
|
package les
|
|
|
|
|
|
|
|
import (
|
2017-03-22 17:20:33 +00:00
|
|
|
"context"
|
2019-05-02 12:50:23 +00:00
|
|
|
"errors"
|
2016-10-14 03:51:29 +00:00
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2020-08-03 17:40:46 +00:00
|
|
|
"github.com/ethereum/go-ethereum/consensus"
|
2016-10-14 03:51:29 +00:00
|
|
|
"github.com/ethereum/go-ethereum/core"
|
2017-08-29 11:13:11 +00:00
|
|
|
"github.com/ethereum/go-ethereum/core/bloombits"
|
2018-05-07 11:35:06 +00:00
|
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
2017-06-27 13:57:06 +00:00
|
|
|
"github.com/ethereum/go-ethereum/core/state"
|
2016-10-14 03:51:29 +00:00
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
|
|
"github.com/ethereum/go-ethereum/eth/downloader"
|
|
|
|
"github.com/ethereum/go-ethereum/eth/gasprice"
|
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
|
|
|
"github.com/ethereum/go-ethereum/event"
|
|
|
|
"github.com/ethereum/go-ethereum/light"
|
2016-11-02 12:44:13 +00:00
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2017-01-05 13:03:50 +00:00
|
|
|
"github.com/ethereum/go-ethereum/rpc"
|
2016-10-14 03:51:29 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
type LesApiBackend struct {
|
2021-02-23 12:09:19 +00:00
|
|
|
extRPCEnabled bool
|
|
|
|
allowUnprotectedTxs bool
|
|
|
|
eth *LightEthereum
|
|
|
|
gpo *gasprice.Oracle
|
2016-10-14 03:51:29 +00:00
|
|
|
}
|
|
|
|
|
2016-11-02 12:44:13 +00:00
|
|
|
func (b *LesApiBackend) ChainConfig() *params.ChainConfig {
|
|
|
|
return b.eth.chainConfig
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *LesApiBackend) CurrentBlock() *types.Block {
|
|
|
|
return types.NewBlockWithHeader(b.eth.BlockChain().CurrentHeader())
|
|
|
|
}
|
|
|
|
|
2016-10-14 03:51:29 +00:00
|
|
|
func (b *LesApiBackend) SetHead(number uint64) {
|
2019-08-21 09:29:34 +00:00
|
|
|
b.eth.handler.downloader.Cancel()
|
2016-10-14 03:51:29 +00:00
|
|
|
b.eth.blockchain.SetHead(number)
|
|
|
|
}
|
|
|
|
|
2019-07-23 13:52:24 +00:00
|
|
|
func (b *LesApiBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
|
|
|
|
if number == rpc.LatestBlockNumber || number == rpc.PendingBlockNumber {
|
2016-10-14 03:51:29 +00:00
|
|
|
return b.eth.blockchain.CurrentHeader(), nil
|
|
|
|
}
|
2019-07-23 13:52:24 +00:00
|
|
|
return b.eth.blockchain.GetHeaderByNumberOdr(ctx, uint64(number))
|
2016-10-14 03:51:29 +00:00
|
|
|
}
|
|
|
|
|
2019-09-26 08:47:31 +00:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
|
2018-07-12 14:36:07 +00:00
|
|
|
func (b *LesApiBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
|
|
|
|
return b.eth.blockchain.GetHeaderByHash(hash), nil
|
|
|
|
}
|
|
|
|
|
2019-07-23 13:52:24 +00:00
|
|
|
func (b *LesApiBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
|
|
|
|
header, err := b.HeaderByNumber(ctx, number)
|
2016-10-14 03:51:29 +00:00
|
|
|
if header == nil || err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2019-07-25 06:29:53 +00:00
|
|
|
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)
|
2016-10-14 03:51:29 +00:00
|
|
|
}
|
|
|
|
|
2019-09-26 08:47:31 +00:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
|
2019-07-23 13:52:24 +00:00
|
|
|
func (b *LesApiBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
|
|
|
|
header, err := b.HeaderByNumber(ctx, number)
|
2019-05-02 12:50:23 +00:00
|
|
|
if err != nil {
|
2016-10-14 03:51:29 +00:00
|
|
|
return nil, nil, err
|
|
|
|
}
|
2019-05-02 12:50:23 +00:00
|
|
|
if header == nil {
|
|
|
|
return nil, nil, errors.New("header not found")
|
|
|
|
}
|
2017-06-27 13:57:06 +00:00
|
|
|
return light.NewState(ctx, header, b.eth.odr), header, nil
|
2016-10-14 03:51:29 +00:00
|
|
|
}
|
|
|
|
|
2019-09-26 08:47:31 +00:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
|
2018-05-07 11:35:06 +00:00
|
|
|
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
|
2016-10-14 03:51:29 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 11:35:06 +00:00
|
|
|
func (b *LesApiBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*types.Log, error) {
|
|
|
|
if number := rawdb.ReadHeaderNumber(b.eth.chainDb, hash); number != nil {
|
|
|
|
return light.GetBlockLogs(ctx, b.eth.odr, hash, *number)
|
|
|
|
}
|
|
|
|
return nil, nil
|
2018-02-22 10:48:14 +00:00
|
|
|
}
|
|
|
|
|
2020-07-13 09:02:54 +00:00
|
|
|
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
|
2016-10-14 03:51:29 +00:00
|
|
|
}
|
|
|
|
|
core, internal, eth, miner, les: Take VM config from BlockChain (#17955)
Until this commit, when sending an RPC request that called `NewEVM`, a blank `vm.Config`
would be taken so as to set some options, based on the default configuration. If some extra
configuration switches were passed to the blockchain, those would be ignored.
This PR adds a function to get the config from the blockchain, and this is what is now used
for RPC calls.
Some subsequent changes need to be made, see https://github.com/ethereum/go-ethereum/pull/17955#pullrequestreview-182237244
for the details of the discussion.
2018-12-06 13:34:49 +00:00
|
|
|
func (b *LesApiBackend) GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header) (*vm.EVM, func() error, error) {
|
2020-11-13 12:42:19 +00:00
|
|
|
txContext := core.NewEVMTxContext(msg)
|
|
|
|
context := core.NewEVMBlockContext(header, b.eth.blockchain, nil)
|
|
|
|
return vm.NewEVM(context, txContext, state, b.eth.chainConfig, vm.Config{}), state.Error, nil
|
2016-10-14 03:51:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2016-12-10 22:54:58 +00:00
|
|
|
func (b *LesApiBackend) GetPoolTransactions() (types.Transactions, error) {
|
2016-10-14 03:51:29 +00:00
|
|
|
return b.eth.txPool.GetTransactions()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *LesApiBackend) GetPoolTransaction(txHash common.Hash) *types.Transaction {
|
|
|
|
return b.eth.txPool.GetTransaction(txHash)
|
|
|
|
}
|
|
|
|
|
2019-05-13 11:41:10 +00:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2016-10-14 03:51:29 +00:00
|
|
|
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.Transactions, map[common.Address]types.Transactions) {
|
|
|
|
return b.eth.txPool.Content()
|
|
|
|
}
|
|
|
|
|
2018-05-18 08:45:52 +00:00
|
|
|
func (b *LesApiBackend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
|
|
|
|
return b.eth.txPool.SubscribeNewTxsEvent(ch)
|
2017-08-18 10:58:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2019-12-10 11:39:14 +00:00
|
|
|
func (b *LesApiBackend) SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription {
|
|
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
|
|
<-quit
|
|
|
|
return nil
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2017-08-18 10:58:36 +00:00
|
|
|
func (b *LesApiBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
|
|
|
|
return b.eth.blockchain.SubscribeRemovedLogsEvent(ch)
|
|
|
|
}
|
|
|
|
|
2016-10-14 03:51:29 +00:00
|
|
|
func (b *LesApiBackend) Downloader() *downloader.Downloader {
|
|
|
|
return b.eth.Downloader()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *LesApiBackend) ProtocolVersion() int {
|
|
|
|
return b.eth.LesVersion() + 10000
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *LesApiBackend) SuggestPrice(ctx context.Context) (*big.Int, error) {
|
|
|
|
return b.gpo.SuggestPrice(ctx)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *LesApiBackend) ChainDb() ethdb.Database {
|
|
|
|
return b.eth.chainDb
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *LesApiBackend) AccountManager() *accounts.Manager {
|
|
|
|
return b.eth.accountManager
|
|
|
|
}
|
2017-08-18 19:52:20 +00:00
|
|
|
|
2019-04-04 11:03:10 +00:00
|
|
|
func (b *LesApiBackend) ExtRPCEnabled() bool {
|
|
|
|
return b.extRPCEnabled
|
|
|
|
}
|
|
|
|
|
2021-02-23 12:09:19 +00:00
|
|
|
func (b *LesApiBackend) UnprotectedAllowed() bool {
|
|
|
|
return b.allowUnprotectedTxs
|
|
|
|
}
|
|
|
|
|
2020-07-01 17:54:21 +00:00
|
|
|
func (b *LesApiBackend) RPCGasCap() uint64 {
|
2019-04-08 11:49:52 +00:00
|
|
|
return b.eth.config.RPCGasCap
|
|
|
|
}
|
|
|
|
|
2020-06-17 07:46:31 +00:00
|
|
|
func (b *LesApiBackend) RPCTxFeeCap() float64 {
|
|
|
|
return b.eth.config.RPCTxFeeCap
|
|
|
|
}
|
|
|
|
|
2017-08-29 11:13:11 +00:00
|
|
|
func (b *LesApiBackend) BloomStatus() (uint64, uint64) {
|
2017-10-24 13:19:09 +00:00
|
|
|
if b.eth.bloomIndexer == nil {
|
|
|
|
return 0, 0
|
|
|
|
}
|
|
|
|
sections, _, _ := b.eth.bloomIndexer.Sections()
|
2018-08-28 07:08:16 +00:00
|
|
|
return params.BloomBitsBlocksClient, sections
|
2017-08-18 19:52:20 +00:00
|
|
|
}
|
|
|
|
|
2017-08-29 11:13:11 +00:00
|
|
|
func (b *LesApiBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession) {
|
2017-10-24 13:19:09 +00:00
|
|
|
for i := 0; i < bloomFilterThreads; i++ {
|
|
|
|
go session.Multiplex(bloomRetrievalBatch, bloomRetrievalWait, b.eth.bloomRequests)
|
|
|
|
}
|
2017-08-18 19:52:20 +00:00
|
|
|
}
|
2020-08-03 17:40:46 +00:00
|
|
|
|
|
|
|
func (b *LesApiBackend) Engine() consensus.Engine {
|
|
|
|
return b.eth.engine
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *LesApiBackend) CurrentHeader() *types.Header {
|
|
|
|
return b.eth.blockchain.CurrentHeader()
|
|
|
|
}
|
2021-01-25 13:36:39 +00:00
|
|
|
|
2021-04-07 07:30:26 +00:00
|
|
|
func (b *LesApiBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, checkLive bool) (*state.StateDB, error) {
|
2021-01-25 13:36:39 +00:00
|
|
|
return b.eth.stateAtBlock(ctx, block, reexec)
|
|
|
|
}
|
|
|
|
|
2021-04-07 07:30:26 +00:00
|
|
|
func (b *LesApiBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.BlockContext, *state.StateDB, error) {
|
2021-01-25 13:36:39 +00:00
|
|
|
return b.eth.stateAtTransaction(ctx, block, txIndex, reexec)
|
|
|
|
}
|