2020-08-19 11:46:20 +00:00
|
|
|
package rpchelper
|
|
|
|
|
|
|
|
import (
|
2022-02-23 09:44:55 +00:00
|
|
|
"context"
|
2020-08-19 11:46:20 +00:00
|
|
|
"fmt"
|
2020-08-29 21:28:09 +00:00
|
|
|
|
2021-07-29 11:53:13 +00:00
|
|
|
"github.com/ledgerwatch/erigon-lib/kv"
|
2022-02-23 09:44:55 +00:00
|
|
|
"github.com/ledgerwatch/erigon-lib/kv/kvcache"
|
2021-05-20 18:25:53 +00:00
|
|
|
"github.com/ledgerwatch/erigon/cmd/rpcdaemon/filters"
|
|
|
|
"github.com/ledgerwatch/erigon/common"
|
|
|
|
"github.com/ledgerwatch/erigon/core/rawdb"
|
2022-02-23 09:44:55 +00:00
|
|
|
"github.com/ledgerwatch/erigon/core/state"
|
2021-05-20 18:25:53 +00:00
|
|
|
"github.com/ledgerwatch/erigon/core/types/accounts"
|
|
|
|
"github.com/ledgerwatch/erigon/eth/stagedsync/stages"
|
|
|
|
"github.com/ledgerwatch/erigon/rpc"
|
|
|
|
"github.com/ledgerwatch/erigon/turbo/adapter"
|
2020-08-19 11:46:20 +00:00
|
|
|
)
|
|
|
|
|
2021-06-11 12:19:10 +00:00
|
|
|
// unable to decode supplied params, or an invalid number of parameters
|
|
|
|
type nonCanonocalHashError struct{ hash common.Hash }
|
|
|
|
|
|
|
|
func (e nonCanonocalHashError) ErrorCode() int { return -32603 }
|
|
|
|
|
|
|
|
func (e nonCanonocalHashError) Error() string {
|
|
|
|
return fmt.Sprintf("hash %x is not currently canonical", e.hash)
|
|
|
|
}
|
|
|
|
|
2022-02-23 23:42:14 +00:00
|
|
|
func GetBlockNumber(blockNrOrHash rpc.BlockNumberOrHash, tx kv.Tx, filters *filters.Filters) (uint64, common.Hash, bool, error) {
|
2021-09-28 02:25:56 +00:00
|
|
|
return _GetBlockNumber(blockNrOrHash.RequireCanonical, blockNrOrHash, tx, filters)
|
|
|
|
}
|
|
|
|
|
2022-02-23 23:42:14 +00:00
|
|
|
func GetCanonicalBlockNumber(blockNrOrHash rpc.BlockNumberOrHash, tx kv.Tx, filters *filters.Filters) (uint64, common.Hash, bool, error) {
|
2021-09-28 02:25:56 +00:00
|
|
|
return _GetBlockNumber(true, blockNrOrHash, tx, filters)
|
|
|
|
}
|
|
|
|
|
2022-02-23 23:42:14 +00:00
|
|
|
func _GetBlockNumber(requireCanonical bool, blockNrOrHash rpc.BlockNumberOrHash, tx kv.Tx, filters *filters.Filters) (blockNumber uint64, hash common.Hash, latest bool, err error) {
|
|
|
|
var latestBlockNumber uint64
|
|
|
|
if latestBlockNumber, err = stages.GetStageProgress(tx, stages.Execution); err != nil {
|
|
|
|
return 0, common.Hash{}, false, fmt.Errorf("getting latest block number: %w", err)
|
|
|
|
}
|
|
|
|
var ok bool
|
|
|
|
hash, ok = blockNrOrHash.Hash()
|
2020-08-19 11:46:20 +00:00
|
|
|
if !ok {
|
2020-08-29 21:28:09 +00:00
|
|
|
number := *blockNrOrHash.BlockNumber
|
|
|
|
if number == rpc.LatestBlockNumber {
|
2022-02-23 23:42:14 +00:00
|
|
|
blockNumber = latestBlockNumber
|
2020-09-12 05:33:07 +00:00
|
|
|
} else if number == rpc.EarliestBlockNumber {
|
|
|
|
blockNumber = 0
|
|
|
|
} else if number == rpc.PendingBlockNumber {
|
2021-05-17 12:15:19 +00:00
|
|
|
pendingBlock := filters.LastPendingBlock()
|
2021-03-30 07:09:00 +00:00
|
|
|
if pendingBlock == nil {
|
2021-04-15 05:23:10 +00:00
|
|
|
blockNumber, err = stages.GetStageProgress(tx, stages.Execution)
|
2021-03-30 07:09:00 +00:00
|
|
|
if err != nil {
|
2022-02-23 23:42:14 +00:00
|
|
|
return 0, common.Hash{}, false, fmt.Errorf("getting latest block number: %w", err)
|
2021-03-30 07:09:00 +00:00
|
|
|
}
|
|
|
|
} else {
|
2022-02-23 23:42:14 +00:00
|
|
|
return pendingBlock.NumberU64(), pendingBlock.Hash(), false, nil
|
2021-03-30 07:09:00 +00:00
|
|
|
}
|
2020-08-29 21:28:09 +00:00
|
|
|
} else {
|
|
|
|
blockNumber = uint64(number.Int64())
|
|
|
|
}
|
2021-04-15 05:23:10 +00:00
|
|
|
hash, err = rawdb.ReadCanonicalHash(tx, blockNumber)
|
2020-08-19 11:46:20 +00:00
|
|
|
if err != nil {
|
2022-02-23 23:42:14 +00:00
|
|
|
return 0, common.Hash{}, false, err
|
2020-08-19 11:46:20 +00:00
|
|
|
}
|
|
|
|
} else {
|
2021-04-15 05:23:10 +00:00
|
|
|
number := rawdb.ReadHeaderNumber(tx, hash)
|
2021-01-02 19:28:22 +00:00
|
|
|
if number == nil {
|
2022-02-23 23:42:14 +00:00
|
|
|
return 0, common.Hash{}, false, fmt.Errorf("block %x not found", hash)
|
2020-08-19 11:46:20 +00:00
|
|
|
}
|
2021-01-02 19:28:22 +00:00
|
|
|
blockNumber = *number
|
2020-08-19 11:46:20 +00:00
|
|
|
|
2021-04-15 05:23:10 +00:00
|
|
|
ch, err := rawdb.ReadCanonicalHash(tx, blockNumber)
|
2020-10-10 06:05:56 +00:00
|
|
|
if err != nil {
|
2022-02-23 23:42:14 +00:00
|
|
|
return 0, common.Hash{}, false, err
|
2020-10-10 06:05:56 +00:00
|
|
|
}
|
2021-09-28 02:25:56 +00:00
|
|
|
if requireCanonical && ch != hash {
|
2022-02-23 23:42:14 +00:00
|
|
|
return 0, common.Hash{}, false, nonCanonocalHashError{hash}
|
2020-08-19 11:46:20 +00:00
|
|
|
}
|
|
|
|
}
|
2022-02-23 23:42:14 +00:00
|
|
|
return blockNumber, hash, blockNumber == latestBlockNumber, nil
|
2020-08-19 11:46:20 +00:00
|
|
|
}
|
|
|
|
|
2021-07-28 02:47:38 +00:00
|
|
|
func GetAccount(tx kv.Tx, blockNumber uint64, address common.Address) (*accounts.Account, error) {
|
2021-03-30 09:53:54 +00:00
|
|
|
reader := adapter.NewStateReader(tx, blockNumber)
|
2020-08-19 11:46:20 +00:00
|
|
|
return reader.ReadAccountData(address)
|
|
|
|
}
|
2022-02-23 09:44:55 +00:00
|
|
|
|
2022-02-23 23:42:14 +00:00
|
|
|
func CreateStateReader(ctx context.Context, tx kv.Tx, blockNrOrHash rpc.BlockNumberOrHash, filters *filters.Filters, stateCache kvcache.Cache) (state.StateReader, error) {
|
|
|
|
blockNumber, _, latest, err := _GetBlockNumber(true, blockNrOrHash, tx, filters)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2022-02-23 09:44:55 +00:00
|
|
|
var stateReader state.StateReader
|
2022-02-23 23:42:14 +00:00
|
|
|
if latest {
|
2022-02-23 09:44:55 +00:00
|
|
|
cacheView, err := stateCache.View(ctx, tx)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
stateReader = state.NewCachedReader2(cacheView, tx)
|
|
|
|
} else {
|
2022-03-19 02:36:35 +00:00
|
|
|
stateReader = state.NewPlainState(tx, blockNumber+1)
|
2022-02-23 09:44:55 +00:00
|
|
|
}
|
|
|
|
return stateReader, nil
|
|
|
|
}
|