434 lines
12 KiB
Go
434 lines
12 KiB
Go
|
package baseapp
|
||
|
|
||
|
import (
|
||
|
"fmt"
|
||
|
"os"
|
||
|
"sort"
|
||
|
"strings"
|
||
|
|
||
|
abci "github.com/tendermint/tendermint/abci/types"
|
||
|
|
||
|
"github.com/cosmos/cosmos-sdk/codec"
|
||
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
||
|
)
|
||
|
|
||
|
// InitChain implements the ABCI interface. It runs the initialization logic
|
||
|
// directly on the CommitMultiStore.
|
||
|
func (app *BaseApp) InitChain(req abci.RequestInitChain) (res abci.ResponseInitChain) {
|
||
|
// stash the consensus params in the cms main store and memoize
|
||
|
if req.ConsensusParams != nil {
|
||
|
app.setConsensusParams(req.ConsensusParams)
|
||
|
app.storeConsensusParams(req.ConsensusParams)
|
||
|
}
|
||
|
|
||
|
initHeader := abci.Header{ChainID: req.ChainId, Time: req.Time}
|
||
|
|
||
|
// initialize the deliver state and check state with a correct header
|
||
|
app.setDeliverState(initHeader)
|
||
|
app.setCheckState(initHeader)
|
||
|
|
||
|
if app.initChainer == nil {
|
||
|
return
|
||
|
}
|
||
|
|
||
|
// reset the inter-block cache in case successive InitChain calls are made
|
||
|
if app.interBlockCache != nil {
|
||
|
app.interBlockCache.Reset()
|
||
|
}
|
||
|
|
||
|
// add block gas meter for any genesis transactions (allow infinite gas)
|
||
|
app.deliverState.ctx = app.deliverState.ctx.WithBlockGasMeter(sdk.NewInfiniteGasMeter())
|
||
|
|
||
|
res = app.initChainer(app.deliverState.ctx, req)
|
||
|
|
||
|
// sanity check
|
||
|
if len(req.Validators) > 0 {
|
||
|
if len(req.Validators) != len(res.Validators) {
|
||
|
panic(
|
||
|
fmt.Errorf(
|
||
|
"len(RequestInitChain.Validators) != len(GenesisValidators) (%d != %d)",
|
||
|
len(req.Validators), len(res.Validators),
|
||
|
),
|
||
|
)
|
||
|
}
|
||
|
|
||
|
sort.Sort(abci.ValidatorUpdates(req.Validators))
|
||
|
sort.Sort(abci.ValidatorUpdates(res.Validators))
|
||
|
|
||
|
for i, val := range res.Validators {
|
||
|
if !val.Equal(req.Validators[i]) {
|
||
|
panic(fmt.Errorf("genesisValidators[%d] != req.Validators[%d] ", i, i))
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// NOTE: We don't commit, but BeginBlock for block 1 starts from this
|
||
|
// deliverState.
|
||
|
return
|
||
|
}
|
||
|
|
||
|
// Info implements the ABCI interface.
|
||
|
func (app *BaseApp) Info(req abci.RequestInfo) abci.ResponseInfo {
|
||
|
lastCommitID := app.cms.LastCommitID()
|
||
|
|
||
|
return abci.ResponseInfo{
|
||
|
Data: app.name,
|
||
|
LastBlockHeight: lastCommitID.Version,
|
||
|
LastBlockAppHash: lastCommitID.Hash,
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// SetOption implements the ABCI interface.
|
||
|
func (app *BaseApp) SetOption(req abci.RequestSetOption) (res abci.ResponseSetOption) {
|
||
|
// TODO: Implement!
|
||
|
return
|
||
|
}
|
||
|
|
||
|
// FilterPeerByAddrPort filters peers by address/port.
|
||
|
func (app *BaseApp) FilterPeerByAddrPort(info string) abci.ResponseQuery {
|
||
|
if app.addrPeerFilter != nil {
|
||
|
return app.addrPeerFilter(info)
|
||
|
}
|
||
|
return abci.ResponseQuery{}
|
||
|
}
|
||
|
|
||
|
// FilterPeerByIDfilters peers by node ID.
|
||
|
func (app *BaseApp) FilterPeerByID(info string) abci.ResponseQuery {
|
||
|
if app.idPeerFilter != nil {
|
||
|
return app.idPeerFilter(info)
|
||
|
}
|
||
|
return abci.ResponseQuery{}
|
||
|
}
|
||
|
|
||
|
// BeginBlock implements the ABCI application interface.
|
||
|
func (app *BaseApp) BeginBlock(req abci.RequestBeginBlock) (res abci.ResponseBeginBlock) {
|
||
|
if app.cms.TracingEnabled() {
|
||
|
app.cms.SetTracingContext(sdk.TraceContext(
|
||
|
map[string]interface{}{"blockHeight": req.Header.Height},
|
||
|
))
|
||
|
}
|
||
|
|
||
|
if err := app.validateHeight(req); err != nil {
|
||
|
panic(err)
|
||
|
}
|
||
|
|
||
|
// Initialize the DeliverTx state. If this is the first block, it should
|
||
|
// already be initialized in InitChain. Otherwise app.deliverState will be
|
||
|
// nil, since it is reset on Commit.
|
||
|
if app.deliverState == nil {
|
||
|
app.setDeliverState(req.Header)
|
||
|
} else {
|
||
|
// In the first block, app.deliverState.ctx will already be initialized
|
||
|
// by InitChain. Context is now updated with Header information.
|
||
|
app.deliverState.ctx = app.deliverState.ctx.
|
||
|
WithBlockHeader(req.Header).
|
||
|
WithBlockHeight(req.Header.Height)
|
||
|
}
|
||
|
|
||
|
// add block gas meter
|
||
|
var gasMeter sdk.GasMeter
|
||
|
if maxGas := app.getMaximumBlockGas(); maxGas > 0 {
|
||
|
gasMeter = sdk.NewGasMeter(maxGas)
|
||
|
} else {
|
||
|
gasMeter = sdk.NewInfiniteGasMeter()
|
||
|
}
|
||
|
|
||
|
app.deliverState.ctx = app.deliverState.ctx.WithBlockGasMeter(gasMeter)
|
||
|
|
||
|
if app.beginBlocker != nil {
|
||
|
res = app.beginBlocker(app.deliverState.ctx, req)
|
||
|
}
|
||
|
|
||
|
// set the signed validators for addition to context in deliverTx
|
||
|
app.voteInfos = req.LastCommitInfo.GetVotes()
|
||
|
return
|
||
|
}
|
||
|
|
||
|
// EndBlock implements the ABCI interface.
|
||
|
func (app *BaseApp) EndBlock(req abci.RequestEndBlock) (res abci.ResponseEndBlock) {
|
||
|
if app.deliverState.ms.TracingEnabled() {
|
||
|
app.deliverState.ms = app.deliverState.ms.SetTracingContext(nil).(sdk.CacheMultiStore)
|
||
|
}
|
||
|
|
||
|
if app.endBlocker != nil {
|
||
|
res = app.endBlocker(app.deliverState.ctx, req)
|
||
|
}
|
||
|
|
||
|
return
|
||
|
}
|
||
|
|
||
|
// CheckTx implements the ABCI interface. It runs the "basic checks" to see
|
||
|
// whether or not a transaction can possibly be executed, first decoding and then
|
||
|
// the ante handler (which checks signatures/fees/ValidateBasic).
|
||
|
//
|
||
|
// NOTE:CheckTx does not run the actual Msg handler function(s).
|
||
|
func (app *BaseApp) CheckTx(req abci.RequestCheckTx) (res abci.ResponseCheckTx) {
|
||
|
var result sdk.Result
|
||
|
|
||
|
tx, err := app.txDecoder(req.Tx)
|
||
|
if err != nil {
|
||
|
result = err.Result()
|
||
|
} else {
|
||
|
result = app.runTx(runTxModeCheck, req.Tx, tx)
|
||
|
}
|
||
|
|
||
|
return abci.ResponseCheckTx{
|
||
|
Code: uint32(result.Code),
|
||
|
Data: result.Data,
|
||
|
Log: result.Log,
|
||
|
GasWanted: int64(result.GasWanted), // TODO: Should type accept unsigned ints?
|
||
|
GasUsed: int64(result.GasUsed), // TODO: Should type accept unsigned ints?
|
||
|
Events: result.Events.ToABCIEvents(),
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// DeliverTx implements the ABCI interface.
|
||
|
func (app *BaseApp) DeliverTx(req abci.RequestDeliverTx) (res abci.ResponseDeliverTx) {
|
||
|
var result sdk.Result
|
||
|
|
||
|
tx, err := app.txDecoder(req.Tx)
|
||
|
if err != nil {
|
||
|
result = err.Result()
|
||
|
} else {
|
||
|
result = app.runTx(runTxModeDeliver, req.Tx, tx)
|
||
|
}
|
||
|
|
||
|
return abci.ResponseDeliverTx{
|
||
|
Code: uint32(result.Code),
|
||
|
Codespace: string(result.Codespace),
|
||
|
Data: result.Data,
|
||
|
Log: result.Log,
|
||
|
GasWanted: int64(result.GasWanted), // TODO: Should type accept unsigned ints?
|
||
|
GasUsed: int64(result.GasUsed), // TODO: Should type accept unsigned ints?
|
||
|
Events: result.Events.ToABCIEvents(),
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Commit implements the ABCI interface. It will commit all state that exists in
|
||
|
// the deliver state's multi-store and includes the resulting commit ID in the
|
||
|
// returned abci.ResponseCommit. Commit will set the check state based on the
|
||
|
// latest header and reset the deliver state. Also, if a non-zero halt height is
|
||
|
// defined in config, Commit will execute a deferred function call to check
|
||
|
// against that height and gracefully halt if it matches the latest committed
|
||
|
// height.
|
||
|
func (app *BaseApp) Commit() (res abci.ResponseCommit) {
|
||
|
header := app.deliverState.ctx.BlockHeader()
|
||
|
|
||
|
// Write the DeliverTx state which is cache-wrapped and commit the MultiStore.
|
||
|
// The write to the DeliverTx state writes all state transitions to the root
|
||
|
// MultiStore (app.cms) so when Commit() is called is persists those values.
|
||
|
app.deliverState.ms.Write()
|
||
|
commitID := app.cms.Commit()
|
||
|
app.logger.Debug("Commit synced", "commit", fmt.Sprintf("%X", commitID))
|
||
|
|
||
|
// Reset the Check state to the latest committed.
|
||
|
//
|
||
|
// NOTE: This is safe because Tendermint holds a lock on the mempool for
|
||
|
// Commit. Use the header from this latest block.
|
||
|
app.setCheckState(header)
|
||
|
|
||
|
// empty/reset the deliver state
|
||
|
app.deliverState = nil
|
||
|
|
||
|
defer func() {
|
||
|
if app.haltHeight > 0 && uint64(header.Height) == app.haltHeight {
|
||
|
app.logger.Info("halting node per configuration", "height", app.haltHeight)
|
||
|
os.Exit(0)
|
||
|
}
|
||
|
}()
|
||
|
|
||
|
return abci.ResponseCommit{
|
||
|
Data: commitID.Hash,
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Query implements the ABCI interface. It delegates to CommitMultiStore if it
|
||
|
// implements Queryable.
|
||
|
func (app *BaseApp) Query(req abci.RequestQuery) (res abci.ResponseQuery) {
|
||
|
path := splitPath(req.Path)
|
||
|
if len(path) == 0 {
|
||
|
msg := "no query path provided"
|
||
|
return sdk.ErrUnknownRequest(msg).QueryResult()
|
||
|
}
|
||
|
|
||
|
switch path[0] {
|
||
|
// "/app" prefix for special application queries
|
||
|
case "app":
|
||
|
return handleQueryApp(app, path, req)
|
||
|
|
||
|
case "store":
|
||
|
return handleQueryStore(app, path, req)
|
||
|
|
||
|
case "p2p":
|
||
|
return handleQueryP2P(app, path, req)
|
||
|
|
||
|
case "custom":
|
||
|
return handleQueryCustom(app, path, req)
|
||
|
}
|
||
|
|
||
|
msg := "unknown query path"
|
||
|
return sdk.ErrUnknownRequest(msg).QueryResult()
|
||
|
}
|
||
|
|
||
|
func handleQueryApp(app *BaseApp, path []string, req abci.RequestQuery) (res abci.ResponseQuery) {
|
||
|
if len(path) >= 2 {
|
||
|
var result sdk.Result
|
||
|
|
||
|
switch path[1] {
|
||
|
case "simulate":
|
||
|
txBytes := req.Data
|
||
|
tx, err := app.txDecoder(txBytes)
|
||
|
if err != nil {
|
||
|
result = err.Result()
|
||
|
} else {
|
||
|
result = app.Simulate(txBytes, tx)
|
||
|
}
|
||
|
|
||
|
case "version":
|
||
|
return abci.ResponseQuery{
|
||
|
Code: uint32(sdk.CodeOK),
|
||
|
Codespace: string(sdk.CodespaceRoot),
|
||
|
Height: req.Height,
|
||
|
Value: []byte(app.appVersion),
|
||
|
}
|
||
|
|
||
|
default:
|
||
|
result = sdk.ErrUnknownRequest(fmt.Sprintf("unknown query: %s", path)).Result()
|
||
|
}
|
||
|
|
||
|
value := codec.Cdc.MustMarshalBinaryLengthPrefixed(result)
|
||
|
return abci.ResponseQuery{
|
||
|
Code: uint32(sdk.CodeOK),
|
||
|
Codespace: string(sdk.CodespaceRoot),
|
||
|
Height: req.Height,
|
||
|
Value: value,
|
||
|
}
|
||
|
}
|
||
|
|
||
|
msg := "expected second parameter to be either 'simulate' or 'version', neither was present"
|
||
|
return sdk.ErrUnknownRequest(msg).QueryResult()
|
||
|
}
|
||
|
|
||
|
func handleQueryStore(app *BaseApp, path []string, req abci.RequestQuery) abci.ResponseQuery {
|
||
|
// "/store" prefix for store queries
|
||
|
queryable, ok := app.cms.(sdk.Queryable)
|
||
|
if !ok {
|
||
|
msg := "multistore doesn't support queries"
|
||
|
return sdk.ErrUnknownRequest(msg).QueryResult()
|
||
|
}
|
||
|
|
||
|
req.Path = "/" + strings.Join(path[1:], "/")
|
||
|
|
||
|
// when a client did not provide a query height, manually inject the latest
|
||
|
if req.Height == 0 {
|
||
|
req.Height = app.LastBlockHeight()
|
||
|
}
|
||
|
|
||
|
if req.Height <= 1 && req.Prove {
|
||
|
return sdk.ErrInternal("cannot query with proof when height <= 1; please provide a valid height").QueryResult()
|
||
|
}
|
||
|
|
||
|
resp := queryable.Query(req)
|
||
|
resp.Height = req.Height
|
||
|
|
||
|
return resp
|
||
|
}
|
||
|
|
||
|
func handleQueryP2P(app *BaseApp, path []string, _ abci.RequestQuery) (res abci.ResponseQuery) {
|
||
|
// "/p2p" prefix for p2p queries
|
||
|
if len(path) >= 4 {
|
||
|
cmd, typ, arg := path[1], path[2], path[3]
|
||
|
switch cmd {
|
||
|
case "filter":
|
||
|
switch typ {
|
||
|
case "addr":
|
||
|
return app.FilterPeerByAddrPort(arg)
|
||
|
|
||
|
case "id":
|
||
|
return app.FilterPeerByID(arg)
|
||
|
}
|
||
|
|
||
|
default:
|
||
|
msg := "expected second parameter to be 'filter'"
|
||
|
return sdk.ErrUnknownRequest(msg).QueryResult()
|
||
|
}
|
||
|
}
|
||
|
|
||
|
msg := "Expected path is p2p filter <addr|id> <parameter>"
|
||
|
return sdk.ErrUnknownRequest(msg).QueryResult()
|
||
|
}
|
||
|
|
||
|
func handleQueryCustom(app *BaseApp, path []string, req abci.RequestQuery) (res abci.ResponseQuery) {
|
||
|
// path[0] should be "custom" because "/custom" prefix is required for keeper
|
||
|
// queries.
|
||
|
//
|
||
|
// The queryRouter routes using path[1]. For example, in the path
|
||
|
// "custom/gov/proposal", queryRouter routes using "gov".
|
||
|
if len(path) < 2 || path[1] == "" {
|
||
|
return sdk.ErrUnknownRequest("No route for custom query specified").QueryResult()
|
||
|
}
|
||
|
|
||
|
querier := app.queryRouter.Route(path[1])
|
||
|
if querier == nil {
|
||
|
return sdk.ErrUnknownRequest(fmt.Sprintf("no custom querier found for route %s", path[1])).QueryResult()
|
||
|
}
|
||
|
|
||
|
// when a client did not provide a query height, manually inject the latest
|
||
|
if req.Height == 0 {
|
||
|
req.Height = app.LastBlockHeight()
|
||
|
}
|
||
|
|
||
|
if req.Height <= 1 && req.Prove {
|
||
|
return sdk.ErrInternal("cannot query with proof when height <= 1; please provide a valid height").QueryResult()
|
||
|
}
|
||
|
|
||
|
cacheMS, err := app.cms.CacheMultiStoreWithVersion(req.Height)
|
||
|
if err != nil {
|
||
|
return sdk.ErrInternal(
|
||
|
fmt.Sprintf(
|
||
|
"failed to load state at height %d; %s (latest height: %d)",
|
||
|
req.Height, err, app.LastBlockHeight(),
|
||
|
),
|
||
|
).QueryResult()
|
||
|
}
|
||
|
|
||
|
// cache wrap the commit-multistore for safety
|
||
|
ctx := sdk.NewContext(
|
||
|
cacheMS, app.checkState.ctx.BlockHeader(), true, app.logger,
|
||
|
).WithMinGasPrices(app.minGasPrices)
|
||
|
|
||
|
// Passes the rest of the path as an argument to the querier.
|
||
|
//
|
||
|
// For example, in the path "custom/gov/proposal/test", the gov querier gets
|
||
|
// []string{"proposal", "test"} as the path.
|
||
|
resBytes, queryErr := querier(ctx, path[2:], req)
|
||
|
if queryErr != nil {
|
||
|
return abci.ResponseQuery{
|
||
|
Code: uint32(queryErr.Code()),
|
||
|
Codespace: string(queryErr.Codespace()),
|
||
|
Height: req.Height,
|
||
|
Log: queryErr.ABCILog(),
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return abci.ResponseQuery{
|
||
|
Code: uint32(sdk.CodeOK),
|
||
|
Height: req.Height,
|
||
|
Value: resBytes,
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// splitPath splits a string path using the delimiter '/'.
|
||
|
//
|
||
|
// e.g. "this/is/funny" becomes []string{"this", "is", "funny"}
|
||
|
func splitPath(requestPath string) (path []string) {
|
||
|
path = strings.Split(requestPath, "/")
|
||
|
|
||
|
// first element is empty string
|
||
|
if len(path) > 0 && path[0] == "" {
|
||
|
path = path[1:]
|
||
|
}
|
||
|
|
||
|
return path
|
||
|
}
|