Roy Crihfield
27d1634b5b
- Fixes RPC for blob transactions - Allows loading chain ID from chain config file, improving integration in cerc-io/fixturenet-eth-stacks#21 Depends on cerc-io/system-tests#13 Reviewed-on: #266
1324 lines
44 KiB
Go
1324 lines
44 KiB
Go
// VulcanizeDB
|
|
// Copyright © 2019 Vulcanize
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// This program 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 Affero General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package eth
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"math/big"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
ipld_direct_state "github.com/cerc-io/ipld-eth-statedb/direct_by_leaf"
|
|
"github.com/cerc-io/ipld-eth-statedb/trie_by_cid/state"
|
|
"github.com/cerc-io/ipld-eth-statedb/trie_by_cid/trie"
|
|
statediff "github.com/cerc-io/plugeth-statediff"
|
|
"github.com/ethereum/go-ethereum/accounts/abi"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
"github.com/ethereum/go-ethereum/common/math"
|
|
"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
|
|
"github.com/ethereum/go-ethereum/core"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/eth/filters"
|
|
"github.com/ethereum/go-ethereum/ethclient"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
"github.com/ethereum/go-ethereum/rpc"
|
|
"github.com/holiman/uint256"
|
|
|
|
"github.com/cerc-io/ipld-eth-server/v5/pkg/log"
|
|
)
|
|
|
|
const (
|
|
defaultEVMTimeout = 30 * time.Second
|
|
)
|
|
|
|
// APIName is the namespace for the watcher's eth api
|
|
const APIName = "eth"
|
|
|
|
// APIVersion is the version of the watcher's eth api
|
|
const APIVersion = "0.0.1"
|
|
|
|
type APIConfig struct {
|
|
// Proxy node for forwarding cache misses
|
|
SupportsStateDiff bool // Whether the remote node supports the statediff_writeStateDiffAt endpoint, if it does we can fill the local cache when we hit a miss
|
|
ForwardEthCalls bool // if true, forward eth_call calls directly to the configured proxy node
|
|
ForwardGetStorageAt bool // if true, forward eth_getStorageAt calls directly to the configured proxy node
|
|
ProxyOnError bool // turn on regular proxy fall-through on errors; needed to test difference between direct and indirect fall-through
|
|
GetLogsBlockLimit int64 // the maximum size of the block range to use in GetLogs
|
|
|
|
StateDiffTimeout time.Duration
|
|
}
|
|
|
|
// PublicEthAPI is the eth namespace API
|
|
type PublicEthAPI struct {
|
|
// Local db backend
|
|
B *Backend
|
|
rpc *rpc.Client
|
|
ethClient *ethclient.Client
|
|
config APIConfig
|
|
}
|
|
|
|
// NewPublicEthAPI creates a new PublicEthAPI with the provided underlying Backend
|
|
func NewPublicEthAPI(b *Backend, client *rpc.Client, config APIConfig) (*PublicEthAPI, error) {
|
|
if b == nil {
|
|
return nil, errors.New("ipld-eth-server must be configured with an ethereum backend")
|
|
}
|
|
if config.ForwardEthCalls && client == nil {
|
|
return nil, errors.New("ipld-eth-server is configured to forward eth_calls to proxy node but no proxy node is configured")
|
|
}
|
|
if config.ForwardGetStorageAt && client == nil {
|
|
return nil, errors.New("ipld-eth-server is configured to forward eth_getStorageAt to proxy node but no proxy node is configured")
|
|
}
|
|
if config.ProxyOnError && client == nil {
|
|
return nil, errors.New("ipld-eth-server is configured to forward all calls to proxy node on errors but no proxy node is configured")
|
|
}
|
|
var ethClient *ethclient.Client
|
|
if client != nil {
|
|
ethClient = ethclient.NewClient(client)
|
|
}
|
|
return &PublicEthAPI{
|
|
B: b,
|
|
rpc: client,
|
|
ethClient: ethClient,
|
|
config: config,
|
|
}, nil
|
|
}
|
|
|
|
/*
|
|
|
|
Headers and blocks
|
|
|
|
*/
|
|
|
|
// decodeHash parses a hex-encoded 32-byte hash. The input may optionally
|
|
// be prefixed by 0x and can have a byte length up to 32.
|
|
func decodeHash(s string) (h common.Hash, inputLength int, err error) {
|
|
if strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X") {
|
|
s = s[2:]
|
|
}
|
|
if (len(s) & 1) > 0 {
|
|
s = "0" + s
|
|
}
|
|
b, err := hex.DecodeString(s)
|
|
if err != nil {
|
|
return common.Hash{}, 0, errors.New("hex string invalid")
|
|
}
|
|
if len(b) > 32 {
|
|
return common.Hash{}, len(b), errors.New("hex string too long, want at most 32 bytes")
|
|
}
|
|
return common.BytesToHash(b), len(b), nil
|
|
}
|
|
|
|
// GetHeaderByNumber returns the requested canonical block header.
|
|
// * When blockNr is -1 the chain head is returned.
|
|
// * We cannot support pending block calls since we do not have an active miner
|
|
func (pea *PublicEthAPI) GetHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (map[string]interface{}, error) {
|
|
header, err := pea.B.HeaderByNumber(ctx, number)
|
|
if header != nil && err == nil {
|
|
return pea.rpcMarshalHeader(header)
|
|
}
|
|
if pea.config.ProxyOnError {
|
|
if header, err := pea.ethClient.HeaderByNumber(ctx, big.NewInt(number.Int64())); header != nil && err == nil {
|
|
go pea.writeStateDiffAt(number.Int64())
|
|
return pea.rpcMarshalHeader(header)
|
|
}
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
|
|
// GetHeaderByHash returns the requested header by hash.
|
|
func (pea *PublicEthAPI) GetHeaderByHash(ctx context.Context, hash common.Hash) map[string]interface{} {
|
|
header, err := pea.B.HeaderByHash(ctx, hash)
|
|
if header != nil && err == nil {
|
|
if res, err := pea.rpcMarshalHeader(header); err == nil {
|
|
return res
|
|
}
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
var result map[string]interface{}
|
|
if err := pea.rpc.CallContext(ctx, &result, "eth_getHeaderByHash", hash); result != nil && err == nil {
|
|
go pea.writeStateDiffFor(hash)
|
|
return result
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// rpcMarshalHeader uses the generalized output filler, then adds the total difficulty field
|
|
func (pea *PublicEthAPI) rpcMarshalHeader(header *types.Header) (map[string]interface{}, error) {
|
|
fields := RPCMarshalHeader(header)
|
|
td, err := pea.B.GetTd(header.Hash())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
fields["totalDifficulty"] = (*hexutil.Big)(td)
|
|
|
|
return fields, nil
|
|
}
|
|
|
|
// BlockNumber returns the block number of the chain head.
|
|
func (pea *PublicEthAPI) BlockNumber() hexutil.Uint64 {
|
|
number, _ := pea.B.Retriever.RetrieveLastBlockNumber()
|
|
return hexutil.Uint64(number)
|
|
}
|
|
|
|
// GetBlockByNumber returns the requested canonical block.
|
|
// - When blockNr is -1 the chain head is returned.
|
|
// - We cannot support pending block calls since we do not have an active miner
|
|
// - When fullTx is true all transactions in the block are returned, otherwise
|
|
// only the transaction hash is returned.
|
|
func (pea *PublicEthAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (map[string]interface{}, error) {
|
|
block, err := pea.B.BlockByNumber(ctx, number)
|
|
if block != nil && err == nil {
|
|
return pea.rpcMarshalBlock(block, true, fullTx)
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
if block, err := pea.ethClient.BlockByNumber(ctx, big.NewInt(number.Int64())); block != nil && err == nil {
|
|
go pea.writeStateDiffAt(number.Int64())
|
|
return pea.rpcMarshalBlock(block, true, fullTx)
|
|
}
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
|
|
// GetBlockByHash returns the requested block. When fullTx is true all transactions in the block are returned in full
|
|
// detail, otherwise only the transaction hash is returned.
|
|
func (pea *PublicEthAPI) GetBlockByHash(ctx context.Context, hash common.Hash, fullTx bool) (map[string]interface{}, error) {
|
|
block, err := pea.B.BlockByHash(ctx, hash)
|
|
if block != nil && err == nil {
|
|
return pea.rpcMarshalBlock(block, true, fullTx)
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
if block, err := pea.ethClient.BlockByHash(ctx, hash); block != nil && err == nil {
|
|
go pea.writeStateDiffFor(hash)
|
|
return pea.rpcMarshalBlock(block, true, fullTx)
|
|
}
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
|
|
// ChainId is the EIP-155 replay-protection chain id for the current ethereum chain config.
|
|
func (pea *PublicEthAPI) ChainId() *hexutil.Big {
|
|
if pea.B.Config.ChainConfig.ChainID == nil || pea.B.Config.ChainConfig.ChainID.Cmp(big.NewInt(0)) <= 0 {
|
|
if pea.config.ProxyOnError {
|
|
if id, err := pea.ethClient.ChainID(context.Background()); err == nil {
|
|
return (*hexutil.Big)(id)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
return (*hexutil.Big)(pea.B.Config.ChainConfig.ChainID)
|
|
}
|
|
|
|
/*
|
|
|
|
Uncles
|
|
|
|
*/
|
|
|
|
// GetUncleByBlockNumberAndIndex returns the uncle block for the given block hash and index.
|
|
func (pea *PublicEthAPI) GetUncleByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) (map[string]interface{}, error) {
|
|
block, err := pea.B.BlockByNumber(ctx, blockNr)
|
|
if block != nil && err == nil {
|
|
uncles := block.Uncles()
|
|
if index >= hexutil.Uint(len(uncles)) {
|
|
log.Debugxf(ctx, "uncle with index %s request at block number %d was not found", index.String(), blockNr.Int64())
|
|
return nil, nil
|
|
}
|
|
block = types.NewBlockWithHeader(uncles[index])
|
|
return pea.rpcMarshalBlock(block, false, false)
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
if uncle, uncleHashes, err := getBlockAndUncleHashes(pea.rpc, ctx, "eth_getUncleByBlockNumberAndIndex", blockNr, index); uncle != nil && err == nil {
|
|
go pea.writeStateDiffAt(blockNr.Int64())
|
|
return pea.rpcMarshalBlockWithUncleHashes(uncle, uncleHashes, false, false)
|
|
}
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
|
|
// GetUncleByBlockHashAndIndex returns the uncle block for the given block hash and index. When fullTx is true
|
|
// all transactions in the block are returned in full detail, otherwise only the transaction hash is returned.
|
|
func (pea *PublicEthAPI) GetUncleByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) (map[string]interface{}, error) {
|
|
block, err := pea.B.BlockByHash(ctx, blockHash)
|
|
if block != nil {
|
|
uncles := block.Uncles()
|
|
if index >= hexutil.Uint(len(uncles)) {
|
|
log.Debugxf(ctx, "uncle with index %s request at block hash %s was not found", index.String(), blockHash.Hex())
|
|
return nil, nil
|
|
}
|
|
block = types.NewBlockWithHeader(uncles[index])
|
|
return pea.rpcMarshalBlock(block, false, false)
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
if uncle, uncleHashes, err := getBlockAndUncleHashes(pea.rpc, ctx, "eth_getUncleByBlockHashAndIndex", blockHash, index); uncle != nil && err == nil {
|
|
go pea.writeStateDiffFor(blockHash)
|
|
return pea.rpcMarshalBlockWithUncleHashes(uncle, uncleHashes, false, false)
|
|
}
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
|
|
// GetUncleCountByBlockNumber returns number of uncles in the block for the given block number
|
|
func (pea *PublicEthAPI) GetUncleCountByBlockNumber(ctx context.Context, blockNr rpc.BlockNumber) *hexutil.Uint {
|
|
if block, err := pea.B.BlockByNumber(ctx, blockNr); block != nil && err == nil {
|
|
n := hexutil.Uint(len(block.Uncles()))
|
|
return &n
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
var num *hexutil.Uint
|
|
if err := pea.rpc.CallContext(ctx, &num, "eth_getUncleCountByBlockNumber", blockNr); num != nil && err == nil {
|
|
go pea.writeStateDiffAt(blockNr.Int64())
|
|
return num
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetUncleCountByBlockHash returns number of uncles in the block for the given block hash
|
|
func (pea *PublicEthAPI) GetUncleCountByBlockHash(ctx context.Context, blockHash common.Hash) *hexutil.Uint {
|
|
if block, err := pea.B.BlockByHash(ctx, blockHash); block != nil && err == nil {
|
|
n := hexutil.Uint(len(block.Uncles()))
|
|
return &n
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
var num *hexutil.Uint
|
|
if err := pea.rpc.CallContext(ctx, &num, "eth_getUncleCountByBlockHash", blockHash); num != nil && err == nil {
|
|
go pea.writeStateDiffFor(blockHash)
|
|
return num
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
/*
|
|
|
|
Transactions
|
|
|
|
*/
|
|
|
|
// GetTransactionCount returns the number of transactions the given address has sent for the given block number
|
|
func (pea *PublicEthAPI) GetTransactionCount(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Uint64, error) {
|
|
count, err := pea.localGetTransactionCount(ctx, address, blockNrOrHash)
|
|
if count != nil && err == nil {
|
|
return count, nil
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
var num *hexutil.Uint64
|
|
if err := pea.rpc.CallContext(ctx, &num, "eth_getTransactionCount", address, blockNrOrHash); num != nil && err == nil {
|
|
go pea.writeStateDiffAtOrFor(blockNrOrHash)
|
|
return num, nil
|
|
}
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
|
|
func (pea *PublicEthAPI) localGetTransactionCount(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Uint64, error) {
|
|
account, err := pea.B.GetAccountByNumberOrHash(ctx, address, blockNrOrHash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
nonce := hexutil.Uint64(account.Nonce)
|
|
return &nonce, nil
|
|
}
|
|
|
|
// GetBlockTransactionCountByNumber returns the number of transactions in the block with the given block number.
|
|
func (pea *PublicEthAPI) GetBlockTransactionCountByNumber(ctx context.Context, blockNr rpc.BlockNumber) *hexutil.Uint {
|
|
if block, _ := pea.B.BlockByNumber(ctx, blockNr); block != nil {
|
|
n := hexutil.Uint(len(block.Transactions()))
|
|
return &n
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
var num *hexutil.Uint
|
|
if err := pea.rpc.CallContext(ctx, &num, "eth_getBlockTransactionCountByNumber", blockNr); num != nil && err == nil {
|
|
go pea.writeStateDiffAt(blockNr.Int64())
|
|
return num
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetBlockTransactionCountByHash returns the number of transactions in the block with the given hash.
|
|
func (pea *PublicEthAPI) GetBlockTransactionCountByHash(ctx context.Context, blockHash common.Hash) *hexutil.Uint {
|
|
if block, _ := pea.B.BlockByHash(ctx, blockHash); block != nil {
|
|
n := hexutil.Uint(len(block.Transactions()))
|
|
return &n
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
var num *hexutil.Uint
|
|
if err := pea.rpc.CallContext(ctx, &num, "eth_getBlockTransactionCountByHash", blockHash); num != nil && err == nil {
|
|
go pea.writeStateDiffFor(blockHash)
|
|
return num
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetTransactionByBlockNumberAndIndex returns the transaction for the given block number and index.
|
|
func (pea *PublicEthAPI) GetTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) *RPCTransaction {
|
|
if block, _ := pea.B.BlockByNumber(ctx, blockNr); block != nil {
|
|
return newRPCTransactionFromBlockIndex(block, uint64(index), pea.B.ChainConfig())
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
var tx *RPCTransaction
|
|
if err := pea.rpc.CallContext(ctx, &tx, "eth_getTransactionByBlockNumberAndIndex", blockNr, index); tx != nil && err == nil {
|
|
go pea.writeStateDiffAt(blockNr.Int64())
|
|
return tx
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetTransactionByBlockHashAndIndex returns the transaction for the given block hash and index.
|
|
func (pea *PublicEthAPI) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) *RPCTransaction {
|
|
if block, _ := pea.B.BlockByHash(ctx, blockHash); block != nil {
|
|
return newRPCTransactionFromBlockIndex(block, uint64(index), pea.B.ChainConfig())
|
|
}
|
|
|
|
if pea.config.ProxyOnError {
|
|
var tx *RPCTransaction
|
|
if err := pea.rpc.CallContext(ctx, &tx, "eth_getTransactionByBlockHashAndIndex", blockHash, index); tx != nil && err == nil {
|
|
go pea.writeStateDiffFor(blockHash)
|
|
return tx
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetRawTransactionByBlockNumberAndIndex returns the bytes of the transaction for the given block number and index.
|
|
func (pea *PublicEthAPI) GetRawTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) hexutil.Bytes {
|
|
if block, _ := pea.B.BlockByNumber(ctx, blockNr); block != nil {
|
|
return newRPCRawTransactionFromBlockIndex(block, uint64(index))
|
|
}
|
|
if pea.config.ProxyOnError {
|
|
var tx hexutil.Bytes
|
|
if err := pea.rpc.CallContext(ctx, &tx, "eth_getRawTransactionByBlockNumberAndIndex", blockNr, index); tx != nil && err == nil {
|
|
go pea.writeStateDiffAt(blockNr.Int64())
|
|
return tx
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GetRawTransactionByBlockHashAndIndex returns the bytes of the transaction for the given block hash and index.
|
|
func (pea *PublicEthAPI) GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) hexutil.Bytes {
|
|
if block, _ := pea.B.BlockByHash(ctx, blockHash); block != nil {
|
|
return newRPCRawTransactionFromBlockIndex(block, uint64(index))
|
|
}
|
|
if pea.config.ProxyOnError {
|
|
var tx hexutil.Bytes
|
|
if err := pea.rpc.CallContext(ctx, &tx, "eth_getRawTransactionByBlockHashAndIndex", blockHash, index); tx != nil && err == nil {
|
|
go pea.writeStateDiffFor(blockHash)
|
|
return tx
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GetTransactionByHash returns the transaction for the given hash
|
|
// eth ipld-eth-server cannot currently handle pending/tx_pool txs
|
|
func (pea *PublicEthAPI) GetTransactionByHash(ctx context.Context, hash common.Hash) (*RPCTransaction, error) {
|
|
_, tx, blockHash, blockNumber, index, err := pea.B.GetTransaction(ctx, hash)
|
|
if tx != nil && err == nil {
|
|
header, err := pea.B.HeaderByHash(ctx, blockHash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return NewRPCTransaction(tx, blockHash, blockNumber, header.Time, index, header.BaseFee, pea.B.ChainConfig()), nil
|
|
}
|
|
if pea.config.ProxyOnError {
|
|
var tx *RPCTransaction
|
|
if err := pea.rpc.CallContext(ctx, &tx, "eth_getTransactionByHash", hash); tx != nil && err == nil {
|
|
go pea.writeStateDiffFor(hash)
|
|
return tx, nil
|
|
}
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// GetRawTransactionByHash returns the bytes of the transaction for the given hash.
|
|
func (pea *PublicEthAPI) GetRawTransactionByHash(ctx context.Context, hash common.Hash) (hexutil.Bytes, error) {
|
|
// Retrieve a finalized transaction, or a pooled otherwise
|
|
_, tx, _, _, _, err := pea.B.GetTransaction(ctx, hash)
|
|
if tx != nil && err == nil {
|
|
return tx.MarshalBinary()
|
|
}
|
|
if pea.config.ProxyOnError {
|
|
var tx hexutil.Bytes
|
|
if err := pea.rpc.CallContext(ctx, &tx, "eth_getRawTransactionByHash", hash); tx != nil && err == nil {
|
|
go pea.writeStateDiffFor(hash)
|
|
return tx, nil
|
|
}
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// accessListResult returns an optional accesslist
|
|
// Its the result of the `debug_createAccessList` RPC call.
|
|
// It contains an error if the transaction itself failed.
|
|
type accessListResult struct {
|
|
Accesslist *types.AccessList `json:"accessList"`
|
|
Error string `json:"error,omitempty"`
|
|
GasUsed hexutil.Uint64 `json:"gasUsed"`
|
|
}
|
|
|
|
// CreateAccessList creates a EIP-2930 type AccessList for the given transaction.
|
|
// Reexec and BlockNrOrHash can be specified to create the accessList on top of a certain state.
|
|
func (pea *PublicEthAPI) CreateAccessList(ctx context.Context, args TransactionArgs, blockNrOrHash *rpc.BlockNumberOrHash) (*accessListResult, error) {
|
|
if pea.rpc != nil {
|
|
var res *accessListResult
|
|
if err := pea.rpc.CallContext(ctx, &res, "eth_createAccessList", args, blockNrOrHash); err != nil {
|
|
return nil, err
|
|
}
|
|
return res, nil
|
|
}
|
|
return nil, RequiresProxyError{method: "eth_createAccessList"}
|
|
}
|
|
|
|
type feeHistoryResult struct {
|
|
OldestBlock *hexutil.Big `json:"oldestBlock"`
|
|
Reward [][]*hexutil.Big `json:"reward,omitempty"`
|
|
BaseFee []*hexutil.Big `json:"baseFeePerGas,omitempty"`
|
|
GasUsedRatio []float64 `json:"gasUsedRatio"`
|
|
}
|
|
|
|
// FeeHistory returns the fee market history.
|
|
func (pea *PublicEthAPI) FeeHistory(ctx context.Context, blockCount int, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*feeHistoryResult, error) {
|
|
if pea.rpc != nil {
|
|
var res *feeHistoryResult
|
|
if err := pea.rpc.CallContext(ctx, &res, "eth_feeHistory", blockCount, lastBlock, rewardPercentiles); err != nil {
|
|
return nil, err
|
|
}
|
|
return res, nil
|
|
}
|
|
return nil, RequiresProxyError{method: "eth_feeHistory"}
|
|
}
|
|
|
|
// EstimateGas returns an estimate of the amount of gas needed to execute the
|
|
// given transaction against the current pending block.
|
|
func (pea *PublicEthAPI) EstimateGas(ctx context.Context, args TransactionArgs, blockNrOrHash *rpc.BlockNumberOrHash) (hexutil.Uint64, error) {
|
|
if pea.rpc != nil {
|
|
var res hexutil.Uint64
|
|
if err := pea.rpc.CallContext(ctx, &res, "eth_estimateGas", args, blockNrOrHash); err != nil {
|
|
return hexutil.Uint64(0), err
|
|
}
|
|
return res, nil
|
|
}
|
|
return hexutil.Uint64(0), RequiresProxyError{method: "eth_estimateGas"}
|
|
}
|
|
|
|
// GasPrice returns a suggestion for a gas price for legacy transactions.
|
|
func (pea *PublicEthAPI) GasPrice(ctx context.Context) (*hexutil.Big, error) {
|
|
if pea.rpc != nil {
|
|
var res *hexutil.Big
|
|
if err := pea.rpc.CallContext(ctx, &res, "eth_gasPrice"); err != nil {
|
|
return nil, err
|
|
}
|
|
return res, nil
|
|
}
|
|
return nil, RequiresProxyError{method: "eth_gasPrice"}
|
|
}
|
|
|
|
// MaxPriorityFeePerGas returns a suggestion for a gas tip cap for dynamic fee transactions.
|
|
func (pea *PublicEthAPI) MaxPriorityFeePerGas(ctx context.Context) (*hexutil.Big, error) {
|
|
if pea.rpc != nil {
|
|
var res *hexutil.Big
|
|
if err := pea.rpc.CallContext(ctx, &res, "eth_maxPriorityFeePerGas"); err != nil {
|
|
return nil, err
|
|
}
|
|
return res, nil
|
|
}
|
|
return nil, RequiresProxyError{method: "eth_maxPriorityFeePerGas"}
|
|
}
|
|
|
|
/*
|
|
|
|
Receipts and Logs
|
|
|
|
*/
|
|
|
|
// GetTransactionReceipt returns the transaction receipt for the given transaction hash.
|
|
func (pea *PublicEthAPI) GetTransactionReceipt(ctx context.Context, hash common.Hash) (map[string]interface{}, error) {
|
|
receipt, err := pea.localGetTransactionReceipt(ctx, hash)
|
|
if receipt != nil && err == nil {
|
|
return receipt, nil
|
|
}
|
|
if pea.config.ProxyOnError {
|
|
if receipt := pea.remoteGetTransactionReceipt(ctx, hash); receipt != nil {
|
|
go pea.writeStateDiffFor(hash)
|
|
return receipt, nil
|
|
}
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
func (pea *PublicEthAPI) localGetTransactionReceipt(ctx context.Context, hash common.Hash) (map[string]interface{}, error) {
|
|
// TODO: this can be optimized for Postgres
|
|
_, tx, blockHash, blockNumber, index, err := pea.B.GetTransaction(ctx, hash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if tx == nil {
|
|
return nil, nil
|
|
}
|
|
receipts, err := pea.B.GetReceipts(ctx, blockHash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
block, err := pea.B.BlockByHash(ctx, blockHash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var blobGasPrice *big.Int
|
|
if excessBlobGas := block.ExcessBlobGas(); excessBlobGas != nil {
|
|
blobGasPrice = eip4844.CalcBlobFee(*excessBlobGas)
|
|
}
|
|
err = receipts.DeriveFields(pea.B.Config.ChainConfig, blockHash, blockNumber, block.Time(), block.BaseFee(), blobGasPrice, block.Transactions())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(receipts) <= int(index) {
|
|
return nil, nil
|
|
}
|
|
receipt := receipts[index]
|
|
|
|
signer := SignerForTx(tx)
|
|
from, _ := types.Sender(signer, tx)
|
|
|
|
fields := map[string]interface{}{
|
|
"type": hexutil.Uint64(receipt.Type),
|
|
"blockHash": blockHash,
|
|
"blockNumber": hexutil.Uint64(blockNumber),
|
|
"transactionHash": hash,
|
|
"transactionIndex": hexutil.Uint64(index),
|
|
"from": from,
|
|
"to": tx.To(),
|
|
"gasUsed": hexutil.Uint64(receipt.GasUsed),
|
|
"cumulativeGasUsed": hexutil.Uint64(receipt.CumulativeGasUsed),
|
|
"contractAddress": nil,
|
|
"logs": receipt.Logs,
|
|
"logsBloom": receipt.Bloom,
|
|
"effectiveGasPrice": (*hexutil.Big)(receipt.EffectiveGasPrice),
|
|
}
|
|
|
|
// Assign receipt status or post state.
|
|
if len(receipt.PostState) > 0 {
|
|
fields["root"] = hexutil.Bytes(receipt.PostState)
|
|
} else {
|
|
fields["status"] = hexutil.Uint(receipt.Status)
|
|
}
|
|
if receipt.Logs == nil {
|
|
fields["logs"] = []*types.Log{}
|
|
}
|
|
|
|
if tx.Type() == types.BlobTxType {
|
|
fields["blobGasUsed"] = hexutil.Uint64(receipt.BlobGasUsed)
|
|
fields["blobGasPrice"] = (*hexutil.Big)(receipt.BlobGasPrice)
|
|
}
|
|
|
|
// If the ContractAddress is 20 0x0 bytes, assume it is not a contract creation
|
|
if receipt.ContractAddress != (common.Address{}) {
|
|
fields["contractAddress"] = receipt.ContractAddress
|
|
}
|
|
return fields, nil
|
|
}
|
|
|
|
func (pea *PublicEthAPI) remoteGetTransactionReceipt(ctx context.Context, hash common.Hash) map[string]interface{} {
|
|
var rct *RPCReceipt
|
|
if err := pea.rpc.CallContext(ctx, &rct, "eth_getTransactionReceipt", hash); rct != nil && err == nil {
|
|
return map[string]interface{}{
|
|
"blockHash": rct.BlockHash,
|
|
"blockNumber": rct.BlockNumber,
|
|
"transactionHash": rct.TransactionHash,
|
|
"transactionIndex": rct.TransactionIndex,
|
|
"from": rct.From,
|
|
"to": rct.To,
|
|
"gasUsed": rct.GasUsed,
|
|
"cumulativeGasUsed": rct.CumulativeGsUsed,
|
|
"contractAddress": rct.ContractAddress,
|
|
"logs": rct.Logs,
|
|
"logsBloom": rct.Bloom,
|
|
"root": rct.Root,
|
|
"status": rct.Status,
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GetLogs returns logs matching the given argument that are stored within the state.
|
|
//
|
|
// https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_getlogs
|
|
func (pea *PublicEthAPI) GetLogs(ctx context.Context, crit filters.FilterCriteria) ([]*types.Log, error) {
|
|
logs, err := pea.localGetLogs(crit)
|
|
if err != nil && pea.config.ProxyOnError {
|
|
var res []*types.Log
|
|
if err := pea.rpc.CallContext(ctx, &res, "eth_getLogs", crit); err == nil {
|
|
go pea.writeStateDiffWithCriteria(crit)
|
|
return res, nil
|
|
}
|
|
}
|
|
return logs, err
|
|
}
|
|
|
|
func (pea *PublicEthAPI) localGetLogs(crit filters.FilterCriteria) ([]*types.Log, error) {
|
|
// TODO: this can be optimized away from using the old cid retriever and ipld fetcher interfaces
|
|
// Convert FilterQuery into ReceiptFilter
|
|
addrStrs := make([]string, len(crit.Addresses))
|
|
for i, addr := range crit.Addresses {
|
|
addrStrs[i] = addr.String()
|
|
}
|
|
|
|
topicStrSets := make([][]string, len(crit.Topics))
|
|
for i, topicSet := range crit.Topics {
|
|
if i > 3 {
|
|
topicStrSets = topicStrSets[:4]
|
|
// don't allow more than 4 topics
|
|
break
|
|
}
|
|
for _, topic := range topicSet {
|
|
topicStrSets[i] = append(topicStrSets[i], topic.String())
|
|
}
|
|
}
|
|
filter := ReceiptFilter{
|
|
LogAddresses: addrStrs,
|
|
Topics: topicStrSets,
|
|
}
|
|
|
|
// If we have a blockHash to filter on, fire off single retrieval query
|
|
if crit.BlockHash != nil {
|
|
var filteredLogs []LogResult
|
|
filteredLogs, err := pea.B.Retriever.RetrieveFilteredLogsForBlock(pea.B.DB, filter, crit.BlockHash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var logs []*types.Log
|
|
logs, err = decomposeLogs(filteredLogs)
|
|
return logs, err
|
|
}
|
|
|
|
// Otherwise, create block range from criteria
|
|
// nil values are filled in; to request a single block have both ToBlock and FromBlock equal that number
|
|
|
|
// geth uses LatestBlockNumber as the default value for both begin and end, so we do the same
|
|
lastBlockNumber, err := pea.B.Retriever.RetrieveLastBlockNumber()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
start := lastBlockNumber
|
|
if crit.FromBlock != nil {
|
|
start, err = pea.B.NormalizeBlockNumber(rpc.BlockNumber(crit.FromBlock.Int64()))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
end := lastBlockNumber
|
|
if crit.ToBlock != nil {
|
|
end, err = pea.B.NormalizeBlockNumber(rpc.BlockNumber(crit.ToBlock.Int64()))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if pea.config.GetLogsBlockLimit > 0 && (end-start) > pea.config.GetLogsBlockLimit {
|
|
return nil, errors.New(
|
|
fmt.Sprintf(
|
|
"Invalid eth_getLogs request. 'fromBlock'-'toBlock' range too large. Max range: %d",
|
|
pea.config.GetLogsBlockLimit,
|
|
))
|
|
}
|
|
|
|
filteredLogs, err := pea.B.Retriever.RetrieveFilteredLogsForBlockRange(pea.B.DB, filter, start, end)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var logCIDs []*types.Log
|
|
logCIDs, err = decomposeLogs(filteredLogs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return logCIDs, err // need to return err variable so that we return the err = tx.Commit() assignment in the defer
|
|
}
|
|
|
|
/*
|
|
|
|
State and Storage
|
|
|
|
*/
|
|
|
|
// GetBalance returns the amount of wei for the given address in the state of the
|
|
// given block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta
|
|
// block numbers are also allowed.
|
|
func (pea *PublicEthAPI) GetBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error) {
|
|
bal, err := pea.localGetBalance(ctx, address, blockNrOrHash)
|
|
if err != nil && err != sql.ErrNoRows {
|
|
return nil, err
|
|
} else if bal != nil {
|
|
return bal, nil
|
|
}
|
|
if pea.config.ProxyOnError {
|
|
var res *hexutil.Big
|
|
if err := pea.rpc.CallContext(ctx, &res, "eth_getBalance", address, blockNrOrHash); res != nil && err == nil {
|
|
return res, nil
|
|
}
|
|
}
|
|
if err == sql.ErrNoRows {
|
|
return (*hexutil.Big)(big.NewInt(0)), nil
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
|
|
func (pea *PublicEthAPI) localGetBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error) {
|
|
account, err := pea.B.GetAccountByNumberOrHash(ctx, address, blockNrOrHash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return (*hexutil.Big)(account.Balance.ToBig()), nil
|
|
}
|
|
|
|
// GetStorageAt returns the storage from the state at the given address, key and
|
|
// block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta block
|
|
// numbers are also allowed.
|
|
func (pea *PublicEthAPI) GetStorageAt(ctx context.Context, address common.Address, key string, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
|
|
if pea.config.ForwardGetStorageAt {
|
|
var res hexutil.Bytes
|
|
// If forwarding all getStorageAt calls, don't request statediffing.
|
|
err := pea.rpc.CallContext(ctx, &res, "eth_getStorageAt", address, key, blockNrOrHash)
|
|
return res, err
|
|
}
|
|
|
|
storageVal, err := pea.B.GetStorageByNumberOrHash(ctx, address, common.HexToHash(key), blockNrOrHash)
|
|
if storageVal != nil && err == nil {
|
|
var value common.Hash
|
|
_, content, _, err := rlp.Split(storageVal)
|
|
if err == io.ErrUnexpectedEOF {
|
|
return hexutil.Bytes{}, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
value.SetBytes(content)
|
|
|
|
return value[:], nil
|
|
}
|
|
if pea.config.ProxyOnError {
|
|
log.Warnxf(ctx, "Missing eth_getStorageAt(%s, %s, %s)", address, key, blockNrOrHash.String())
|
|
var res hexutil.Bytes
|
|
if err := pea.rpc.CallContext(ctx, &res, "eth_getStorageAt", address, key, blockNrOrHash); res != nil && err == nil {
|
|
return res, nil
|
|
}
|
|
}
|
|
if err == sql.ErrNoRows {
|
|
return make([]byte, 32), nil
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// GetCode returns the code stored at the given address in the state for the given block number.
|
|
func (pea *PublicEthAPI) GetCode(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
|
|
code, err := pea.B.GetCodeByNumberOrHash(ctx, address, blockNrOrHash)
|
|
if code != nil && err == nil {
|
|
return code, nil
|
|
}
|
|
if pea.config.ProxyOnError {
|
|
var res hexutil.Bytes
|
|
if err := pea.rpc.CallContext(ctx, &res, "eth_getCode", address, blockNrOrHash); res != nil && err == nil {
|
|
return res, nil
|
|
}
|
|
}
|
|
if err == sql.ErrNoRows {
|
|
return code, nil
|
|
}
|
|
|
|
return nil, err
|
|
}
|
|
|
|
// GetProof returns the Merkle-proof for a given account and optionally some storage keys.
|
|
func (pea *PublicEthAPI) GetProof(ctx context.Context, address common.Address, storageKeys []string, blockNrOrHash rpc.BlockNumberOrHash) (*AccountResult, error) {
|
|
proof, err := pea.localGetProof(ctx, address, storageKeys, blockNrOrHash)
|
|
if proof != nil && err == nil {
|
|
return proof, nil
|
|
}
|
|
if pea.config.ProxyOnError {
|
|
var res *AccountResult
|
|
if err := pea.rpc.CallContext(ctx, &res, "eth_getProof", address, storageKeys, blockNrOrHash); res != nil && err == nil {
|
|
return res, nil
|
|
}
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// proofList implements ethdb.KeyValueWriter and collects the proofs as
|
|
// hex-strings for delivery to rpc-caller.
|
|
type proofList []string
|
|
|
|
func (n *proofList) Put(key []byte, value []byte) error {
|
|
*n = append(*n, hexutil.Encode(value))
|
|
return nil
|
|
}
|
|
|
|
func (n *proofList) Delete(key []byte) error {
|
|
panic("not supported")
|
|
}
|
|
|
|
// this continues to use ipfs-ethdb based geth StateDB as it requires trie access
|
|
func (pea *PublicEthAPI) localGetProof(ctx context.Context, address common.Address, storageKeys []string, blockNrOrHash rpc.BlockNumberOrHash) (*AccountResult, error) {
|
|
var (
|
|
keys = make([]common.Hash, len(storageKeys))
|
|
keyLengths = make([]int, len(storageKeys))
|
|
storageProof = make([]StorageResult, len(storageKeys))
|
|
)
|
|
// Deserialize all keys. This prevents state access on invalid input.
|
|
for i, hexKey := range storageKeys {
|
|
var err error
|
|
keys[i], keyLengths[i], err = decodeHash(hexKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
statedb, header, err := pea.B.IPLDTrieStateDBAndHeaderByNumberOrHash(ctx, blockNrOrHash)
|
|
// statedb, header, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
|
|
if statedb == nil || err != nil {
|
|
return nil, err
|
|
}
|
|
codeHash := statedb.GetCodeHash(address)
|
|
storageRoot := statedb.GetStorageRoot(address)
|
|
|
|
if len(keys) > 0 {
|
|
var storageTrie state.Trie
|
|
if storageRoot != types.EmptyRootHash && storageRoot != (common.Hash{}) {
|
|
id := trie.StorageTrieID(header.Root, crypto.Keccak256Hash(address.Bytes()), storageRoot)
|
|
st, err := trie.NewStateTrie(id, statedb.Database().TrieDB())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
storageTrie = st
|
|
}
|
|
// Create the proofs for the storageKeys.
|
|
for i, key := range keys {
|
|
// Output key encoding is a bit special: if the input was a 32-byte hash, it is
|
|
// returned as such. Otherwise, we apply the QUANTITY encoding mandated by the
|
|
// JSON-RPC spec for getProof. This behavior exists to preserve backwards
|
|
// compatibility with older client versions.
|
|
var outputKey string
|
|
if keyLengths[i] != 32 {
|
|
outputKey = hexutil.EncodeBig(key.Big())
|
|
} else {
|
|
outputKey = hexutil.Encode(key[:])
|
|
}
|
|
if storageTrie == nil {
|
|
storageProof[i] = StorageResult{outputKey, &hexutil.Big{}, []string{}}
|
|
continue
|
|
}
|
|
var proof proofList
|
|
if err := storageTrie.Prove(crypto.Keccak256(key.Bytes()), &proof); err != nil {
|
|
return nil, err
|
|
}
|
|
value := (*hexutil.Big)(statedb.GetState(address, key).Big())
|
|
storageProof[i] = StorageResult{outputKey, value, proof}
|
|
}
|
|
}
|
|
// Create the accountProof.
|
|
tr, err := trie.NewStateTrie(trie.StateTrieID(header.Root), statedb.Database().TrieDB())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var accountProof proofList
|
|
if err := tr.Prove(crypto.Keccak256(address.Bytes()), &accountProof); err != nil {
|
|
return nil, err
|
|
}
|
|
balance := statedb.GetBalance(address).ToBig()
|
|
return &AccountResult{
|
|
Address: address,
|
|
AccountProof: accountProof,
|
|
Balance: (*hexutil.Big)(balance),
|
|
CodeHash: codeHash,
|
|
Nonce: hexutil.Uint64(statedb.GetNonce(address)),
|
|
StorageHash: storageRoot,
|
|
StorageProof: storageProof,
|
|
}, statedb.Error()
|
|
}
|
|
|
|
// GetSlice returns a slice of state or storage nodes from a provided root to a provided path and past it to a certain depth
|
|
func (pea *PublicEthAPI) GetSlice(ctx context.Context, path string, depth int, root common.Hash, storage bool) (*GetSliceResponse, error) {
|
|
return pea.B.GetSlice(path, depth, root, storage)
|
|
}
|
|
|
|
// revertError is an API error that encompassas an EVM revertal with JSON error
|
|
// code and a binary data blob.
|
|
type revertError struct {
|
|
error
|
|
reason string // revert reason hex encoded
|
|
}
|
|
|
|
// ErrorCode returns the JSON error code for a revertal.
|
|
// See: https://github.com/ethereum/wiki/wiki/JSON-RPC-Error-Codes-Improvement-Proposal
|
|
func (e *revertError) ErrorCode() int {
|
|
return 3
|
|
}
|
|
|
|
// ErrorData returns the hex encoded revert reason.
|
|
func (e *revertError) ErrorData() interface{} {
|
|
return e.reason
|
|
}
|
|
|
|
func newRevertError(result *core.ExecutionResult) *revertError {
|
|
reason, errUnpack := abi.UnpackRevert(result.Revert())
|
|
err := errors.New("execution reverted")
|
|
if errUnpack == nil {
|
|
err = fmt.Errorf("execution reverted: %v", reason)
|
|
}
|
|
return &revertError{
|
|
error: err,
|
|
reason: hexutil.Encode(result.Revert()),
|
|
}
|
|
}
|
|
|
|
// OverrideAccount indicates the overriding fields of account during the execution
|
|
// of a message call.
|
|
// Note, state and stateDiff can't be specified at the same time. If state is
|
|
// set, message execution will only use the data in the given state. Otherwise
|
|
// if statDiff is set, all diff will be applied first and then execute the call
|
|
// message.
|
|
type OverrideAccount struct {
|
|
Nonce *hexutil.Uint64 `json:"nonce"`
|
|
Code *hexutil.Bytes `json:"code"`
|
|
Balance **hexutil.Big `json:"balance"`
|
|
State *map[common.Hash]common.Hash `json:"state"`
|
|
StateDiff *map[common.Hash]common.Hash `json:"stateDiff"`
|
|
}
|
|
|
|
// StateOverride is the collection of overridden accounts.
|
|
type StateOverride map[common.Address]OverrideAccount
|
|
|
|
// Apply overrides the fields of specified accounts into the given state.
|
|
func (diff *StateOverride) Apply(state *ipld_direct_state.StateDB) error {
|
|
if diff == nil {
|
|
return nil
|
|
}
|
|
for addr, account := range *diff {
|
|
// Override account nonce.
|
|
if account.Nonce != nil {
|
|
state.SetNonce(addr, uint64(*account.Nonce))
|
|
}
|
|
// Override account(contract) code.
|
|
if account.Code != nil {
|
|
state.SetCode(addr, *account.Code)
|
|
}
|
|
// Override account balance.
|
|
if account.Balance != nil {
|
|
state.SetBalance(addr, uint256.MustFromBig((*big.Int)(*account.Balance)))
|
|
}
|
|
if account.State != nil && account.StateDiff != nil {
|
|
return fmt.Errorf("account %s has both 'state' and 'stateDiff'", addr.Hex())
|
|
}
|
|
// Replace entire state if caller requires.
|
|
if account.State != nil {
|
|
state.SetStorage(addr, *account.State)
|
|
}
|
|
// Apply state diff into specified accounts.
|
|
if account.StateDiff != nil {
|
|
for key, value := range *account.StateDiff {
|
|
state.SetState(addr, key, value)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Call executes the given transaction on the state for the given block number.
|
|
//
|
|
// Additionally, the caller can specify a batch of contract for fields overriding.
|
|
//
|
|
// Note, this function doesn't make and changes in the state/blockchain and is
|
|
// useful to execute and retrieve values.
|
|
func (pea *PublicEthAPI) Call(ctx context.Context, args CallArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride) (hexutil.Bytes, error) {
|
|
if pea.config.ForwardEthCalls {
|
|
var hex hexutil.Bytes
|
|
err := pea.rpc.CallContext(ctx, &hex, "eth_call", args, blockNrOrHash, overrides)
|
|
return hex, err
|
|
}
|
|
|
|
result, err := DoCall(ctx, pea.B, args, blockNrOrHash, overrides, defaultEVMTimeout, pea.B.Config.RPCGasCap.Uint64())
|
|
|
|
// If the result contains a revert reason, try to unpack and return it.
|
|
if err == nil {
|
|
if len(result.Revert()) > 0 {
|
|
err = newRevertError(result)
|
|
} else if result.Err != nil {
|
|
err = result.Err
|
|
}
|
|
}
|
|
|
|
if err != nil && pea.config.ProxyOnError {
|
|
var hex hexutil.Bytes
|
|
if err := pea.rpc.CallContext(ctx, &hex, "eth_call", args, blockNrOrHash, overrides); hex != nil && err == nil {
|
|
return hex, nil
|
|
}
|
|
}
|
|
|
|
if result != nil {
|
|
return result.Return(), err
|
|
} else {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
func DoCall(ctx context.Context, b *Backend, args CallArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, timeout time.Duration, globalGasCap uint64) (*core.ExecutionResult, error) {
|
|
defer func(start time.Time) {
|
|
log.Debugxf(ctx, "Executing EVM call finished %s runtime %s", time.Now().String(), time.Since(start).String())
|
|
}(time.Now())
|
|
|
|
state, header, err := b.IPLDDirectStateDBAndHeaderByNumberOrHash(ctx, blockNrOrHash)
|
|
if state == nil || err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := overrides.Apply(state); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Setup context so it may be cancelled the call has completed
|
|
// or, in case of unmetered gas, setup a context with a timeout.
|
|
var cancel context.CancelFunc
|
|
if timeout > 0 {
|
|
ctx, cancel = context.WithTimeout(ctx, timeout)
|
|
} else {
|
|
ctx, cancel = context.WithCancel(ctx)
|
|
}
|
|
// Make sure the context is cancelled when the call has completed
|
|
// this makes sure resources are cleaned up.
|
|
defer cancel()
|
|
|
|
// Get a new instance of the EVM.
|
|
msg, err := args.ToMessage(globalGasCap, header.BaseFee)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
evm, vmError, err := b.GetEVM(ctx, msg, state, header)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Wait for the context to be done and cancel the evm. Even if the
|
|
// EVM has finished, cancelling may be done (repeatedly)
|
|
go func() {
|
|
<-ctx.Done()
|
|
evm.Cancel()
|
|
}()
|
|
|
|
// Execute the message.
|
|
gp := new(core.GasPool).AddGas(math.MaxUint64)
|
|
result, err := core.ApplyMessage(evm, msg, gp)
|
|
if err := vmError(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If the timer caused an abort, return an appropriate error message
|
|
if evm.Cancelled() {
|
|
return nil, fmt.Errorf("execution aborted (timeout = %v)", timeout)
|
|
}
|
|
if err != nil {
|
|
return result, fmt.Errorf("err: %w (supplied gas %d)", err, msg.GasLimit)
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
// writeStateDiffAtOrFor calls out to the proxy statediffing geth client to fill in a gap in the index
|
|
func (pea *PublicEthAPI) writeStateDiffAtOrFor(blockNrOrHash rpc.BlockNumberOrHash) {
|
|
// short circuit right away if the proxy doesn't support diffing
|
|
if !pea.config.SupportsStateDiff {
|
|
return
|
|
}
|
|
if blockNr, ok := blockNrOrHash.Number(); ok {
|
|
pea.writeStateDiffAt(blockNr.Int64())
|
|
return
|
|
}
|
|
if hash, ok := blockNrOrHash.Hash(); ok {
|
|
pea.writeStateDiffFor(hash)
|
|
}
|
|
}
|
|
|
|
// writeStateDiffWithCriteria calls out to the proxy statediffing geth client to fill in a gap in the index
|
|
func (pea *PublicEthAPI) writeStateDiffWithCriteria(crit filters.FilterCriteria) {
|
|
// short circuit right away if the proxy doesn't support diffing
|
|
if !pea.config.SupportsStateDiff || crit.BlockHash == nil {
|
|
return
|
|
}
|
|
pea.writeStateDiffFor(*crit.BlockHash)
|
|
}
|
|
|
|
// writeStateDiffAt calls out to the proxy statediffing geth client to fill in a gap in the index
|
|
func (pea *PublicEthAPI) writeStateDiffAt(height int64) {
|
|
if !pea.config.SupportsStateDiff {
|
|
return
|
|
}
|
|
// we use a separate context than the one provided by the client
|
|
ctx, cancel := context.WithTimeout(context.Background(), pea.config.StateDiffTimeout)
|
|
defer cancel()
|
|
var data json.RawMessage
|
|
params := statediff.Params{
|
|
IncludeBlock: true,
|
|
IncludeReceipts: true,
|
|
IncludeTD: true,
|
|
IncludeCode: true,
|
|
}
|
|
log.Debugf("Calling statediff_writeStateDiffAt(%d)", height)
|
|
if err := pea.rpc.CallContext(ctx, &data, "statediff_writeStateDiffAt", uint64(height), params); err != nil {
|
|
log.Errorf("writeStateDiffAt %d failed with err %s", height, err.Error())
|
|
}
|
|
}
|
|
|
|
// writeStateDiffFor calls out to the proxy statediffing geth client to fill in a gap in the index
|
|
func (pea *PublicEthAPI) writeStateDiffFor(blockHash common.Hash) {
|
|
if !pea.config.SupportsStateDiff {
|
|
return
|
|
}
|
|
// we use a separate context than the one provided by the client
|
|
ctx, cancel := context.WithTimeout(context.Background(), pea.config.StateDiffTimeout)
|
|
defer cancel()
|
|
var data json.RawMessage
|
|
params := statediff.Params{
|
|
IncludeBlock: true,
|
|
IncludeReceipts: true,
|
|
IncludeTD: true,
|
|
IncludeCode: true,
|
|
}
|
|
log.Debugf("Calling statediff_writeStateDiffFor(%s)", blockHash.Hex())
|
|
if err := pea.rpc.CallContext(ctx, &data, "statediff_writeStateDiffFor", blockHash, params); err != nil {
|
|
log.Errorf("writeStateDiffFor %s failed with err %s", blockHash.Hex(), err.Error())
|
|
}
|
|
}
|
|
|
|
// rpcMarshalBlock uses the generalized output filler, then adds the total difficulty field
|
|
func (pea *PublicEthAPI) rpcMarshalBlock(b *types.Block, inclTx bool, fullTx bool) (map[string]interface{}, error) {
|
|
fields := RPCMarshalBlock(b, inclTx, fullTx, pea.B.ChainConfig())
|
|
if inclTx {
|
|
td, err := pea.B.GetTd(b.Hash())
|
|
if err != nil {
|
|
err = fmt.Errorf("error getting TD for block at (%s, %s): %s", b.Number(), b.Hash(), err)
|
|
log.Error(err)
|
|
return nil, err
|
|
}
|
|
fields["totalDifficulty"] = (*hexutil.Big)(td)
|
|
}
|
|
return fields, nil
|
|
}
|
|
|
|
// rpcMarshalBlockWithUncleHashes uses the generalized output filler, then adds the total difficulty field
|
|
func (pea *PublicEthAPI) rpcMarshalBlockWithUncleHashes(b *types.Block, uncleHashes []common.Hash, inclTx bool, fullTx bool) (map[string]interface{}, error) {
|
|
fields, err := RPCMarshalBlockWithUncleHashes(b, uncleHashes, inclTx, fullTx, pea.B.ChainConfig())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
td, err := pea.B.GetTd(b.Hash())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fields["totalDifficulty"] = (*hexutil.Big)(td)
|
|
return fields, err
|
|
}
|
|
|
|
// toHexSlice creates a slice of hex-strings based on []byte.
|
|
func toHexSlice(b [][]byte) []string {
|
|
r := make([]string, len(b))
|
|
for i := range b {
|
|
r[i] = hexutil.Encode(b[i])
|
|
}
|
|
return r
|
|
}
|
|
|
|
// decomposeLogs return logs from LogResult.
|
|
func decomposeLogs(logCIDs []LogResult) ([]*types.Log, error) {
|
|
logs := make([]*types.Log, len(logCIDs))
|
|
for i, l := range logCIDs {
|
|
topics := make([]common.Hash, 0)
|
|
if l.Topic0 != "" {
|
|
topics = append(topics, common.HexToHash(l.Topic0))
|
|
}
|
|
if l.Topic1 != "" {
|
|
topics = append(topics, common.HexToHash(l.Topic1))
|
|
}
|
|
if l.Topic2 != "" {
|
|
topics = append(topics, common.HexToHash(l.Topic2))
|
|
}
|
|
if l.Topic3 != "" {
|
|
topics = append(topics, common.HexToHash(l.Topic3))
|
|
}
|
|
|
|
// TODO: should we convert string to uint ?
|
|
blockNum, err := strconv.ParseUint(l.BlockNumber, 10, 64)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
logs[i] = &types.Log{
|
|
Address: common.HexToAddress(l.Address),
|
|
Topics: topics,
|
|
Data: l.Data,
|
|
BlockNumber: blockNum,
|
|
TxHash: common.HexToHash(l.TxHash),
|
|
TxIndex: uint(l.TxnIndex),
|
|
BlockHash: common.HexToHash(l.BlockHash),
|
|
Index: uint(l.Index),
|
|
}
|
|
}
|
|
|
|
return logs, nil
|
|
}
|