diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go index 121b4cfbf..4e0f3e003 100644 --- a/baseapp/baseapp.go +++ b/baseapp/baseapp.go @@ -35,26 +35,29 @@ type BaseApp struct { // Unmarshal []byte into sdk.Tx txDecoder sdk.TxDecoder - // Ante handler for fee and auth. + // Ante handler for fee and auth defaultAnteHandler sdk.AnteHandler - // Handle any kind of message. + // Handle any kind of message router Router //-------------------- // Volatile - // CheckTx state, a cache-wrap of `.cms`. + // CheckTx state, a cache-wrap of `.cms` msCheck sdk.CacheMultiStore - // DeliverTx state, a cache-wrap of `.cms`. + // DeliverTx state, a cache-wrap of `.cms` msDeliver sdk.CacheMultiStore // Current block header header *abci.Header - // Cached validator changes from DeliverTx. + // Cached validator changes from DeliverTx valUpdates []abci.Validator + + // function to + initStater sdk.InitStater } var _ abci.Application = &BaseApp{} diff --git a/types/coin.go b/types/coin.go index 620c2f289..ad541b99b 100644 --- a/types/coin.go +++ b/types/coin.go @@ -184,6 +184,7 @@ func (coins Coins) IsNotNegative() bool { return true } +// Returns the amount of a denom from coins func (coins Coins) AmountOf(denom string) int64 { switch len(coins) { case 0: @@ -192,9 +193,8 @@ func (coins Coins) AmountOf(denom string) int64 { coin := coins[0] if coin.Denom == denom { return coin.Amount - } else { - return 0 } + return 0 default: midIdx := len(coins) / 2 // 2:1, 3:1, 4:2 coin := coins[midIdx] diff --git a/types/coin_test.go b/types/coin_test.go index 03890aa3f..b58578a25 100644 --- a/types/coin_test.go +++ b/types/coin_test.go @@ -192,7 +192,7 @@ func TestAmountOf(t *testing.T) { cases := []struct { coins Coins amountOf int64 - amountOf_ int64 + amountOfSpace int64 amountOfGAS int64 amountOfMINERAL int64 amountOfTREE int64 @@ -210,7 +210,7 @@ func TestAmountOf(t *testing.T) { for _, tc := range cases { assert.Equal(t, tc.amountOf, tc.coins.AmountOf("")) - assert.Equal(t, tc.amountOf_, tc.coins.AmountOf(" ")) + assert.Equal(t, tc.amountOfSpace, tc.coins.AmountOf(" ")) assert.Equal(t, tc.amountOfGAS, tc.coins.AmountOf("GAS")) assert.Equal(t, tc.amountOfMINERAL, tc.coins.AmountOf("MINERAL")) assert.Equal(t, tc.amountOfTREE, tc.coins.AmountOf("TREE")) diff --git a/types/context.go b/types/context.go index 4dbf64c3e..3c90b016a 100644 --- a/types/context.go +++ b/types/context.go @@ -30,6 +30,7 @@ type Context struct { // it's probably not what you want to do. } +// create a new context func NewContext(ms MultiStore, header abci.Header, isCheckTx bool, txBytes []byte) Context { c := Context{ Context: context.Background(), @@ -45,6 +46,7 @@ func NewContext(ms MultiStore, header abci.Header, isCheckTx bool, txBytes []byt return c } +// is context nil func (c Context) IsZero() bool { return c.Context == nil } @@ -52,6 +54,7 @@ func (c Context) IsZero() bool { //---------------------------------------- // Getting a value +// context value for the provided key func (c Context) Value(key interface{}) interface{} { value := c.Context.Value(key) if cloner, ok := value.(cloner); ok { @@ -71,34 +74,28 @@ func (c Context) KVStore(key StoreKey) KVStore { //---------------------------------------- // With* (setting a value) +// nolint func (c Context) WithValue(key interface{}, value interface{}) Context { return c.withValue(key, value) } - func (c Context) WithCloner(key interface{}, value cloner) Context { return c.withValue(key, value) } - func (c Context) WithCacheWrapper(key interface{}, value CacheWrapper) Context { return c.withValue(key, value) } - func (c Context) WithProtoMsg(key interface{}, value proto.Message) Context { return c.withValue(key, value) } - func (c Context) WithString(key interface{}, value string) Context { return c.withValue(key, value) } - func (c Context) WithInt32(key interface{}, value int32) Context { return c.withValue(key, value) } - func (c Context) WithUint32(key interface{}, value uint32) Context { return c.withValue(key, value) } - func (c Context) WithUint64(key interface{}, value uint64) Context { return c.withValue(key, value) } @@ -138,47 +135,38 @@ func (c Context) multiStore() MultiStore { return c.Value(contextKeyMultiStore).(MultiStore) } +// nolint func (c Context) BlockHeader() abci.Header { return c.Value(contextKeyBlockHeader).(abci.Header) } - func (c Context) BlockHeight() int64 { return c.Value(contextKeyBlockHeight).(int64) } - func (c Context) ChainID() string { return c.Value(contextKeyChainID).(string) } - func (c Context) IsCheckTx() bool { return c.Value(contextKeyIsCheckTx).(bool) } - func (c Context) TxBytes() []byte { return c.Value(contextKeyTxBytes).([]byte) } - func (c Context) WithMultiStore(ms MultiStore) Context { return c.withValue(contextKeyMultiStore, ms) } - func (c Context) WithBlockHeader(header abci.Header) Context { var _ proto.Message = &header // for cloning. return c.withValue(contextKeyBlockHeader, header) } - func (c Context) WithBlockHeight(height int64) Context { return c.withValue(contextKeyBlockHeight, height) } - func (c Context) WithChainID(chainID string) Context { return c.withValue(contextKeyChainID, chainID) } - func (c Context) WithIsCheckTx(isCheckTx bool) Context { return c.withValue(contextKeyIsCheckTx, isCheckTx) } - func (c Context) WithTxBytes(txBytes []byte) Context { return c.withValue(contextKeyTxBytes, txBytes) } @@ -199,6 +187,7 @@ type cloner interface { Clone() interface{} // deep copy } +// XXX add description type Op struct { // type is always 'with' gen int @@ -221,7 +210,7 @@ func newThePast() *thePast { func (pst *thePast) bump(op Op) { pst.mtx.Lock() - pst.ver += 1 + pst.ver++ pst.ops = append(pst.ops, op) pst.mtx.Unlock() } @@ -240,7 +229,6 @@ func (pst *thePast) getOp(ver int64) (Op, bool) { l := int64(len(pst.ops)) if l < ver || ver <= 0 { return Op{}, false - } else { - return pst.ops[ver-1], true } + return pst.ops[ver-1], true } diff --git a/types/errors.go b/types/errors.go index a87814931..2290ff833 100644 --- a/types/errors.go +++ b/types/errors.go @@ -7,19 +7,20 @@ import ( "github.com/tendermint/go-crypto" ) +// ABCI Response Code type CodeType uint32 +// is everything okay? func (code CodeType) IsOK() bool { if code == CodeOK { return true - } else { - return false } + return false } +// ABCI Response Codes +// Base SDK reserves 0 ~ 99. const ( - // ABCI Response Codes - // Base SDK reserves 0 ~ 99. CodeOK CodeType = 0 CodeInternal CodeType = 1 CodeTxParse CodeType = 2 @@ -59,34 +60,28 @@ func CodeToDefaultMsg(code CodeType) string { // All errors are created via constructors so as to enable us to hijack them // and inject stack traces if we really want to. +// nolint func ErrInternal(msg string) Error { return newError(CodeInternal, msg) } - func ErrTxParse(msg string) Error { return newError(CodeTxParse, msg) } - func ErrBadNonce(msg string) Error { return newError(CodeBadNonce, msg) } - func ErrUnauthorized(msg string) Error { return newError(CodeUnauthorized, msg) } - func ErrInsufficientFunds(msg string) Error { return newError(CodeInsufficientFunds, msg) } - func ErrUnknownRequest(msg string) Error { return newError(CodeUnknownRequest, msg) } - func ErrUnrecognizedAddress(addr crypto.Address) Error { return newError(CodeUnrecognizedAddress, addr.String()) } - func ErrInvalidSequence(msg string) Error { return newError(CodeInvalidSequence, msg) } @@ -94,6 +89,7 @@ func ErrInvalidSequence(msg string) Error { //---------------------------------------- // Error & sdkError +// sdk Error type type Error interface { Error() string ABCICode() CodeType diff --git a/types/handler.go b/types/handler.go index 6b45f5473..129f42647 100644 --- a/types/handler.go +++ b/types/handler.go @@ -1,5 +1,6 @@ package types +// core function variable which application runs for transactions type Handler func(ctx Context, msg Msg) Result // If newCtx.IsZero(), ctx is used instead. diff --git a/types/signature.go b/types/signature.go index e22d0c78c..7fecc5fe9 100644 --- a/types/signature.go +++ b/types/signature.go @@ -2,6 +2,7 @@ package types import crypto "github.com/tendermint/go-crypto" +// Standard Signature type StdSignature struct { crypto.PubKey // optional crypto.Signature diff --git a/types/store.go b/types/store.go index 6802a4bf1..872c38090 100644 --- a/types/store.go +++ b/types/store.go @@ -9,12 +9,12 @@ import ( // NOTE: These are implemented in cosmos-sdk/store. -type Store interface { +type Store interface { //nolint GetStoreType() StoreType CacheWrapper } -// Something that can persist to disk. +// something that can persist to disk type Committer interface { Commit() CommitID LastCommitID() CommitID @@ -37,7 +37,7 @@ type Queryable interface { //---------------------------------------- // MultiStore -type MultiStore interface { +type MultiStore interface { //nolint Store // Cache wrap MultiStore. @@ -139,10 +139,6 @@ type CacheKVStore interface { cache-wraps make no sense. It can return KVStore, HeapStore, SpaceStore, etc. */ -type CacheWrapper interface { - CacheWrap() CacheWrap -} - type CacheWrap interface { // Write syncs with the underlying store. @@ -152,6 +148,10 @@ type CacheWrap interface { CacheWrap() CacheWrap } +type CacheWrapper interface { //nolint + CacheWrap() CacheWrap +} + //---------------------------------------- // CommitID @@ -161,7 +161,7 @@ type CommitID struct { Hash []byte } -func (cid CommitID) IsZero() bool { +func (cid CommitID) IsZero() bool { //nolint return cid.Version == 0 && len(cid.Hash) == 0 } @@ -172,9 +172,11 @@ func (cid CommitID) String() string { //---------------------------------------- // Store types +// kind of store type StoreType int const ( + //nolint StoreTypeMulti StoreType = iota StoreTypeDB StoreTypeIAVL diff --git a/types/tx_msg.go b/types/tx_msg.go index 8e7a8e428..ebed8a25a 100644 --- a/types/tx_msg.go +++ b/types/tx_msg.go @@ -4,6 +4,7 @@ import ( crypto "github.com/tendermint/go-crypto" ) +// Transactions messages must fulfill the Msg type Msg interface { // Return the message type. @@ -26,6 +27,7 @@ type Msg interface { GetSigners() []crypto.Address } +// Transactions objects must fulfill the Tx type Tx interface { // Gets the Msg. @@ -47,13 +49,18 @@ type Tx interface { var _ Tx = (*StdTx)(nil) +// standard transaction form type StdTx struct { Msg Signatures []StdSignature } +//nolint func (tx StdTx) GetMsg() Msg { return tx.Msg } func (tx StdTx) GetFeePayer() crypto.Address { return tx.Signatures[0].PubKey.Address() } func (tx StdTx) GetSignatures() []StdSignature { return tx.Signatures } +//------------------------------------- + +// Application function variable used to unmarshal transaction bytes type TxDecoder func(txBytes []byte) (Tx, Error)