2015-12-15 21:26:23 -06:00
|
|
|
// Copyright 2015 The go-ethereum Authors
|
2016-11-08 19:01:56 -06:00
|
|
|
// This file is part of the go-ethereum library.
|
2015-12-15 21:26:23 -06:00
|
|
|
//
|
2016-11-08 19:01:56 -06: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
|
2015-12-15 21:26:23 -06:00
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
2016-11-08 19:01:56 -06:00
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
2015-12-15 21:26:23 -06:00
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2016-11-08 19:01:56 -06:00
|
|
|
// GNU Lesser General Public License for more details.
|
2015-12-15 21:26:23 -06:00
|
|
|
//
|
2016-11-08 19:01:56 -06: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/>.
|
2015-12-15 21:26:23 -06:00
|
|
|
|
|
|
|
package eth
|
|
|
|
|
|
|
|
import (
|
2017-03-22 12:20:33 -05:00
|
|
|
"context"
|
2019-05-02 07:50:23 -05:00
|
|
|
"errors"
|
2015-12-15 21:26:23 -06:00
|
|
|
"math/big"
|
2021-10-12 03:46:04 -05:00
|
|
|
"time"
|
2015-12-15 21:26:23 -06:00
|
|
|
|
2021-09-10 02:55:48 -05:00
|
|
|
"github.com/ethereum/go-ethereum"
|
2015-12-15 21:26:23 -06:00
|
|
|
"github.com/ethereum/go-ethereum/accounts"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2020-08-03 12:40:46 -05:00
|
|
|
"github.com/ethereum/go-ethereum/consensus"
|
2015-12-15 21:26:23 -06:00
|
|
|
"github.com/ethereum/go-ethereum/core"
|
2017-08-29 06:13:11 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/bloombits"
|
2019-05-13 06:41:10 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
2015-12-15 21:26:23 -06:00
|
|
|
"github.com/ethereum/go-ethereum/core/state"
|
2022-10-24 08:13:55 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core/txpool"
|
2015-12-15 21:26:23 -06:00
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
|
|
"github.com/ethereum/go-ethereum/core/vm"
|
|
|
|
"github.com/ethereum/go-ethereum/eth/gasprice"
|
2022-09-07 13:25:58 -05:00
|
|
|
"github.com/ethereum/go-ethereum/eth/tracers"
|
2015-12-15 21:26:23 -06:00
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
|
|
|
"github.com/ethereum/go-ethereum/event"
|
2020-08-03 12:40:46 -05:00
|
|
|
"github.com/ethereum/go-ethereum/miner"
|
2016-11-02 07:44:13 -05:00
|
|
|
"github.com/ethereum/go-ethereum/params"
|
2017-01-05 07:03:50 -06:00
|
|
|
"github.com/ethereum/go-ethereum/rpc"
|
2015-12-15 21:26:23 -06:00
|
|
|
)
|
|
|
|
|
2023-05-29 04:09:34 -05:00
|
|
|
// EthAPIBackend implements ethapi.Backend and tracers.Backend for full nodes
|
2018-05-09 02:59:00 -05:00
|
|
|
type EthAPIBackend struct {
|
2021-02-23 06:09:19 -06:00
|
|
|
extRPCEnabled bool
|
|
|
|
allowUnprotectedTxs bool
|
|
|
|
eth *Ethereum
|
|
|
|
gpo *gasprice.Oracle
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2018-06-14 05:14:52 -05:00
|
|
|
// ChainConfig returns the active chain configuration.
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) ChainConfig() *params.ChainConfig {
|
2019-03-27 06:23:08 -05:00
|
|
|
return b.eth.blockchain.Config()
|
2016-11-02 07:44:13 -05:00
|
|
|
}
|
|
|
|
|
2023-03-02 00:29:15 -06:00
|
|
|
func (b *EthAPIBackend) CurrentBlock() *types.Header {
|
2016-11-02 07:44:13 -05:00
|
|
|
return b.eth.blockchain.CurrentBlock()
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) SetHead(number uint64) {
|
2020-12-14 03:27:15 -06:00
|
|
|
b.eth.handler.downloader.Cancel()
|
2015-12-15 21:26:23 -06:00
|
|
|
b.eth.blockchain.SetHead(number)
|
|
|
|
}
|
|
|
|
|
2019-07-23 08:52:24 -05:00
|
|
|
func (b *EthAPIBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
|
2015-12-15 21:26:23 -06:00
|
|
|
// Pending block is only known by the miner
|
2019-07-23 08:52:24 -05:00
|
|
|
if number == rpc.PendingBlockNumber {
|
2016-11-30 03:48:48 -06:00
|
|
|
block := b.eth.miner.PendingBlock()
|
2023-05-31 02:09:49 -05:00
|
|
|
if block == nil {
|
|
|
|
return nil, errors.New("pending block is not available")
|
|
|
|
}
|
2016-10-13 22:51:29 -05:00
|
|
|
return block.Header(), nil
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
// Otherwise resolve and return the block
|
2019-07-23 08:52:24 -05:00
|
|
|
if number == rpc.LatestBlockNumber {
|
2023-03-02 00:29:15 -06:00
|
|
|
return b.eth.blockchain.CurrentBlock(), nil
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
2022-05-18 09:30:42 -05:00
|
|
|
if number == rpc.FinalizedBlockNumber {
|
2023-03-13 05:51:23 -05:00
|
|
|
if !b.eth.Merger().TDDReached() {
|
|
|
|
return nil, errors.New("'finalized' tag not supported on pre-merge network")
|
|
|
|
}
|
2023-03-02 00:29:15 -06:00
|
|
|
block := b.eth.blockchain.CurrentFinalBlock()
|
2022-07-25 10:42:05 -05:00
|
|
|
if block != nil {
|
2023-03-02 00:29:15 -06:00
|
|
|
return block, nil
|
2022-07-25 10:42:05 -05:00
|
|
|
}
|
|
|
|
return nil, errors.New("finalized block not found")
|
|
|
|
}
|
|
|
|
if number == rpc.SafeBlockNumber {
|
2023-03-13 05:51:23 -05:00
|
|
|
if !b.eth.Merger().TDDReached() {
|
|
|
|
return nil, errors.New("'safe' tag not supported on pre-merge network")
|
|
|
|
}
|
2022-07-25 10:42:05 -05:00
|
|
|
block := b.eth.blockchain.CurrentSafeBlock()
|
|
|
|
if block != nil {
|
2023-03-02 00:29:15 -06:00
|
|
|
return block, nil
|
2022-07-25 10:42:05 -05:00
|
|
|
}
|
|
|
|
return nil, errors.New("safe block not found")
|
2022-05-18 09:30:42 -05:00
|
|
|
}
|
2019-07-23 08:52:24 -05:00
|
|
|
return b.eth.blockchain.GetHeaderByNumber(uint64(number)), nil
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2019-09-26 03:47:31 -05:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
|
2018-07-12 09:36:07 -05:00
|
|
|
func (b *EthAPIBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
|
|
|
|
return b.eth.blockchain.GetHeaderByHash(hash), nil
|
|
|
|
}
|
|
|
|
|
2019-07-23 08:52:24 -05:00
|
|
|
func (b *EthAPIBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
|
2015-12-15 21:26:23 -06:00
|
|
|
// Pending block is only known by the miner
|
2019-07-23 08:52:24 -05:00
|
|
|
if number == rpc.PendingBlockNumber {
|
2016-11-30 03:48:48 -06:00
|
|
|
block := b.eth.miner.PendingBlock()
|
2023-05-31 02:09:49 -05:00
|
|
|
if block == nil {
|
|
|
|
return nil, errors.New("pending block is not available")
|
|
|
|
}
|
2015-12-15 21:26:23 -06:00
|
|
|
return block, nil
|
|
|
|
}
|
|
|
|
// Otherwise resolve and return the block
|
2019-07-23 08:52:24 -05:00
|
|
|
if number == rpc.LatestBlockNumber {
|
2023-03-02 00:29:15 -06:00
|
|
|
header := b.eth.blockchain.CurrentBlock()
|
|
|
|
return b.eth.blockchain.GetBlock(header.Hash(), header.Number.Uint64()), nil
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
2022-05-18 09:30:42 -05:00
|
|
|
if number == rpc.FinalizedBlockNumber {
|
2023-03-13 05:51:23 -05:00
|
|
|
if !b.eth.Merger().TDDReached() {
|
|
|
|
return nil, errors.New("'finalized' tag not supported on pre-merge network")
|
|
|
|
}
|
2023-03-02 00:29:15 -06:00
|
|
|
header := b.eth.blockchain.CurrentFinalBlock()
|
2023-04-25 08:15:43 -05:00
|
|
|
if header == nil {
|
|
|
|
return nil, errors.New("finalized block not found")
|
|
|
|
}
|
2023-03-02 00:29:15 -06:00
|
|
|
return b.eth.blockchain.GetBlock(header.Hash(), header.Number.Uint64()), nil
|
2022-05-18 09:30:42 -05:00
|
|
|
}
|
2022-07-25 10:42:05 -05:00
|
|
|
if number == rpc.SafeBlockNumber {
|
2023-03-13 05:51:23 -05:00
|
|
|
if !b.eth.Merger().TDDReached() {
|
|
|
|
return nil, errors.New("'safe' tag not supported on pre-merge network")
|
|
|
|
}
|
2023-03-02 00:29:15 -06:00
|
|
|
header := b.eth.blockchain.CurrentSafeBlock()
|
2023-04-25 08:15:43 -05:00
|
|
|
if header == nil {
|
|
|
|
return nil, errors.New("safe block not found")
|
|
|
|
}
|
2023-03-02 00:29:15 -06:00
|
|
|
return b.eth.blockchain.GetBlock(header.Hash(), header.Number.Uint64()), nil
|
2022-07-25 10:42:05 -05:00
|
|
|
}
|
2019-07-23 08:52:24 -05:00
|
|
|
return b.eth.blockchain.GetBlockByNumber(uint64(number)), nil
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2019-07-25 01:29:53 -05:00
|
|
|
func (b *EthAPIBackend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
|
|
|
|
return b.eth.blockchain.GetBlockByHash(hash), nil
|
|
|
|
}
|
|
|
|
|
2023-02-13 03:59:27 -06:00
|
|
|
// 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")
|
|
|
|
}
|
|
|
|
|
2019-09-26 03:47:31 -05:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
|
2021-06-28 09:16:32 -05:00
|
|
|
func (b *EthAPIBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) {
|
|
|
|
return b.eth.miner.PendingBlockAndReceipts()
|
|
|
|
}
|
|
|
|
|
2019-07-23 08:52:24 -05:00
|
|
|
func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
|
2015-12-15 21:26:23 -06:00
|
|
|
// Pending state is only known by the miner
|
2019-07-23 08:52:24 -05:00
|
|
|
if number == rpc.PendingBlockNumber {
|
2015-12-15 21:26:23 -06:00
|
|
|
block, state := b.eth.miner.Pending()
|
2023-05-31 02:09:49 -05:00
|
|
|
if block == nil || state == nil {
|
|
|
|
return nil, nil, errors.New("pending state is not available")
|
|
|
|
}
|
2017-06-27 08:57:06 -05:00
|
|
|
return state, block.Header(), nil
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
// Otherwise resolve the block number and return its state
|
2019-07-23 08:52:24 -05:00
|
|
|
header, err := b.HeaderByNumber(ctx, number)
|
2019-05-02 07:50:23 -05:00
|
|
|
if err != nil {
|
2016-10-13 22:51:29 -05:00
|
|
|
return nil, nil, err
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
2019-05-02 07:50:23 -05:00
|
|
|
if header == nil {
|
|
|
|
return nil, nil, errors.New("header not found")
|
|
|
|
}
|
2016-09-27 05:13:13 -05:00
|
|
|
stateDb, err := b.eth.BlockChain().StateAt(header.Root)
|
2017-06-27 08:57:06 -05:00
|
|
|
return stateDb, header, err
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2019-09-26 03:47:31 -05:00
|
|
|
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)
|
|
|
|
return stateDb, header, err
|
|
|
|
}
|
|
|
|
return nil, nil, errors.New("invalid arguments; neither block nor hash specified")
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
|
2018-09-29 15:53:31 -05:00
|
|
|
return b.eth.blockchain.GetReceiptsByHash(hash), nil
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2022-08-19 04:14:59 -05:00
|
|
|
func (b *EthAPIBackend) GetLogs(ctx context.Context, hash common.Hash, number uint64) ([][]*types.Log, error) {
|
|
|
|
return rawdb.ReadLogs(b.eth.chainDb, hash, number, b.ChainConfig()), nil
|
2018-02-22 04:48:14 -06:00
|
|
|
}
|
|
|
|
|
2020-07-13 04:02:54 -05:00
|
|
|
func (b *EthAPIBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int {
|
2021-10-11 16:16:46 -05:00
|
|
|
if header := b.eth.blockchain.GetHeaderByHash(hash); header != nil {
|
|
|
|
return b.eth.blockchain.GetTd(hash, header.Number.Uint64())
|
|
|
|
}
|
|
|
|
return nil
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2023-05-11 07:23:47 -05:00
|
|
|
func (b *EthAPIBackend) GetEVM(ctx context.Context, msg *core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config, blockCtx *vm.BlockContext) (*vm.EVM, func() error) {
|
2021-04-07 09:54:31 -05:00
|
|
|
if vmConfig == nil {
|
|
|
|
vmConfig = b.eth.blockchain.GetVMConfig()
|
|
|
|
}
|
2020-11-13 06:42:19 -06:00
|
|
|
txContext := core.NewEVMTxContext(msg)
|
2023-05-02 03:28:43 -05:00
|
|
|
var context vm.BlockContext
|
|
|
|
if blockCtx != nil {
|
|
|
|
context = *blockCtx
|
|
|
|
} else {
|
|
|
|
context = core.NewEVMBlockContext(header, b.eth.BlockChain(), nil)
|
|
|
|
}
|
2023-05-11 07:23:47 -05:00
|
|
|
return vm.NewEVM(context, txContext, state, b.eth.blockchain.Config(), *vmConfig), state.Error
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
|
2017-08-18 05:58:36 -05:00
|
|
|
return b.eth.BlockChain().SubscribeRemovedLogsEvent(ch)
|
|
|
|
}
|
|
|
|
|
2019-12-10 05:39:14 -06:00
|
|
|
func (b *EthAPIBackend) SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription {
|
|
|
|
return b.eth.miner.SubscribePendingLogs(ch)
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
|
2017-08-18 05:58:36 -05:00
|
|
|
return b.eth.BlockChain().SubscribeChainEvent(ch)
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription {
|
2017-08-18 05:58:36 -05:00
|
|
|
return b.eth.BlockChain().SubscribeChainHeadEvent(ch)
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription {
|
2017-08-18 05:58:36 -05:00
|
|
|
return b.eth.BlockChain().SubscribeChainSideEvent(ch)
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
|
2017-08-18 05:58:36 -05:00
|
|
|
return b.eth.BlockChain().SubscribeLogsEvent(ch)
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
|
2017-07-05 08:51:55 -05:00
|
|
|
return b.eth.txPool.AddLocal(signedTx)
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) GetPoolTransactions() (types.Transactions, error) {
|
2021-10-13 16:00:45 -05:00
|
|
|
pending := b.eth.txPool.Pending(false)
|
2016-07-01 10:59:55 -05:00
|
|
|
var txs types.Transactions
|
2016-12-10 16:54:58 -06:00
|
|
|
for _, batch := range pending {
|
2016-07-01 10:59:55 -05:00
|
|
|
txs = append(txs, batch...)
|
|
|
|
}
|
2016-12-10 16:54:58 -06:00
|
|
|
return txs, nil
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) GetPoolTransaction(hash common.Hash) *types.Transaction {
|
2016-07-01 10:59:55 -05:00
|
|
|
return b.eth.txPool.Get(hash)
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2019-05-13 06:41:10 -05:00
|
|
|
func (b *EthAPIBackend) GetTransaction(ctx context.Context, txHash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, error) {
|
|
|
|
tx, blockHash, blockNumber, index := rawdb.ReadTransaction(b.eth.ChainDb(), txHash)
|
|
|
|
return tx, blockHash, blockNumber, index, nil
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) GetPoolNonce(ctx context.Context, addr common.Address) (uint64, error) {
|
2019-07-09 02:34:35 -05:00
|
|
|
return b.eth.txPool.Nonce(addr), nil
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) Stats() (pending int, queued int) {
|
2015-12-15 21:26:23 -06:00
|
|
|
return b.eth.txPool.Stats()
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) TxPoolContent() (map[common.Address]types.Transactions, map[common.Address]types.Transactions) {
|
2015-12-15 21:26:23 -06:00
|
|
|
return b.eth.TxPool().Content()
|
|
|
|
}
|
|
|
|
|
2021-07-13 05:40:58 -05:00
|
|
|
func (b *EthAPIBackend) TxPoolContentFrom(addr common.Address) (types.Transactions, types.Transactions) {
|
|
|
|
return b.eth.TxPool().ContentFrom(addr)
|
|
|
|
}
|
|
|
|
|
2022-10-24 08:13:55 -05:00
|
|
|
func (b *EthAPIBackend) TxPool() *txpool.TxPool {
|
2020-08-03 12:40:46 -05:00
|
|
|
return b.eth.TxPool()
|
|
|
|
}
|
|
|
|
|
2018-05-18 03:45:52 -05:00
|
|
|
func (b *EthAPIBackend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
|
|
|
|
return b.eth.TxPool().SubscribeNewTxsEvent(ch)
|
2017-08-18 05:58:36 -05:00
|
|
|
}
|
|
|
|
|
2021-09-10 02:55:48 -05:00
|
|
|
func (b *EthAPIBackend) SyncProgress() ethereum.SyncProgress {
|
|
|
|
return b.eth.Downloader().Progress()
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
core, eth, internal, les: RPC methods and fields for EIP 1559 (#22964)
* internal/ethapi: add baseFee to RPCMarshalHeader
* internal/ethapi: add FeeCap, Tip and correct GasPrice to EIP-1559 RPCTransaction results
* core,eth,les,internal: add support for tip estimation in gas price oracle
* internal/ethapi,eth/gasprice: don't suggest tip larger than fee cap
* core/types,internal: use correct eip1559 terminology for json marshalling
* eth, internal/ethapi: fix rebase problems
* internal/ethapi: fix rpc name of basefee
* internal/ethapi: address review concerns
* core, eth, internal, les: simplify gasprice oracle (#25)
* core, eth, internal, les: simplify gasprice oracle
* eth/gasprice: fix typo
* internal/ethapi: minor tweak in tx args
* internal/ethapi: calculate basefee for pending block
* internal/ethapi: fix panic
* internal/ethapi, eth/tracers: simplify txargs ToMessage
* internal/ethapi: remove unused param
* core, eth, internal: fix regressions wrt effective gas price in the evm
* eth/gasprice: drop weird debug println
* internal/jsre/deps: hack in 1559 gas conversions into embedded web3
* internal/jsre/deps: hack basFee to decimal conversion
* internal/ethapi: init feecap and tipcap for legacy txs too
* eth, graphql, internal, les: fix gas price suggestion on all combos
* internal/jsre/deps: handle decimal tipcap and feecap
* eth, internal: minor review fixes
* graphql, internal: export max fee cap RPC endpoint
* internal/ethapi: fix crash in transaction_args
* internal/ethapi: minor refactor to make the code safer
Co-authored-by: Ryan Schneider <ryanleeschneider@gmail.com>
Co-authored-by: lightclient@protonmail.com <lightclient@protonmail.com>
Co-authored-by: gary rong <garyrong0905@gmail.com>
Co-authored-by: Péter Szilágyi <peterke@gmail.com>
2021-06-02 08:13:10 -05:00
|
|
|
func (b *EthAPIBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
|
|
|
|
return b.gpo.SuggestTipCap(ctx)
|
2015-12-15 21:26:23 -06:00
|
|
|
}
|
|
|
|
|
2023-03-23 15:12:37 -05:00
|
|
|
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) {
|
2021-06-28 09:16:32 -05:00
|
|
|
return b.gpo.FeeHistory(ctx, blockCount, lastBlock, rewardPercentiles)
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) ChainDb() ethdb.Database {
|
2015-12-15 21:26:23 -06:00
|
|
|
return b.eth.ChainDb()
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) EventMux() *event.TypeMux {
|
2015-12-15 21:26:23 -06:00
|
|
|
return b.eth.EventMux()
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) AccountManager() *accounts.Manager {
|
2015-12-15 21:26:23 -06:00
|
|
|
return b.eth.AccountManager()
|
|
|
|
}
|
2017-08-18 14:52:20 -05:00
|
|
|
|
2019-04-04 06:03:10 -05:00
|
|
|
func (b *EthAPIBackend) ExtRPCEnabled() bool {
|
|
|
|
return b.extRPCEnabled
|
|
|
|
}
|
|
|
|
|
2021-02-23 06:09:19 -06:00
|
|
|
func (b *EthAPIBackend) UnprotectedAllowed() bool {
|
|
|
|
return b.allowUnprotectedTxs
|
|
|
|
}
|
|
|
|
|
2020-07-01 12:54:21 -05:00
|
|
|
func (b *EthAPIBackend) RPCGasCap() uint64 {
|
2019-04-08 06:49:52 -05:00
|
|
|
return b.eth.config.RPCGasCap
|
|
|
|
}
|
|
|
|
|
2021-10-12 03:46:04 -05:00
|
|
|
func (b *EthAPIBackend) RPCEVMTimeout() time.Duration {
|
|
|
|
return b.eth.config.RPCEVMTimeout
|
|
|
|
}
|
|
|
|
|
2020-06-17 02:46:31 -05:00
|
|
|
func (b *EthAPIBackend) RPCTxFeeCap() float64 {
|
|
|
|
return b.eth.config.RPCTxFeeCap
|
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) BloomStatus() (uint64, uint64) {
|
2017-08-29 06:13:11 -05:00
|
|
|
sections, _, _ := b.eth.bloomIndexer.Sections()
|
|
|
|
return params.BloomBitsBlocks, sections
|
2017-08-18 14:52:20 -05:00
|
|
|
}
|
|
|
|
|
2018-05-09 02:59:00 -05:00
|
|
|
func (b *EthAPIBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession) {
|
2017-08-29 06:13:11 -05:00
|
|
|
for i := 0; i < bloomFilterThreads; i++ {
|
|
|
|
go session.Multiplex(bloomRetrievalBatch, bloomRetrievalWait, b.eth.bloomRequests)
|
2017-08-18 14:52:20 -05:00
|
|
|
}
|
|
|
|
}
|
2020-08-03 12:40:46 -05:00
|
|
|
|
|
|
|
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()
|
|
|
|
}
|
|
|
|
|
2023-05-03 04:58:39 -05:00
|
|
|
func (b *EthAPIBackend) StartMining() error {
|
|
|
|
return b.eth.StartMining()
|
2020-08-03 12:40:46 -05:00
|
|
|
}
|
2021-01-25 07:36:39 -06:00
|
|
|
|
2022-09-07 13:25:58 -05:00
|
|
|
func (b *EthAPIBackend) StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, tracers.StateReleaseFunc, error) {
|
2022-12-15 06:52:07 -06:00
|
|
|
return b.eth.StateAtBlock(ctx, block, reexec, base, readOnly, preferDisk)
|
2021-01-25 07:36:39 -06:00
|
|
|
}
|
|
|
|
|
core, core/types: plain Message struct (#25977)
Here, the core.Message interface turns into a plain struct and
types.Message gets removed.
This is a breaking change to packages core and core/types. While we do
not promise API stability for package core, we do for core/types. An
exception can be made for types.Message, since it doesn't have any
purpose apart from invoking the state transition in package core.
types.Message was also marked deprecated by the same commit it
got added in, 4dca5d4db7 (November 2016).
The core.Message interface was added in December 2014, in commit
db494170dc, for the purpose of 'testing' state transitions. It's the
same change that made transaction struct fields private. Before that,
the state transition used *types.Transaction directly.
Over time, multiple implementations of the interface accrued across
different packages, since constructing a Message is required whenever
one wants to invoke the state transition. These implementations all
looked very similar, a struct with private fields exposing the fields
as accessor methods.
By changing Message into a struct with public fields we can remove all
these useless interface implementations. It will also hopefully
simplify future changes to the type with less updates to apply across
all of go-ethereum when a field is added to Message.
---------
Co-authored-by: Felix Lange <fjl@twurst.com>
2023-03-09 07:19:12 -06:00
|
|
|
func (b *EthAPIBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) {
|
2022-12-15 06:52:07 -06:00
|
|
|
return b.eth.stateAtTransaction(ctx, block, txIndex, reexec)
|
2021-01-25 07:36:39 -06:00
|
|
|
}
|