You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
290 lines
8.9 KiB
290 lines
8.9 KiB
package core
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sort"
|
|
|
|
tmquery "github.com/tendermint/tendermint/internal/pubsub/query"
|
|
"github.com/tendermint/tendermint/internal/state/indexer"
|
|
"github.com/tendermint/tendermint/libs/bytes"
|
|
tmmath "github.com/tendermint/tendermint/libs/math"
|
|
"github.com/tendermint/tendermint/rpc/coretypes"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
// BlockchainInfo gets block headers for minHeight <= height <= maxHeight.
|
|
//
|
|
// If maxHeight does not yet exist, blocks up to the current height will be
|
|
// returned. If minHeight does not exist (due to pruning), earliest existing
|
|
// height will be used.
|
|
//
|
|
// At most 20 items will be returned. Block headers are returned in descending
|
|
// order (highest first).
|
|
//
|
|
// More: https://docs.tendermint.com/master/rpc/#/Info/blockchain
|
|
func (env *Environment) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) {
|
|
|
|
const limit int64 = 20
|
|
|
|
var err error
|
|
minHeight, maxHeight, err = filterMinMax(
|
|
env.BlockStore.Base(),
|
|
env.BlockStore.Height(),
|
|
minHeight,
|
|
maxHeight,
|
|
limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
env.Logger.Debug("BlockchainInfo", "maxHeight", maxHeight, "minHeight", minHeight)
|
|
|
|
blockMetas := make([]*types.BlockMeta, 0, maxHeight-minHeight+1)
|
|
for height := maxHeight; height >= minHeight; height-- {
|
|
blockMeta := env.BlockStore.LoadBlockMeta(height)
|
|
if blockMeta != nil {
|
|
blockMetas = append(blockMetas, blockMeta)
|
|
}
|
|
}
|
|
|
|
return &coretypes.ResultBlockchainInfo{
|
|
LastHeight: env.BlockStore.Height(),
|
|
BlockMetas: blockMetas,
|
|
}, nil
|
|
}
|
|
|
|
// error if either min or max are negative or min > max
|
|
// if 0, use blockstore base for min, latest block height for max
|
|
// enforce limit.
|
|
func filterMinMax(base, height, min, max, limit int64) (int64, int64, error) {
|
|
// filter negatives
|
|
if min < 0 || max < 0 {
|
|
return min, max, coretypes.ErrZeroOrNegativeHeight
|
|
}
|
|
|
|
// adjust for default values
|
|
if min == 0 {
|
|
min = 1
|
|
}
|
|
if max == 0 {
|
|
max = height
|
|
}
|
|
|
|
// limit max to the height
|
|
max = tmmath.MinInt64(height, max)
|
|
|
|
// limit min to the base
|
|
min = tmmath.MaxInt64(base, min)
|
|
|
|
// limit min to within `limit` of max
|
|
// so the total number of blocks returned will be `limit`
|
|
min = tmmath.MaxInt64(min, max-limit+1)
|
|
|
|
if min > max {
|
|
return min, max, fmt.Errorf("%w: min height %d can't be greater than max height %d",
|
|
coretypes.ErrInvalidRequest, min, max)
|
|
}
|
|
return min, max, nil
|
|
}
|
|
|
|
// Block gets block at a given height.
|
|
// If no height is provided, it will fetch the latest block.
|
|
// More: https://docs.tendermint.com/master/rpc/#/Info/block
|
|
func (env *Environment) Block(ctx context.Context, heightPtr *int64) (*coretypes.ResultBlock, error) {
|
|
height, err := env.getHeight(env.BlockStore.Height(), heightPtr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
blockMeta := env.BlockStore.LoadBlockMeta(height)
|
|
if blockMeta == nil {
|
|
return &coretypes.ResultBlock{BlockID: types.BlockID{}, Block: nil}, nil
|
|
}
|
|
|
|
block := env.BlockStore.LoadBlock(height)
|
|
return &coretypes.ResultBlock{BlockID: blockMeta.BlockID, Block: block}, nil
|
|
}
|
|
|
|
// BlockByHash gets block by hash.
|
|
// More: https://docs.tendermint.com/master/rpc/#/Info/block_by_hash
|
|
func (env *Environment) BlockByHash(ctx context.Context, hash bytes.HexBytes) (*coretypes.ResultBlock, error) {
|
|
// N.B. The hash parameter is HexBytes so that the reflective parameter
|
|
// decoding logic in the HTTP service will correctly translate from JSON.
|
|
// See https://github.com/tendermint/tendermint/issues/6802 for context.
|
|
|
|
block := env.BlockStore.LoadBlockByHash(hash)
|
|
if block == nil {
|
|
return &coretypes.ResultBlock{BlockID: types.BlockID{}, Block: nil}, nil
|
|
}
|
|
// If block is not nil, then blockMeta can't be nil.
|
|
blockMeta := env.BlockStore.LoadBlockMeta(block.Height)
|
|
return &coretypes.ResultBlock{BlockID: blockMeta.BlockID, Block: block}, nil
|
|
}
|
|
|
|
// Header gets block header at a given height.
|
|
// If no height is provided, it will fetch the latest header.
|
|
// More: https://docs.tendermint.com/master/rpc/#/Info/header
|
|
func (env *Environment) Header(ctx context.Context, heightPtr *int64) (*coretypes.ResultHeader, error) {
|
|
height, err := env.getHeight(env.BlockStore.Height(), heightPtr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
blockMeta := env.BlockStore.LoadBlockMeta(height)
|
|
if blockMeta == nil {
|
|
return &coretypes.ResultHeader{}, nil
|
|
}
|
|
|
|
return &coretypes.ResultHeader{Header: &blockMeta.Header}, nil
|
|
}
|
|
|
|
// HeaderByHash gets header by hash.
|
|
// More: https://docs.tendermint.com/master/rpc/#/Info/header_by_hash
|
|
func (env *Environment) HeaderByHash(ctx context.Context, hash bytes.HexBytes) (*coretypes.ResultHeader, error) {
|
|
// N.B. The hash parameter is HexBytes so that the reflective parameter
|
|
// decoding logic in the HTTP service will correctly translate from JSON.
|
|
// See https://github.com/tendermint/tendermint/issues/6802 for context.
|
|
|
|
blockMeta := env.BlockStore.LoadBlockMetaByHash(hash)
|
|
if blockMeta == nil {
|
|
return &coretypes.ResultHeader{}, nil
|
|
}
|
|
|
|
return &coretypes.ResultHeader{Header: &blockMeta.Header}, nil
|
|
}
|
|
|
|
// Commit gets block commit at a given height.
|
|
// If no height is provided, it will fetch the commit for the latest block.
|
|
// More: https://docs.tendermint.com/master/rpc/#/Info/commit
|
|
func (env *Environment) Commit(ctx context.Context, heightPtr *int64) (*coretypes.ResultCommit, error) {
|
|
height, err := env.getHeight(env.BlockStore.Height(), heightPtr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
blockMeta := env.BlockStore.LoadBlockMeta(height)
|
|
if blockMeta == nil {
|
|
return nil, nil
|
|
}
|
|
header := blockMeta.Header
|
|
|
|
// If the next block has not been committed yet,
|
|
// use a non-canonical commit
|
|
if height == env.BlockStore.Height() {
|
|
commit := env.BlockStore.LoadSeenCommit()
|
|
// NOTE: we can't yet ensure atomicity of operations in asserting
|
|
// whether this is the latest height and retrieving the seen commit
|
|
if commit != nil && commit.Height == height {
|
|
return coretypes.NewResultCommit(&header, commit, false), nil
|
|
}
|
|
}
|
|
|
|
// Return the canonical commit (comes from the block at height+1)
|
|
commit := env.BlockStore.LoadBlockCommit(height)
|
|
if commit == nil {
|
|
return nil, nil
|
|
}
|
|
return coretypes.NewResultCommit(&header, commit, true), nil
|
|
}
|
|
|
|
// BlockResults gets ABCIResults at a given height.
|
|
// If no height is provided, it will fetch results for the latest block.
|
|
//
|
|
// Results are for the height of the block containing the txs.
|
|
// More: https://docs.tendermint.com/master/rpc/#/Info/block_results
|
|
func (env *Environment) BlockResults(ctx context.Context, heightPtr *int64) (*coretypes.ResultBlockResults, error) {
|
|
height, err := env.getHeight(env.BlockStore.Height(), heightPtr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
results, err := env.StateStore.LoadABCIResponses(height)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var totalGasUsed int64
|
|
for _, res := range results.FinalizeBlock.GetTxResults() {
|
|
totalGasUsed += res.GetGasUsed()
|
|
}
|
|
|
|
return &coretypes.ResultBlockResults{
|
|
Height: height,
|
|
TxsResults: results.FinalizeBlock.TxResults,
|
|
TotalGasUsed: totalGasUsed,
|
|
FinalizeBlockEvents: results.FinalizeBlock.Events,
|
|
ValidatorUpdates: results.FinalizeBlock.ValidatorUpdates,
|
|
ConsensusParamUpdates: results.FinalizeBlock.ConsensusParamUpdates,
|
|
}, nil
|
|
}
|
|
|
|
// BlockSearch searches for a paginated set of blocks matching the provided
|
|
// query.
|
|
func (env *Environment) BlockSearch(
|
|
ctx context.Context,
|
|
query string,
|
|
pagePtr, perPagePtr *int,
|
|
orderBy string,
|
|
) (*coretypes.ResultBlockSearch, error) {
|
|
|
|
if !indexer.KVSinkEnabled(env.EventSinks) {
|
|
return nil, fmt.Errorf("block searching is disabled due to no kvEventSink")
|
|
}
|
|
|
|
q, err := tmquery.New(query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var kvsink indexer.EventSink
|
|
for _, sink := range env.EventSinks {
|
|
if sink.Type() == indexer.KV {
|
|
kvsink = sink
|
|
}
|
|
}
|
|
|
|
results, err := kvsink.SearchBlockEvents(ctx, q)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// sort results (must be done before pagination)
|
|
switch orderBy {
|
|
case "desc", "":
|
|
sort.Slice(results, func(i, j int) bool { return results[i] > results[j] })
|
|
|
|
case "asc":
|
|
sort.Slice(results, func(i, j int) bool { return results[i] < results[j] })
|
|
|
|
default:
|
|
return nil, fmt.Errorf("expected order_by to be either `asc` or `desc` or empty: %w", coretypes.ErrInvalidRequest)
|
|
}
|
|
|
|
// paginate results
|
|
totalCount := len(results)
|
|
perPage := env.validatePerPage(perPagePtr)
|
|
|
|
page, err := validatePage(pagePtr, perPage, totalCount)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
skipCount := validateSkipCount(page, perPage)
|
|
pageSize := tmmath.MinInt(perPage, totalCount-skipCount)
|
|
|
|
apiResults := make([]*coretypes.ResultBlock, 0, pageSize)
|
|
for i := skipCount; i < skipCount+pageSize; i++ {
|
|
block := env.BlockStore.LoadBlock(results[i])
|
|
if block != nil {
|
|
blockMeta := env.BlockStore.LoadBlockMeta(block.Height)
|
|
if blockMeta != nil {
|
|
apiResults = append(apiResults, &coretypes.ResultBlock{
|
|
Block: block,
|
|
BlockID: blockMeta.BlockID,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
return &coretypes.ResultBlockSearch{Blocks: apiResults, TotalCount: totalCount}, nil
|
|
}
|