backport: tendermint v0.36

abci/example/counter/counter.go

@@ -35,7 +35,6 @@ func (app *Application) CheckTx(_ context.Context, req *types.RequestCheckTx) (*
 		if len(req.Tx) > 8 {
 			return &types.ResponseCheckTx{
 				Code: code.CodeTypeEncodingError,
-				Log:  fmt.Sprintf("Max tx size is 8 bytes, got %d", len(req.Tx)),
 			}, nil
 		}
 		tx8 := make([]byte, 8)
@@ -44,7 +43,6 @@ func (app *Application) CheckTx(_ context.Context, req *types.RequestCheckTx) (*
 		if txValue < uint64(app.txCount) {
 			return &types.ResponseCheckTx{
 				Code: code.CodeTypeBadNonce,
-				Log:  fmt.Sprintf("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue),
 			}, nil
 		}
 	}
@@ -56,11 +54,9 @@ func (app *Application) Commit(_ context.Context) (*types.ResponseCommit, error)
 	if app.txCount == 0 {
 		return &types.ResponseCommit{}, nil
 	}
-	hash := make([]byte, 24)
-	endHash := make([]byte, 8)
-	binary.BigEndian.PutUint64(endHash, uint64(app.txCount))
-	hash = append(hash, endHash...)
-	return &types.ResponseCommit{Data: hash}, nil
+	hash := make([]byte, 32)
+	binary.BigEndian.PutUint64(hash[24:], uint64(app.txCount))
+	return &types.ResponseCommit{}, nil
 }
 
 func (app *Application) Query(_ context.Context, reqQuery *types.RequestQuery) (*types.ResponseQuery, error) {

abci/example/kvstore/kvstore.go

@@ -206,6 +206,7 @@ func (app *Application) FinalizeBlock(_ context.Context, req *types.RequestFinal
 	return &types.ResponseFinalizeBlock{
 		TxResults:          respTxs,
 		ValidatorSetUpdate: proto.Clone(&app.valSetUpdate).(*types.ValidatorSetUpdate),
+		AppHash:            appHash,
 	}, nil
 }
 

abci/tests/test_cli/ex1.abci

@@ -15,4 +15,4 @@ process_proposal "preparedef"
 prepare_proposal
 process_proposal
 finalize_block
-commit
+commit

abci/tests/test_cli/ex1.abci.out

@@ -78,7 +78,7 @@
 
 > finalize_block
 -> code: OK
--> data.hex: 0x0600000000000000
+-> data.hex: 0x0600000000000000000000000000000000000000000000000000000000000000
 
 > commit
 -> code: OK

abci/tests/test_cli/ex2.abci.out

@@ -7,9 +7,9 @@
 > finalize_block 0x00
 -> code: OK
 -> code: OK
--> data.hex: 0x0200000000000000
+-> data.hex: 0x0200000000000000000000000000000000000000000000000000000000000000
 
-> commit 
+> commit
 -> code: OK
 
 > check_tx 0x00
@@ -18,20 +18,20 @@
 > finalize_block 0x01
 -> code: OK
 -> code: OK
--> data.hex: 0x0400000000000000
+-> data.hex: 0x0400000000000000000000000000000000000000000000000000000000000000
 
-> commit 
+> commit
 -> code: OK
 
 > finalize_block 0x04
 -> code: OK
 -> code: OK
--> data.hex: 0x0600000000000000
+-> data.hex: 0x0600000000000000000000000000000000000000000000000000000000000000
 
-> commit 
+> commit
 -> code: OK
 
-> info 
+> info
 -> code: OK
 -> data: {"size":3}
 -> data.hex: 0x7B2273697A65223A337D

abci/types/types.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 
 	"github.com/gogo/protobuf/jsonpb"
+
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/internal/jsontypes"
@@ -148,7 +149,10 @@ type validatorUpdateJSON struct {
 }
 
 func (v *ValidatorUpdate) MarshalJSON() ([]byte, error) {
-	key, err := encoding.PubKeyFromProto(v.PubKey)
+	if v.PubKey == nil {
+		return nil, nil
+	}
+	key, err := encoding.PubKeyFromProto(*v.PubKey)
 	if err != nil {
 		return nil, err
 	}
@@ -175,11 +179,56 @@ func (v *ValidatorUpdate) UnmarshalJSON(data []byte) error {
 	if err != nil {
 		return err
 	}
-	v.PubKey = pkey
+	v.PubKey = &pkey
 	v.Power = vu.Power
 	return nil
 }
 
+type validatorSetUpdateJSON struct {
+	ValidatorUpdates []ValidatorUpdate `json:"validator_updates"`
+	ThresholdPubKey  json.RawMessage   `json:"threshold_public_key"`
+	QuorumHash       []byte            `json:"quorum_hash,omitempty"`
+}
+
+func (m *ValidatorSetUpdate) MarshalJSON() ([]byte, error) {
+	ret := validatorSetUpdateJSON{
+		ValidatorUpdates: m.ValidatorUpdates,
+		QuorumHash:       m.QuorumHash,
+	}
+	if m.ThresholdPublicKey.Sum != nil {
+		key, err := encoding.PubKeyFromProto(m.ThresholdPublicKey)
+		if err != nil {
+			return nil, err
+		}
+		ret.ThresholdPubKey, err = jsontypes.Marshal(key)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return json.Marshal(ret)
+}
+
+func (m *ValidatorSetUpdate) UnmarshalJSON(data []byte) error {
+	var vsu validatorSetUpdateJSON
+	err := json.Unmarshal(data, &vsu)
+	if err != nil {
+		return err
+	}
+	var key crypto.PubKey
+	if err := jsontypes.Unmarshal(vsu.ThresholdPubKey, &key); err != nil {
+		return err
+	}
+	if key != nil {
+		m.ThresholdPublicKey, err = encoding.PubKeyToProto(key)
+		if err != nil {
+			return err
+		}
+	}
+	m.ValidatorUpdates = vsu.ValidatorUpdates
+	m.QuorumHash = vsu.QuorumHash
+	return nil
+}
+
 // Some compile time assertions to ensure we don't
 // have accidental runtime surprises later on.