78a3c32ef4
This change simplifies the logic for indexing transactions and enhances the UX when transaction is not found by returning more information to users. Transaction indexing is now considered as a part of the initial sync, and `eth.syncing` will thus be `true` if transaction indexing is not yet finished. API consumers can use the syncing status to determine if the node is ready to serve users.
439 lines
15 KiB
Go
439 lines
15 KiB
Go
// 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 eth
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"math/big"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum"
|
|
"github.com/ethereum/go-ethereum/accounts"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/consensus"
|
|
"github.com/ethereum/go-ethereum/core"
|
|
"github.com/ethereum/go-ethereum/core/bloombits"
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
|
"github.com/ethereum/go-ethereum/core/state"
|
|
"github.com/ethereum/go-ethereum/core/txpool"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
"github.com/ethereum/go-ethereum/eth/gasprice"
|
|
"github.com/ethereum/go-ethereum/eth/tracers"
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
|
"github.com/ethereum/go-ethereum/event"
|
|
"github.com/ethereum/go-ethereum/miner"
|
|
"github.com/ethereum/go-ethereum/params"
|
|
"github.com/ethereum/go-ethereum/rpc"
|
|
)
|
|
|
|
// EthAPIBackend implements ethapi.Backend and tracers.Backend for full nodes
|
|
type EthAPIBackend struct {
|
|
extRPCEnabled bool
|
|
allowUnprotectedTxs bool
|
|
eth *Ethereum
|
|
gpo *gasprice.Oracle
|
|
}
|
|
|
|
// ChainConfig returns the active chain configuration.
|
|
func (b *EthAPIBackend) ChainConfig() *params.ChainConfig {
|
|
return b.eth.blockchain.Config()
|
|
}
|
|
|
|
func (b *EthAPIBackend) CurrentBlock() *types.Header {
|
|
return b.eth.blockchain.CurrentBlock()
|
|
}
|
|
|
|
func (b *EthAPIBackend) SetHead(number uint64) {
|
|
b.eth.handler.downloader.Cancel()
|
|
b.eth.blockchain.SetHead(number)
|
|
}
|
|
|
|
func (b *EthAPIBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
|
|
// Pending block is only known by the miner
|
|
if number == rpc.PendingBlockNumber {
|
|
block := b.eth.miner.PendingBlock()
|
|
if block == nil {
|
|
return nil, errors.New("pending block is not available")
|
|
}
|
|
return block.Header(), nil
|
|
}
|
|
// Otherwise resolve and return the block
|
|
if number == rpc.LatestBlockNumber {
|
|
return b.eth.blockchain.CurrentBlock(), nil
|
|
}
|
|
if number == rpc.FinalizedBlockNumber {
|
|
block := b.eth.blockchain.CurrentFinalBlock()
|
|
if block == nil {
|
|
return nil, errors.New("finalized block not found")
|
|
}
|
|
return block, nil
|
|
}
|
|
if number == rpc.SafeBlockNumber {
|
|
block := b.eth.blockchain.CurrentSafeBlock()
|
|
if block == nil {
|
|
return nil, errors.New("safe block not found")
|
|
}
|
|
return block, nil
|
|
}
|
|
return b.eth.blockchain.GetHeaderByNumber(uint64(number)), nil
|
|
}
|
|
|
|
func (b *EthAPIBackend) 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 := b.eth.blockchain.GetHeaderByHash(hash)
|
|
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")
|
|
}
|
|
|
|
func (b *EthAPIBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
|
|
return b.eth.blockchain.GetHeaderByHash(hash), nil
|
|
}
|
|
|
|
func (b *EthAPIBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
|
|
// Pending block is only known by the miner
|
|
if number == rpc.PendingBlockNumber {
|
|
block := b.eth.miner.PendingBlock()
|
|
if block == nil {
|
|
return nil, errors.New("pending block is not available")
|
|
}
|
|
return block, nil
|
|
}
|
|
// Otherwise resolve and return the block
|
|
if number == rpc.LatestBlockNumber {
|
|
header := b.eth.blockchain.CurrentBlock()
|
|
return b.eth.blockchain.GetBlock(header.Hash(), header.Number.Uint64()), nil
|
|
}
|
|
if number == rpc.FinalizedBlockNumber {
|
|
header := b.eth.blockchain.CurrentFinalBlock()
|
|
if header == nil {
|
|
return nil, errors.New("finalized block not found")
|
|
}
|
|
return b.eth.blockchain.GetBlock(header.Hash(), header.Number.Uint64()), nil
|
|
}
|
|
if number == rpc.SafeBlockNumber {
|
|
header := b.eth.blockchain.CurrentSafeBlock()
|
|
if header == nil {
|
|
return nil, errors.New("safe block not found")
|
|
}
|
|
return b.eth.blockchain.GetBlock(header.Hash(), header.Number.Uint64()), nil
|
|
}
|
|
return b.eth.blockchain.GetBlockByNumber(uint64(number)), nil
|
|
}
|
|
|
|
func (b *EthAPIBackend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
|
|
return b.eth.blockchain.GetBlockByHash(hash), nil
|
|
}
|
|
|
|
// GetBody returns body of a block. It does not resolve special block numbers.
|
|
func (b *EthAPIBackend) GetBody(ctx context.Context, hash common.Hash, number rpc.BlockNumber) (*types.Body, error) {
|
|
if number < 0 || hash == (common.Hash{}) {
|
|
return nil, errors.New("invalid arguments; expect hash and no special block numbers")
|
|
}
|
|
if body := b.eth.blockchain.GetBody(hash); body != nil {
|
|
return body, nil
|
|
}
|
|
return nil, errors.New("block body not found")
|
|
}
|
|
|
|
func (b *EthAPIBackend) 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 {
|
|
header := b.eth.blockchain.GetHeaderByHash(hash)
|
|
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")
|
|
}
|
|
block := b.eth.blockchain.GetBlock(hash, header.Number.Uint64())
|
|
if block == nil {
|
|
return nil, errors.New("header found, but block body is missing")
|
|
}
|
|
return block, nil
|
|
}
|
|
return nil, errors.New("invalid arguments; neither block nor hash specified")
|
|
}
|
|
|
|
func (b *EthAPIBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) {
|
|
return b.eth.miner.PendingBlockAndReceipts()
|
|
}
|
|
|
|
func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
|
|
// Pending state is only known by the miner
|
|
if number == rpc.PendingBlockNumber {
|
|
block, state := b.eth.miner.Pending()
|
|
if block == nil || state == nil {
|
|
return nil, nil, errors.New("pending state is not available")
|
|
}
|
|
return state, block.Header(), nil
|
|
}
|
|
// Otherwise resolve the block number and return its state
|
|
header, err := b.HeaderByNumber(ctx, number)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if header == nil {
|
|
return nil, nil, errors.New("header not found")
|
|
}
|
|
stateDb, err := b.eth.BlockChain().StateAt(header.Root)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return stateDb, header, nil
|
|
}
|
|
|
|
func (b *EthAPIBackend) 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, err := b.HeaderByHash(ctx, hash)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
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")
|
|
}
|
|
stateDb, err := b.eth.BlockChain().StateAt(header.Root)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return stateDb, header, nil
|
|
}
|
|
return nil, nil, errors.New("invalid arguments; neither block nor hash specified")
|
|
}
|
|
|
|
func (b *EthAPIBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
|
|
return b.eth.blockchain.GetReceiptsByHash(hash), nil
|
|
}
|
|
|
|
func (b *EthAPIBackend) GetLogs(ctx context.Context, hash common.Hash, number uint64) ([][]*types.Log, error) {
|
|
return rawdb.ReadLogs(b.eth.chainDb, hash, number), nil
|
|
}
|
|
|
|
func (b *EthAPIBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int {
|
|
if header := b.eth.blockchain.GetHeaderByHash(hash); header != nil {
|
|
return b.eth.blockchain.GetTd(hash, header.Number.Uint64())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (b *EthAPIBackend) GetEVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockCtx *vm.BlockContext) *vm.EVM {
|
|
if vmConfig == nil {
|
|
vmConfig = b.eth.blockchain.GetVMConfig()
|
|
}
|
|
txContext := core.NewEVMTxContext(msg)
|
|
var context vm.BlockContext
|
|
if blockCtx != nil {
|
|
context = *blockCtx
|
|
} else {
|
|
context = core.NewEVMBlockContext(header, b.eth.BlockChain(), nil)
|
|
}
|
|
return vm.NewEVM(context, txContext, state, b.ChainConfig(), *vmConfig)
|
|
}
|
|
|
|
func (b *EthAPIBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
|
|
return b.eth.BlockChain().SubscribeRemovedLogsEvent(ch)
|
|
}
|
|
|
|
func (b *EthAPIBackend) SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription {
|
|
return b.eth.miner.SubscribePendingLogs(ch)
|
|
}
|
|
|
|
func (b *EthAPIBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
|
|
return b.eth.BlockChain().SubscribeChainEvent(ch)
|
|
}
|
|
|
|
func (b *EthAPIBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription {
|
|
return b.eth.BlockChain().SubscribeChainHeadEvent(ch)
|
|
}
|
|
|
|
func (b *EthAPIBackend) SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription {
|
|
return b.eth.BlockChain().SubscribeChainSideEvent(ch)
|
|
}
|
|
|
|
func (b *EthAPIBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
|
|
return b.eth.BlockChain().SubscribeLogsEvent(ch)
|
|
}
|
|
|
|
func (b *EthAPIBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
|
|
return b.eth.txPool.Add([]*types.Transaction{signedTx}, true, false)[0]
|
|
}
|
|
|
|
func (b *EthAPIBackend) GetPoolTransactions() (types.Transactions, error) {
|
|
pending := b.eth.txPool.Pending(false)
|
|
var txs types.Transactions
|
|
for _, batch := range pending {
|
|
for _, lazy := range batch {
|
|
if tx := lazy.Resolve(); tx != nil {
|
|
txs = append(txs, tx)
|
|
}
|
|
}
|
|
}
|
|
return txs, nil
|
|
}
|
|
|
|
func (b *EthAPIBackend) GetPoolTransaction(hash common.Hash) *types.Transaction {
|
|
return b.eth.txPool.Get(hash)
|
|
}
|
|
|
|
// GetTransaction retrieves the lookup along with the transaction itself associate
|
|
// with the given transaction hash.
|
|
//
|
|
// An error will be returned if the transaction is not found, and background
|
|
// indexing for transactions is still in progress. The error is used to indicate the
|
|
// scenario explicitly that the transaction might be reachable shortly.
|
|
//
|
|
// A null will be returned in the transaction is not found and background transaction
|
|
// indexing is already finished. The transaction is not existent from the perspective
|
|
// of node.
|
|
func (b *EthAPIBackend) GetTransaction(ctx context.Context, txHash common.Hash) (bool, *types.Transaction, common.Hash, uint64, uint64, error) {
|
|
lookup, tx, err := b.eth.blockchain.GetTransactionLookup(txHash)
|
|
if err != nil {
|
|
return false, nil, common.Hash{}, 0, 0, err
|
|
}
|
|
if lookup == nil || tx == nil {
|
|
return false, nil, common.Hash{}, 0, 0, nil
|
|
}
|
|
return true, tx, lookup.BlockHash, lookup.BlockIndex, lookup.Index, nil
|
|
}
|
|
|
|
func (b *EthAPIBackend) GetPoolNonce(ctx context.Context, addr common.Address) (uint64, error) {
|
|
return b.eth.txPool.Nonce(addr), nil
|
|
}
|
|
|
|
func (b *EthAPIBackend) Stats() (runnable int, blocked int) {
|
|
return b.eth.txPool.Stats()
|
|
}
|
|
|
|
func (b *EthAPIBackend) TxPoolContent() (map[common.Address][]*types.Transaction, map[common.Address][]*types.Transaction) {
|
|
return b.eth.txPool.Content()
|
|
}
|
|
|
|
func (b *EthAPIBackend) TxPoolContentFrom(addr common.Address) ([]*types.Transaction, []*types.Transaction) {
|
|
return b.eth.txPool.ContentFrom(addr)
|
|
}
|
|
|
|
func (b *EthAPIBackend) TxPool() *txpool.TxPool {
|
|
return b.eth.txPool
|
|
}
|
|
|
|
func (b *EthAPIBackend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
|
|
return b.eth.txPool.SubscribeTransactions(ch, true)
|
|
}
|
|
|
|
func (b *EthAPIBackend) SyncProgress() ethereum.SyncProgress {
|
|
prog := b.eth.Downloader().Progress()
|
|
if txProg, err := b.eth.blockchain.TxIndexProgress(); err == nil {
|
|
prog.TxIndexFinishedBlocks = txProg.Indexed
|
|
prog.TxIndexRemainingBlocks = txProg.Remaining
|
|
}
|
|
return prog
|
|
}
|
|
|
|
func (b *EthAPIBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
|
|
return b.gpo.SuggestTipCap(ctx)
|
|
}
|
|
|
|
func (b *EthAPIBackend) FeeHistory(ctx context.Context, blockCount uint64, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (firstBlock *big.Int, reward [][]*big.Int, baseFee []*big.Int, gasUsedRatio []float64, err error) {
|
|
return b.gpo.FeeHistory(ctx, blockCount, lastBlock, rewardPercentiles)
|
|
}
|
|
|
|
func (b *EthAPIBackend) ChainDb() ethdb.Database {
|
|
return b.eth.ChainDb()
|
|
}
|
|
|
|
func (b *EthAPIBackend) EventMux() *event.TypeMux {
|
|
return b.eth.EventMux()
|
|
}
|
|
|
|
func (b *EthAPIBackend) AccountManager() *accounts.Manager {
|
|
return b.eth.AccountManager()
|
|
}
|
|
|
|
func (b *EthAPIBackend) ExtRPCEnabled() bool {
|
|
return b.extRPCEnabled
|
|
}
|
|
|
|
func (b *EthAPIBackend) UnprotectedAllowed() bool {
|
|
return b.allowUnprotectedTxs
|
|
}
|
|
|
|
func (b *EthAPIBackend) RPCGasCap() uint64 {
|
|
return b.eth.config.RPCGasCap
|
|
}
|
|
|
|
func (b *EthAPIBackend) RPCEVMTimeout() time.Duration {
|
|
return b.eth.config.RPCEVMTimeout
|
|
}
|
|
|
|
func (b *EthAPIBackend) RPCTxFeeCap() float64 {
|
|
return b.eth.config.RPCTxFeeCap
|
|
}
|
|
|
|
func (b *EthAPIBackend) BloomStatus() (uint64, uint64) {
|
|
sections, _, _ := b.eth.bloomIndexer.Sections()
|
|
return params.BloomBitsBlocks, sections
|
|
}
|
|
|
|
func (b *EthAPIBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession) {
|
|
for i := 0; i < bloomFilterThreads; i++ {
|
|
go session.Multiplex(bloomRetrievalBatch, bloomRetrievalWait, b.eth.bloomRequests)
|
|
}
|
|
}
|
|
|
|
func (b *EthAPIBackend) Engine() consensus.Engine {
|
|
return b.eth.engine
|
|
}
|
|
|
|
func (b *EthAPIBackend) CurrentHeader() *types.Header {
|
|
return b.eth.blockchain.CurrentHeader()
|
|
}
|
|
|
|
func (b *EthAPIBackend) Miner() *miner.Miner {
|
|
return b.eth.Miner()
|
|
}
|
|
|
|
func (b *EthAPIBackend) StartMining() error {
|
|
return b.eth.StartMining()
|
|
}
|
|
|
|
func (b *EthAPIBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, tracers.StateReleaseFunc, error) {
|
|
return b.eth.stateAtBlock(ctx, block, reexec, base, readOnly, preferDisk)
|
|
}
|
|
|
|
func (b *EthAPIBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) {
|
|
return b.eth.stateAtTransaction(ctx, block, txIndex, reexec)
|
|
}
|