Documentation

Index

Constants

View Source
const Paramspace = "baseapp"

    Paramspace defines the parameter subspace to be used for the paramstore.

    Variables

    View Source
    var (
    	ParamStoreKeyBlockParams     = []byte("BlockParams")
    	ParamStoreKeyEvidenceParams  = []byte("EvidenceParams")
    	ParamStoreKeyValidatorParams = []byte("ValidatorParams")
    )

      Parameter store keys for all the consensus parameter types.

      Functions

      func DefaultStoreLoader

      func DefaultStoreLoader(ms sdk.CommitMultiStore) error

        DefaultStoreLoader will be used by default and loads the latest version

        func SetHaltHeight

        func SetHaltHeight(blockHeight uint64) func(*BaseApp)

          SetHaltHeight returns a BaseApp option function that sets the halt block height.

          func SetHaltTime

          func SetHaltTime(haltTime uint64) func(*BaseApp)

            SetHaltTime returns a BaseApp option function that sets the halt block time.

            func SetIndexEvents

            func SetIndexEvents(ie []string) func(*BaseApp)

              SetIndexEvents provides a BaseApp option function that sets the events to index.

              func SetInterBlockCache

              func SetInterBlockCache(cache sdk.MultiStorePersistentCache) func(*BaseApp)

                SetInterBlockCache provides a BaseApp option function that sets the inter-block cache.

                func SetMinGasPrices

                func SetMinGasPrices(gasPricesStr string) func(*BaseApp)

                  SetMinGasPrices returns an option that sets the minimum gas prices on the app.

                  func SetMinRetainBlocks

                  func SetMinRetainBlocks(minRetainBlocks uint64) func(*BaseApp)

                    SetMinRetainBlocks returns a BaseApp option function that sets the minimum block retention height value when determining which heights to prune during ABCI Commit.

                    func SetPruning

                    func SetPruning(opts sdk.PruningOptions) func(*BaseApp)

                      SetPruning sets a pruning option on the multistore associated with the app

                      func SetSnapshotInterval

                      func SetSnapshotInterval(interval uint64) func(*BaseApp)

                        SetSnapshotInterval sets the snapshot interval.

                        func SetSnapshotKeepRecent

                        func SetSnapshotKeepRecent(keepRecent uint32) func(*BaseApp)

                          SetSnapshotKeepRecent sets the recent snapshots to keep.

                          func SetSnapshotStore

                          func SetSnapshotStore(snapshotStore *snapshots.Store) func(*BaseApp)

                            SetSnapshotStore sets the snapshot store.

                            func SetTrace

                            func SetTrace(trace bool) func(*BaseApp)

                              SetTrace will turn on or off trace flag

                              func ValidateBlockParams

                              func ValidateBlockParams(i interface{}) error

                                ValidateBlockParams defines a stateless validation on BlockParams. This function is called whenever the parameters are updated or stored.

                                func ValidateEvidenceParams

                                func ValidateEvidenceParams(i interface{}) error

                                  ValidateEvidenceParams defines a stateless validation on EvidenceParams. This function is called whenever the parameters are updated or stored.

                                  func ValidateValidatorParams

                                  func ValidateValidatorParams(i interface{}) error

                                    ValidateValidatorParams defines a stateless validation on ValidatorParams. This function is called whenever the parameters are updated or stored.

                                    Types

                                    type BaseApp

                                    type BaseApp struct {
                                    	// contains filtered or unexported fields
                                    }

                                      BaseApp reflects the ABCI application implementation.

                                      func NewBaseApp

                                      func NewBaseApp(
                                      	name string, logger log.Logger, db dbm.DB, txDecoder sdk.TxDecoder, options ...func(*BaseApp),
                                      ) *BaseApp

                                        NewBaseApp returns a reference to an initialized BaseApp. It accepts a variadic number of option functions, which act on the BaseApp to set configuration choices.

                                        NOTE: The db is used to store the version number for now.

                                        func (*BaseApp) AddRunTxRecoveryHandler

                                        func (app *BaseApp) AddRunTxRecoveryHandler(handlers ...RecoveryHandler)

                                          AddRunTxRecoveryHandler adds custom app.runTx method panic handlers.

                                          func (*BaseApp) AppVersion

                                          func (app *BaseApp) AppVersion() string

                                            AppVersion returns the application's version string.

                                            func (*BaseApp) ApplySnapshotChunk

                                              ApplySnapshotChunk implements the ABCI interface. It delegates to app.snapshotManager if set.

                                              func (*BaseApp) BeginBlock

                                              func (app *BaseApp) BeginBlock(req abci.RequestBeginBlock) (res abci.ResponseBeginBlock)

                                                BeginBlock implements the ABCI application interface.

                                                func (*BaseApp) Check

                                                func (app *BaseApp) Check(txEncoder sdk.TxEncoder, tx sdk.Tx) (sdk.GasInfo, *sdk.Result, error)

                                                func (*BaseApp) CheckTx

                                                func (app *BaseApp) CheckTx(req abci.RequestCheckTx) abci.ResponseCheckTx

                                                  CheckTx implements the ABCI interface and executes a tx in CheckTx mode. In CheckTx mode, messages are not executed. This means messages are only validated and only the AnteHandler is executed. State is persisted to the BaseApp's internal CheckTx state if the AnteHandler passes. Otherwise, the ResponseCheckTx will contain releveant error information. Regardless of tx execution outcome, the ResponseCheckTx will contain relevant gas execution context.

                                                  func (*BaseApp) Commit

                                                  func (app *BaseApp) Commit() (res abci.ResponseCommit)

                                                    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 (*BaseApp) Deliver

                                                    func (app *BaseApp) Deliver(txEncoder sdk.TxEncoder, tx sdk.Tx) (sdk.GasInfo, *sdk.Result, error)

                                                    func (*BaseApp) DeliverTx

                                                    func (app *BaseApp) DeliverTx(req abci.RequestDeliverTx) abci.ResponseDeliverTx

                                                      DeliverTx implements the ABCI interface and executes a tx in DeliverTx mode. State only gets persisted if all messages are valid and get executed successfully. Otherwise, the ResponseDeliverTx will contain releveant error information. Regardless of tx execution outcome, the ResponseDeliverTx will contain relevant gas execution context.

                                                      func (*BaseApp) EndBlock

                                                      func (app *BaseApp) EndBlock(req abci.RequestEndBlock) (res abci.ResponseEndBlock)

                                                        EndBlock implements the ABCI interface.

                                                        func (*BaseApp) FilterPeerByAddrPort

                                                        func (app *BaseApp) FilterPeerByAddrPort(info string) abci.ResponseQuery

                                                          FilterPeerByAddrPort filters peers by address/port.

                                                          func (*BaseApp) FilterPeerByID

                                                          func (app *BaseApp) FilterPeerByID(info string) abci.ResponseQuery

                                                            FilterPeerByID filters peers by node ID.

                                                            func (*BaseApp) GRPCQueryRouter

                                                            func (app *BaseApp) GRPCQueryRouter() *GRPCQueryRouter

                                                              GRPCQueryRouter returns the GRPCQueryRouter of a BaseApp.

                                                              func (*BaseApp) GetBlockRetentionHeight

                                                              func (app *BaseApp) GetBlockRetentionHeight(commitHeight int64) int64

                                                                GetBlockRetentionHeight returns the height for which all blocks below this height are pruned from Tendermint. Given a commitment height and a non-zero local minRetainBlocks configuration, the retentionHeight is the smallest height that satisfies:

                                                                - Unbonding (safety threshold) time: The block interval in which validators can be economically punished for misbehavior. Blocks in this interval must be auditable e.g. by the light client.

                                                                - Logical store snapshot interval: The block interval at which the underlying logical store database is persisted to disk, e.g. every 10000 heights. Blocks since the last IAVL snapshot must be available for replay on application restart.

                                                                - State sync snapshots: Blocks since the oldest available snapshot must be available for state sync nodes to catch up (oldest because a node may be restoring an old snapshot while a new snapshot was taken).

                                                                - Local (minRetainBlocks) config: Archive nodes may want to retain more or all blocks, e.g. via a local config option min-retain-blocks. There may also be a need to vary retention for other nodes, e.g. sentry nodes which do not need historical blocks.

                                                                func (*BaseApp) GetConsensusParams

                                                                func (app *BaseApp) GetConsensusParams(ctx sdk.Context) *abci.ConsensusParams

                                                                  GetConsensusParams returns the current consensus parameters from the BaseApp's ParamStore. If the BaseApp has no ParamStore defined, nil is returned.

                                                                  func (*BaseApp) Info

                                                                  func (app *BaseApp) Info(req abci.RequestInfo) abci.ResponseInfo

                                                                    Info implements the ABCI interface.

                                                                    func (*BaseApp) InitChain

                                                                    func (app *BaseApp) InitChain(req abci.RequestInitChain) (res abci.ResponseInitChain)

                                                                      InitChain implements the ABCI interface. It runs the initialization logic directly on the CommitMultiStore.

                                                                      func (*BaseApp) IsSealed

                                                                      func (app *BaseApp) IsSealed() bool

                                                                        IsSealed returns true if the BaseApp is sealed and false otherwise.

                                                                        func (*BaseApp) LastBlockHeight

                                                                        func (app *BaseApp) LastBlockHeight() int64

                                                                          LastBlockHeight returns the last committed block height.

                                                                          func (*BaseApp) LastCommitID

                                                                          func (app *BaseApp) LastCommitID() sdk.CommitID

                                                                            LastCommitID returns the last CommitID of the multistore.

                                                                            func (*BaseApp) ListSnapshots

                                                                              ListSnapshots implements the ABCI interface. It delegates to app.snapshotManager if set.

                                                                              func (*BaseApp) LoadLatestVersion

                                                                              func (app *BaseApp) LoadLatestVersion() error

                                                                                LoadLatestVersion loads the latest application version. It will panic if called more than once on a running BaseApp.

                                                                                func (*BaseApp) LoadSnapshotChunk

                                                                                  LoadSnapshotChunk implements the ABCI interface. It delegates to app.snapshotManager if set.

                                                                                  func (*BaseApp) LoadVersion

                                                                                  func (app *BaseApp) LoadVersion(version int64) error

                                                                                    LoadVersion loads the BaseApp application version. It will panic if called more than once on a running baseapp.

                                                                                    func (*BaseApp) Logger

                                                                                    func (app *BaseApp) Logger() log.Logger

                                                                                      Logger returns the logger of the BaseApp.

                                                                                      func (*BaseApp) MountKVStores

                                                                                      func (app *BaseApp) MountKVStores(keys map[string]*sdk.KVStoreKey)

                                                                                        MountKVStores mounts all IAVL or DB stores to the provided keys in the BaseApp multistore.

                                                                                        func (*BaseApp) MountMemoryStores

                                                                                        func (app *BaseApp) MountMemoryStores(keys map[string]*sdk.MemoryStoreKey)

                                                                                          MountMemoryStores mounts all in-memory KVStores with the BaseApp's internal commit multi-store.

                                                                                          func (*BaseApp) MountStore

                                                                                          func (app *BaseApp) MountStore(key sdk.StoreKey, typ sdk.StoreType)

                                                                                            MountStore mounts a store to the provided key in the BaseApp multistore, using the default DB.

                                                                                            func (*BaseApp) MountStores

                                                                                            func (app *BaseApp) MountStores(keys ...sdk.StoreKey)

                                                                                              MountStores mounts all IAVL or DB stores to the provided keys in the BaseApp multistore.

                                                                                              func (*BaseApp) MountTransientStores

                                                                                              func (app *BaseApp) MountTransientStores(keys map[string]*sdk.TransientStoreKey)

                                                                                                MountTransientStores mounts all transient stores to the provided keys in the BaseApp multistore.

                                                                                                func (*BaseApp) MsgServiceRouter

                                                                                                func (app *BaseApp) MsgServiceRouter() *MsgServiceRouter

                                                                                                  MsgServiceRouter returns the MsgServiceRouter of a BaseApp.

                                                                                                  func (*BaseApp) Name

                                                                                                  func (app *BaseApp) Name() string

                                                                                                    Name returns the name of the BaseApp.

                                                                                                    func (*BaseApp) NewContext

                                                                                                    func (app *BaseApp) NewContext(isCheckTx bool, header tmproto.Header) sdk.Context

                                                                                                      Context with current {check, deliver}State of the app used by tests.

                                                                                                      func (*BaseApp) NewUncachedContext

                                                                                                      func (app *BaseApp) NewUncachedContext(isCheckTx bool, header tmproto.Header) sdk.Context

                                                                                                      func (*BaseApp) OfferSnapshot

                                                                                                        OfferSnapshot implements the ABCI interface. It delegates to app.snapshotManager if set.

                                                                                                        func (*BaseApp) Query

                                                                                                        func (app *BaseApp) Query(req abci.RequestQuery) (res abci.ResponseQuery)

                                                                                                          Query implements the ABCI interface. It delegates to CommitMultiStore if it implements Queryable.

                                                                                                          func (*BaseApp) QueryRouter

                                                                                                          func (app *BaseApp) QueryRouter() sdk.QueryRouter

                                                                                                            QueryRouter returns the QueryRouter of a BaseApp.

                                                                                                            func (*BaseApp) RegisterGRPCServer

                                                                                                            func (app *BaseApp) RegisterGRPCServer(clientCtx client.Context, server gogogrpc.Server)

                                                                                                              RegisterGRPCServer registers gRPC services directly with the gRPC server.

                                                                                                              func (*BaseApp) Router

                                                                                                              func (app *BaseApp) Router() sdk.Router

                                                                                                                Router returns the router of the BaseApp.

                                                                                                                func (*BaseApp) Seal

                                                                                                                func (app *BaseApp) Seal()

                                                                                                                  Seal seals a BaseApp. It prohibits any further modifications to a BaseApp.

                                                                                                                  func (*BaseApp) SetAddrPeerFilter

                                                                                                                  func (app *BaseApp) SetAddrPeerFilter(pf sdk.PeerFilter)

                                                                                                                  func (*BaseApp) SetAnteHandler

                                                                                                                  func (app *BaseApp) SetAnteHandler(ah sdk.AnteHandler)

                                                                                                                  func (*BaseApp) SetAppVersion

                                                                                                                  func (app *BaseApp) SetAppVersion(v string)

                                                                                                                    SetAppVersion sets the application's version string.

                                                                                                                    func (*BaseApp) SetBeginBlocker

                                                                                                                    func (app *BaseApp) SetBeginBlocker(beginBlocker sdk.BeginBlocker)

                                                                                                                    func (*BaseApp) SetCMS

                                                                                                                    func (app *BaseApp) SetCMS(cms store.CommitMultiStore)

                                                                                                                    func (*BaseApp) SetCommitMultiStoreTracer

                                                                                                                    func (app *BaseApp) SetCommitMultiStoreTracer(w io.Writer)

                                                                                                                      SetCommitMultiStoreTracer sets the store tracer on the BaseApp's underlying CommitMultiStore.

                                                                                                                      func (*BaseApp) SetDB

                                                                                                                      func (app *BaseApp) SetDB(db dbm.DB)

                                                                                                                      func (*BaseApp) SetEndBlocker

                                                                                                                      func (app *BaseApp) SetEndBlocker(endBlocker sdk.EndBlocker)

                                                                                                                      func (*BaseApp) SetFauxMerkleMode

                                                                                                                      func (app *BaseApp) SetFauxMerkleMode()

                                                                                                                      func (*BaseApp) SetIDPeerFilter

                                                                                                                      func (app *BaseApp) SetIDPeerFilter(pf sdk.PeerFilter)

                                                                                                                      func (*BaseApp) SetInitChainer

                                                                                                                      func (app *BaseApp) SetInitChainer(initChainer sdk.InitChainer)

                                                                                                                      func (*BaseApp) SetInterfaceRegistry

                                                                                                                      func (app *BaseApp) SetInterfaceRegistry(registry types.InterfaceRegistry)

                                                                                                                        SetInterfaceRegistry sets the InterfaceRegistry.

                                                                                                                        func (*BaseApp) SetName

                                                                                                                        func (app *BaseApp) SetName(name string)

                                                                                                                        func (*BaseApp) SetOption

                                                                                                                        func (app *BaseApp) SetOption(req abci.RequestSetOption) (res abci.ResponseSetOption)

                                                                                                                          SetOption implements the ABCI interface.

                                                                                                                          func (*BaseApp) SetParamStore

                                                                                                                          func (app *BaseApp) SetParamStore(ps ParamStore)

                                                                                                                            SetParamStore sets a parameter store on the BaseApp.

                                                                                                                            func (*BaseApp) SetRouter

                                                                                                                            func (app *BaseApp) SetRouter(router sdk.Router)

                                                                                                                              SetRouter allows us to customize the router.

                                                                                                                              func (*BaseApp) SetSnapshotInterval

                                                                                                                              func (app *BaseApp) SetSnapshotInterval(snapshotInterval uint64)

                                                                                                                                SetSnapshotInterval sets the snapshot interval.

                                                                                                                                func (*BaseApp) SetSnapshotKeepRecent

                                                                                                                                func (app *BaseApp) SetSnapshotKeepRecent(snapshotKeepRecent uint32)

                                                                                                                                  SetSnapshotKeepRecent sets the number of recent snapshots to keep.

                                                                                                                                  func (*BaseApp) SetSnapshotStore

                                                                                                                                  func (app *BaseApp) SetSnapshotStore(snapshotStore *snapshots.Store)

                                                                                                                                    SetSnapshotStore sets the snapshot store.

                                                                                                                                    func (*BaseApp) SetStoreLoader

                                                                                                                                    func (app *BaseApp) SetStoreLoader(loader StoreLoader)

                                                                                                                                      SetStoreLoader allows us to customize the rootMultiStore initialization.

                                                                                                                                      func (*BaseApp) Simulate

                                                                                                                                      func (app *BaseApp) Simulate(txBytes []byte) (sdk.GasInfo, *sdk.Result, error)

                                                                                                                                      func (*BaseApp) StoreConsensusParams

                                                                                                                                      func (app *BaseApp) StoreConsensusParams(ctx sdk.Context, cp *abci.ConsensusParams)

                                                                                                                                        StoreConsensusParams sets the consensus parameters to the baseapp's param store.

                                                                                                                                        type GRPCQueryHandler

                                                                                                                                        type GRPCQueryHandler = func(ctx sdk.Context, req abci.RequestQuery) (abci.ResponseQuery, error)

                                                                                                                                          GRPCQueryHandler defines a function type which handles ABCI Query requests using gRPC

                                                                                                                                          type GRPCQueryRouter

                                                                                                                                          type GRPCQueryRouter struct {
                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                          }

                                                                                                                                            GRPCQueryRouter routes ABCI Query requests to GRPC handlers

                                                                                                                                            func NewGRPCQueryRouter

                                                                                                                                            func NewGRPCQueryRouter() *GRPCQueryRouter

                                                                                                                                              NewGRPCQueryRouter creates a new GRPCQueryRouter

                                                                                                                                              func (*GRPCQueryRouter) RegisterService

                                                                                                                                              func (qrt *GRPCQueryRouter) RegisterService(sd *grpc.ServiceDesc, handler interface{})

                                                                                                                                                RegisterService implements the gRPC Server.RegisterService method. sd is a gRPC service description, handler is an object which implements that gRPC service/

                                                                                                                                                This functions PANICS: - if a protobuf service is registered twice.

                                                                                                                                                func (*GRPCQueryRouter) Route

                                                                                                                                                func (qrt *GRPCQueryRouter) Route(path string) GRPCQueryHandler

                                                                                                                                                  Route returns the GRPCQueryHandler for a given query route path or nil if not found

                                                                                                                                                  func (*GRPCQueryRouter) SetInterfaceRegistry

                                                                                                                                                  func (qrt *GRPCQueryRouter) SetInterfaceRegistry(interfaceRegistry codectypes.InterfaceRegistry)

                                                                                                                                                    SetInterfaceRegistry sets the interface registry for the router. This will also register the interface reflection gRPC service.

                                                                                                                                                    type MsgServiceHandler

                                                                                                                                                    type MsgServiceHandler = func(ctx sdk.Context, req sdk.MsgRequest) (*sdk.Result, error)

                                                                                                                                                      MsgServiceHandler defines a function type which handles Msg service message.

                                                                                                                                                      type MsgServiceRouter

                                                                                                                                                      type MsgServiceRouter struct {
                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                      }

                                                                                                                                                        MsgServiceRouter routes fully-qualified Msg service methods to their handler.

                                                                                                                                                        func NewMsgServiceRouter

                                                                                                                                                        func NewMsgServiceRouter() *MsgServiceRouter

                                                                                                                                                          NewMsgServiceRouter creates a new MsgServiceRouter.

                                                                                                                                                          func (*MsgServiceRouter) Handler

                                                                                                                                                          func (msr *MsgServiceRouter) Handler(methodName string) MsgServiceHandler

                                                                                                                                                            Handler returns the MsgServiceHandler for a given query route path or nil if not found.

                                                                                                                                                            func (*MsgServiceRouter) RegisterService

                                                                                                                                                            func (msr *MsgServiceRouter) RegisterService(sd *grpc.ServiceDesc, handler interface{})

                                                                                                                                                              RegisterService implements the gRPC Server.RegisterService method. sd is a gRPC service description, handler is an object which implements that gRPC service.

                                                                                                                                                              This function PANICs: - if it is called before the service `Msg`s have been registered using

                                                                                                                                                              RegisterInterfaces,
                                                                                                                                                              

                                                                                                                                                              - or if a service is being registered twice.

                                                                                                                                                              func (*MsgServiceRouter) SetInterfaceRegistry

                                                                                                                                                              func (msr *MsgServiceRouter) SetInterfaceRegistry(interfaceRegistry codectypes.InterfaceRegistry)

                                                                                                                                                                SetInterfaceRegistry sets the interface registry for the router.

                                                                                                                                                                type ParamStore

                                                                                                                                                                type ParamStore interface {
                                                                                                                                                                	Get(ctx sdk.Context, key []byte, ptr interface{})
                                                                                                                                                                	Has(ctx sdk.Context, key []byte) bool
                                                                                                                                                                	Set(ctx sdk.Context, key []byte, param interface{})
                                                                                                                                                                }

                                                                                                                                                                  ParamStore defines the interface the parameter store used by the BaseApp must fulfill.

                                                                                                                                                                  type QueryRouter

                                                                                                                                                                  type QueryRouter struct {
                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                  }

                                                                                                                                                                  func NewQueryRouter

                                                                                                                                                                  func NewQueryRouter() *QueryRouter

                                                                                                                                                                    NewQueryRouter returns a reference to a new QueryRouter.

                                                                                                                                                                    func (*QueryRouter) AddRoute

                                                                                                                                                                    func (qrt *QueryRouter) AddRoute(path string, q sdk.Querier) sdk.QueryRouter

                                                                                                                                                                      AddRoute adds a query path to the router with a given Querier. It will panic if a duplicate route is given. The route must be alphanumeric.

                                                                                                                                                                      func (*QueryRouter) Route

                                                                                                                                                                      func (qrt *QueryRouter) Route(path string) sdk.Querier

                                                                                                                                                                        Route returns the Querier for a given query route path.

                                                                                                                                                                        type QueryServiceTestHelper

                                                                                                                                                                        type QueryServiceTestHelper struct {
                                                                                                                                                                        	*GRPCQueryRouter
                                                                                                                                                                        	Ctx sdk.Context
                                                                                                                                                                        }

                                                                                                                                                                          QueryServiceTestHelper provides a helper for making grpc query service rpc calls in unit tests. It implements both the grpc Server and ClientConn interfaces needed to register a query service server and create a query service client.

                                                                                                                                                                          func NewQueryServerTestHelper

                                                                                                                                                                          func NewQueryServerTestHelper(ctx sdk.Context, interfaceRegistry types.InterfaceRegistry) *QueryServiceTestHelper

                                                                                                                                                                            NewQueryServerTestHelper creates a new QueryServiceTestHelper that wraps the provided sdk.Context

                                                                                                                                                                            func (*QueryServiceTestHelper) Invoke

                                                                                                                                                                            func (q *QueryServiceTestHelper) Invoke(_ gocontext.Context, method string, args, reply interface{}, _ ...grpc.CallOption) error

                                                                                                                                                                              Invoke implements the grpc ClientConn.Invoke method

                                                                                                                                                                              func (*QueryServiceTestHelper) NewStream

                                                                                                                                                                                NewStream implements the grpc ClientConn.NewStream method

                                                                                                                                                                                type RecoveryHandler

                                                                                                                                                                                type RecoveryHandler func(recoveryObj interface{}) error

                                                                                                                                                                                  RecoveryHandler handles recovery() object. Return a non-nil error if recoveryObj was processed. Return nil if recoveryObj was not processed.

                                                                                                                                                                                  type Router

                                                                                                                                                                                  type Router struct {
                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                  }

                                                                                                                                                                                  func NewRouter

                                                                                                                                                                                  func NewRouter() *Router

                                                                                                                                                                                    NewRouter returns a reference to a new router.

                                                                                                                                                                                    func (*Router) AddRoute

                                                                                                                                                                                    func (rtr *Router) AddRoute(route sdk.Route) sdk.Router

                                                                                                                                                                                      AddRoute adds a route path to the router with a given handler. The route must be alphanumeric.

                                                                                                                                                                                      func (*Router) Route

                                                                                                                                                                                      func (rtr *Router) Route(_ sdk.Context, path string) sdk.Handler

                                                                                                                                                                                        Route returns a handler for a given route path.

                                                                                                                                                                                        TODO: Handle expressive matches.

                                                                                                                                                                                        type StoreLoader

                                                                                                                                                                                        type StoreLoader func(ms sdk.CommitMultiStore) error

                                                                                                                                                                                          StoreLoader defines a customizable function to control how we load the CommitMultiStore from disk. This is useful for state migration, when loading a datastore written with an older version of the software. In particular, if a module changed the substore key name (or removed a substore) between two versions of the software.