tendermint add unit test

plugin/consensus/tendermint/chain33.test.toml

@@ -91,9 +91,9 @@ timeoutPrecommit=1000
 timeoutPrecommitDelta=500
 timeoutCommit=500
 skipTimeoutCommit=false
-createEmptyBlocks=false
-createEmptyBlocksInterval=0
-validatorNodes=["127.0.0.1:46656"]
+createEmptyBlocks=true
+createEmptyBlocksInterval=1
+validatorNodes=["127.0.0.1:46656", "127.0.0.2:46656"]
 
 [store]
 name="kvdb"

plugin/consensus/tendermint/consensus_state.go

@@ -87,7 +87,7 @@ type ConsensusState struct {
 	broadcastChannel chan<- MsgInfo
 	ourID            ID
 	status           uint32 // 0-stop, 1-start
-	Quit             chan struct{}
+	quit             chan struct{}
 
 	txsAvailable      chan int64
 	begCons           time.Time
@@ -103,7 +103,7 @@ func NewConsensusState(client *Client, state State, blockExec *BlockExecutor) *C
 		internalMsgQueue: make(chan MsgInfo, msgQueueSize),
 		timeoutTicker:    NewTimeoutTicker(),
 
-		Quit:         make(chan struct{}),
+		quit:         make(chan struct{}),
 		txsAvailable: make(chan int64, 1),
 		begCons:      time.Time{},
 	}
@@ -205,7 +205,7 @@ func (cs *ConsensusState) Start() {
 func (cs *ConsensusState) Stop() {
 	atomic.CompareAndSwapUint32(&cs.status, 1, 0)
 	cs.timeoutTicker.Stop()
-	cs.Quit <- struct{}{}
+	cs.quit <- struct{}{}
 }
 
 //------------------------------------------------------------
@@ -383,7 +383,7 @@ func (cs *ConsensusState) receiveRoutine(maxSteps int) {
 			// if the timeout is relevant to the rs
 			// go to the next step
 			cs.handleTimeout(ti, rs)
-		case <-cs.Quit:
+		case <-cs.quit:
 			// NOTE: the internalMsgQueue may have signed messages from our
 			// priv_val that haven't hit the WAL, but its ok because
 			// priv_val tracks LastSig
@@ -667,7 +667,13 @@ func (cs *ConsensusState) defaultDecideProposal(height int64, round int) {
 
 	// Decide on block
 	if cs.ValidBlock != nil {
-		// If there is valid block, choose that.
+		// If there is valid block, PreExec that.
+		pblockNew := cs.client.PreExecBlock(cs.ValidBlock.Data, false)
+		if pblockNew == nil {
+			tendermintlog.Error("defaultDecideProposal PreExecBlock fail")
+			return
+		}
+		cs.ValidBlock.Data = pblockNew
 		block = cs.ValidBlock
 	} else {
 		// Create a new proposal block from state/txs from the mempool.
@@ -737,6 +743,10 @@ func (cs *ConsensusState) createProposalBlock() (block *ttypes.TendermintBlock)
 	proposerAddr := cs.privValidator.GetAddress()
 	block = cs.state.MakeBlock(cs.Height, int64(cs.Round), pblock, commit, proposerAddr)
 	baseTx := cs.createBaseTx(block.TendermintBlock)
+	if baseTx == nil {
+		tendermintlog.Error("createProposalBlock createBaseTx fail")
+		return nil
+	}
 	block.Data.Txs[0] = baseTx
 	block.Data.TxHash = merkle.CalcMerkleRoot(block.Data.Txs)
 	pblockNew := cs.client.PreExecBlock(block.Data, false)
@@ -748,17 +758,21 @@ func (cs *ConsensusState) createProposalBlock() (block *ttypes.TendermintBlock)
 	return block
 }
 
-func (cs *ConsensusState) createBaseTx(block *tmtypes.TendermintBlock) (tx *types.Transaction) {
+func (cs *ConsensusState) createBaseTx(block *tmtypes.TendermintBlock) *types.Transaction {
 	var state *tmtypes.State
 	if cs.Height == 1 {
-		state = &tmtypes.State{}
+		genState := cs.client.GenesisState()
+		if genState == nil {
+			return nil
+		}
+		state = SaveState(*genState)
 	} else {
 		state = cs.client.csStore.LoadStateFromStore()
 		if state == nil {
-			panic("createBaseTx LoadStateFromStore fail")
+			return nil
 		}
 	}
-	tx = CreateBlockInfoTx(cs.client.pubKey, state, block)
+	tx := CreateBlockInfoTx(cs.client.pubKey, state, block)
 	return tx
 }
 
@@ -1160,8 +1174,9 @@ func (cs *ConsensusState) defaultSetProposal(proposal *tmtypes.Proposal) error {
 	}
 
 	// Verify POLRound, which must be -1 or in range [0, proposal.Round).
-	if proposal.POLRound != -1 ||
-		(proposal.POLRound >= 0 && proposal.Round >= proposal.POLRound) {
+	if proposal.POLRound < -1 ||
+		(proposal.POLRound >= 0 && proposal.POLRound >= proposal.Round) {
+		tendermintlog.Error("Invalid POLRound", "POLRound", proposal.POLRound, "Round", proposal.Round)
 		return ErrInvalidProposalPOLRound
 	}
 

plugin/consensus/tendermint/genesis.json

-{"genesis_time":"0001-01-01T00:00:00Z","chain_id":"test-chain-Ep9EcD","validators":[{"pub_key":{"type":"ed25519","data":"220ACBE680DF2473A0CB48987A00FCC1812F106A7390BE6B8E2D31122C992A19"},"power":10,"name":""}],"app_hash":""}
+{"genesis_time":"2019-10-25T10:25:24.027375266+08:00","chain_id":"chain33-ROPNZn","validators":[{"pub_key":{"type":"ed25519","data":"8D80E15927EF2854C78D981015BD2AD469867957081357D0FADD88871752A7E1"},"power":10,"name":""}],"app_hash":null}
\ No newline at end of file

plugin/consensus/tendermint/node_test.go

@@ -3,11 +3,14 @@ package tendermint
 import (
 	"encoding/hex"
 	"fmt"
+	"net"
 	"sync"
 	"testing"
 
 	"github.com/33cn/chain33/common/crypto"
 	"github.com/33cn/chain33/types"
+	ttypes "github.com/33cn/plugin/plugin/consensus/tendermint/types"
+	tmtypes "github.com/33cn/plugin/plugin/dapp/valnode/types"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -15,8 +18,8 @@ var (
 	secureConnCrypto crypto.Crypto
 	sum              = 0
 	mutx             sync.Mutex
-	privKey          = "B3DC4C0725884EBB7264B92F1D8D37584A64ADE1799D997EC64B4FE3973E08DE220ACBE680DF2473A0CB48987A00FCC1812F106A7390BE6B8E2D31122C992A19"
-	expectAddress    = "02A13174B92727C4902DB099E51A3339F48BD45E"
+	privKey          = "23278EA4CFE8B00360EBB376F2BBFAC345136EE5BC4549532C394C0AF2B80DFE8D80E15927EF2854C78D981015BD2AD469867957081357D0FADD88871752A7E1"
+	expectAddress    = "07FE011CE6F4C458FD9D417ED38CB262A4364FA1"
 )
 
 func init() {
@@ -79,19 +82,31 @@ func TestIP2IPPort(t *testing.T) {
 	fmt.Println("TestIP2IPPort ok")
 }
 
+func TestNodeFunc(t *testing.T) {
+	node := &Node{Version: "1.1.1", Network: "net1"}
+	assert.NotNil(t, node.CompatibleWith(NodeInfo{Version: "1.1", Network: "net1"}))
+	assert.NotNil(t, node.CompatibleWith(NodeInfo{Version: "2.1.1", Network: "net1"}))
+	assert.NotNil(t, node.CompatibleWith(NodeInfo{Version: "1.1.1", Network: "net2"}))
+	assert.Nil(t, node.CompatibleWith(NodeInfo{Version: "1.2.3", Network: "net1"}))
+
+	assert.False(t, isIpv6(net.IP{127, 0, 0, 1}))
+	assert.True(t, isIpv6(net.IP{0xff, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}))
+	fmt.Println("TestNodeFunc ok")
+}
+
 func TestPeerSet(t *testing.T) {
 	testSet := NewPeerSet()
 	assert.Equal(t, false, testSet.Has("1"))
 
-	peer1 := &peerConn{id: "1", ip: []byte("1.1.1.1")}
+	peer1 := &peerConn{id: "1", ip: net.IP{127, 0, 0, 1}}
 	testSet.Add(peer1)
 	assert.Equal(t, true, testSet.Has("1"))
-	assert.Equal(t, true, testSet.HasIP([]byte("1.1.1.1")))
+	assert.Equal(t, true, testSet.HasIP(net.IP{127, 0, 0, 1}))
 
 	err := testSet.Add(peer1)
 	assert.NotNil(t, err)
 
-	peer2 := &peerConn{id: "2", ip: []byte("1.1.1.2")}
+	peer2 := &peerConn{id: "2", ip: net.IP{127, 0, 0, 2}}
 	testSet.Add(peer2)
 	assert.Equal(t, true, testSet.Has("2"))
 	assert.Equal(t, 2, testSet.Size())
@@ -99,7 +114,142 @@ func TestPeerSet(t *testing.T) {
 	testSet.Remove(peer1)
 	assert.Equal(t, 1, testSet.Size())
 	assert.Equal(t, false, testSet.Has("1"))
-	assert.Equal(t, false, testSet.HasIP([]byte("1.1.1.1")))
+	assert.Equal(t, false, testSet.HasIP(net.IP{127, 0, 0, 1}))
 
 	fmt.Println("TestPeerSet ok")
 }
+
+func TestPeerConn(t *testing.T) {
+	pc := &peerConn{id: "3", ip: net.IP{127, 0, 0, 3}, outbound: true, persistent: false}
+	_, err := pc.RemoteAddr()
+	assert.NotNil(t, err)
+	assert.True(t, pc.IsOutbound())
+	assert.False(t, pc.IsPersistent())
+
+	pc.sendQueue = make(chan MsgInfo, maxSendQueueSize)
+	assert.False(t, pc.Send(MsgInfo{}))
+	assert.False(t, pc.TrySend(MsgInfo{}))
+	pc.started = 1
+	assert.True(t, pc.Send(MsgInfo{}))
+	assert.True(t, pc.TrySend(MsgInfo{}))
+
+	testUpdateStateRoutine(t, pc)
+
+	fmt.Println("TestPeerConn ok")
+}
+
+func testUpdateStateRoutine(t *testing.T, pc *peerConn) {
+	pc.quitUpdate = make(chan struct{})
+	pc.updateStateQueue = make(chan MsgInfo)
+	pc.state = &PeerConnState{
+		ip: pc.ip,
+		PeerRoundState: ttypes.PeerRoundState{
+			Height:             int64(2),
+			Round:              0,
+			Step:               ttypes.RoundStepCommit,
+			Proposal:           true,
+			ProposalBlockHash:  []byte("ProposalBlockHash@2"),
+			LastCommitRound:    0,
+			CatchupCommitRound: 0,
+		},
+	}
+	ps := pc.state
+	pc.waitQuit.Add(1)
+	go pc.updateStateRoutine()
+
+	//NewRoundStepID msg
+	rsMsg := &tmtypes.NewRoundStepMsg{
+		Height:                int64(3),
+		Round:                 int32(1),
+		Step:                  int32(3),
+		SecondsSinceStartTime: int32(1),
+		LastCommitRound:       int32(1),
+	}
+	pc.updateStateQueue <- MsgInfo{ttypes.NewRoundStepID, rsMsg, ID("TEST"), pc.ip.String()}
+	pc.updateStateQueue <- MsgInfo{TypeID: byte(0x00)}
+	assert.Equal(t, int64(3), ps.Height)
+	assert.Equal(t, 1, ps.Round)
+	assert.Equal(t, ttypes.RoundStepPropose, ps.Step)
+	assert.Equal(t, false, ps.Proposal)
+	assert.Equal(t, 1, ps.LastCommitRound)
+	assert.Equal(t, -1, ps.CatchupCommitRound)
+	//SetHasProposal
+	proposal := &tmtypes.Proposal{
+		Height:    int64(3),
+		Round:     int32(1),
+		POLRound:  int32(1),
+		Blockhash: []byte("ProposalBlockHash@3"),
+	}
+	ps.SetHasProposal(proposal)
+	assert.True(t, ps.Proposal)
+	assert.Equal(t, 1, ps.ProposalPOLRound)
+	assert.Equal(t, []byte("ProposalBlockHash@3"), ps.ProposalBlockHash)
+	//SetHasProposalBlock
+	block := &ttypes.TendermintBlock{
+		TendermintBlock: &tmtypes.TendermintBlock{
+			Header: &tmtypes.TendermintBlockHeader{
+				Height: int64(3),
+				Round:  int64(1),
+			},
+		},
+	}
+	ps.SetHasProposalBlock(block)
+	assert.True(t, ps.ProposalBlock)
+	//ValidBlockID msg
+	validBlockMsg := &tmtypes.ValidBlockMsg{
+		Height:    int64(3),
+		Round:     int32(1),
+		Blockhash: []byte("ValidBlockHash@3"),
+		IsCommit:  false,
+	}
+	pc.updateStateQueue <- MsgInfo{ttypes.ValidBlockID, validBlockMsg, ID("TEST"), pc.ip.String()}
+	pc.updateStateQueue <- MsgInfo{TypeID: byte(0x00)}
+	assert.Equal(t, []byte("ValidBlockHash@3"), ps.ProposalBlockHash)
+	//HasVoteID msg
+	hasVoteMsg := &tmtypes.HasVoteMsg{
+		Height: int64(3),
+		Round:  int32(1),
+		Type:   int32(ttypes.VoteTypePrevote),
+		Index:  int32(1),
+	}
+	ps.EnsureVoteBitArrays(int64(3), 2)
+	ps.EnsureVoteBitArrays(int64(2), 2)
+	assert.False(t, ps.Prevotes.GetIndex(1))
+	pc.updateStateQueue <- MsgInfo{ttypes.HasVoteID, hasVoteMsg, ID("TEST"), pc.ip.String()}
+	pc.updateStateQueue <- MsgInfo{TypeID: byte(0x00)}
+	assert.True(t, ps.Prevotes.GetIndex(1))
+	//ProposalPOLID msg
+	proposalPOL := ps.Prevotes.TendermintBitArray
+	proposalPOLMsg := &tmtypes.ProposalPOLMsg{
+		Height:           int64(3),
+		ProposalPOLRound: int32(1),
+		ProposalPOL:      proposalPOL,
+	}
+	pc.updateStateQueue <- MsgInfo{ttypes.ProposalPOLID, proposalPOLMsg, ID("TEST"), pc.ip.String()}
+	pc.updateStateQueue <- MsgInfo{TypeID: byte(0x00)}
+	assert.EqualValues(t, proposalPOL, ps.ProposalPOL.TendermintBitArray)
+
+	//PickSendVote
+	ttypes.Init()
+	vals := make([]*ttypes.Validator, 2)
+	votes := ttypes.NewVoteSet("TEST", 3, 1, ttypes.VoteTypePrevote, &ttypes.ValidatorSet{Validators: vals})
+	assert.False(t, pc.PickSendVote(votes))
+
+	assert.Equal(t, int64(3), ps.GetHeight())
+	assert.NotNil(t, ps.GetRoundState())
+	assert.Nil(t, ps.getVoteBitArray(3, 1, byte(0x03)))
+	assert.NotNil(t, ps.getVoteBitArray(3, 1, ttypes.VoteTypePrecommit))
+	assert.Nil(t, ps.getVoteBitArray(2, 1, ttypes.VoteTypePrevote))
+	assert.NotNil(t, ps.getVoteBitArray(2, 1, ttypes.VoteTypePrecommit))
+
+	ps.ensureCatchupCommitRound(3, 2, 2)
+	assert.Equal(t, 2, ps.CatchupCommitRound)
+	assert.NotNil(t, ps.CatchupCommit)
+	assert.Nil(t, ps.getVoteBitArray(3, 2, ttypes.VoteTypePrevote))
+	assert.NotNil(t, ps.getVoteBitArray(3, 2, ttypes.VoteTypePrecommit))
+
+	pc.quitUpdate <- struct{}{}
+	pc.waitQuit.Wait()
+
+	fmt.Println("testUpdateStateRoutine ok")
+}

plugin/consensus/tendermint/peer_set.go

@@ -85,8 +85,10 @@ type peerConn struct {
 	started uint32 //atomic
 	stopped uint32 // atomic
 
-	quit     chan struct{}
-	waitQuit sync.WaitGroup
+	quitSend   chan struct{}
+	quitUpdate chan struct{}
+	quitBeat   chan struct{}
+	waitQuit   sync.WaitGroup
 
 	transferChannel chan MsgInfo
 
@@ -404,7 +406,9 @@ func (pc *peerConn) Start() error {
 		pc.pongChannel = make(chan struct{})
 		pc.sendQueue = make(chan MsgInfo, maxSendQueueSize)
 		pc.sendBuffer = make([]byte, 0, MaxMsgPacketPayloadSize)
-		pc.quit = make(chan struct{})
+		pc.quitSend = make(chan struct{})
+		pc.quitUpdate = make(chan struct{})
+		pc.quitBeat = make(chan struct{})
 		pc.state = &PeerConnState{ip: pc.ip, PeerRoundState: ttypes.PeerRoundState{
 			Round:              -1,
 			ProposalPOLRound:   -1,
@@ -413,7 +417,7 @@ func (pc *peerConn) Start() error {
 		}}
 		pc.updateStateQueue = make(chan MsgInfo, maxSendQueueSize)
 		pc.heartbeatQueue = make(chan proto.Message, 100)
-		pc.waitQuit.Add(5) //sendRoutine, updateStateRoutine,gossipDataRoutine,gossipVotesRoutine,queryMaj23Routine
+		pc.waitQuit.Add(5) //heartbeatRoutine, updateStateRoutine,gossipDataRoutine,gossipVotesRoutine,queryMaj23Routine
 
 		go pc.sendRoutine()
 		go pc.recvRoutine()
@@ -430,20 +434,18 @@ func (pc *peerConn) Start() error {
 
 func (pc *peerConn) Stop() {
 	if atomic.CompareAndSwapUint32(&pc.stopped, 0, 1) {
-		if pc.heartbeatQueue != nil {
-			close(pc.heartbeatQueue)
-			pc.heartbeatQueue = nil
-		}
-		if pc.quit != nil {
-			close(pc.quit)
-			tendermintlog.Info("peerConn stop quit wait", "peerIP", pc.ip.String())
-			pc.waitQuit.Wait()
-			tendermintlog.Info("peerConn stop quit wait finish", "peerIP", pc.ip.String())
-			pc.quit = nil
-		}
+		pc.quitSend <- struct{}{}
+		pc.quitUpdate <- struct{}{}
+		pc.quitBeat <- struct{}{}
+
+		pc.waitQuit.Wait()
+		tendermintlog.Info("peerConn stop waitQuit", "peerIP", pc.ip.String())
+
 		close(pc.sendQueue)
+		pc.sendQueue = nil
 		pc.transferChannel = nil
 		pc.CloseConn()
+		tendermintlog.Info("peerConn stop finish", "peerIP", pc.ip.String())
 	}
 }
 
@@ -460,8 +462,9 @@ func (pc *peerConn) stopForError(r interface{}) {
 	tendermintlog.Error("peerConn recovered panic", "error", r, "peer", pc.ip.String())
 	if pc.onPeerError != nil {
 		pc.onPeerError(pc, r)
+	} else {
+		pc.Stop()
 	}
-	pc.Stop()
 }
 
 func (pc *peerConn) sendRoutine() {
@@ -469,8 +472,7 @@ func (pc *peerConn) sendRoutine() {
 FOR_LOOP:
 	for {
 		select {
-		case <-pc.quit:
-			pc.waitQuit.Done()
+		case <-pc.quitSend:
 			break FOR_LOOP
 		case msg := <-pc.sendQueue:
 			bytes, err := proto.Marshal(msg.Msg)
@@ -519,6 +521,7 @@ FOR_LOOP:
 			}
 		}
 	}
+	tendermintlog.Info("peerConn stop sendRoutine", "peerIP", pc.ip.String())
 }
 
 func (pc *peerConn) recvRoutine() {
@@ -542,7 +545,6 @@ FOR_LOOP:
 			if err != nil {
 				tendermintlog.Error("Connection failed @ recvRoutine", "conn", pc, "err", err)
 				pc.stopForError(err)
-				panic(fmt.Sprintf("peerConn recvRoutine packetTypeMsg failed :%v", err))
 			}
 			pkt.Bytes = buf2
 		}
@@ -591,23 +593,24 @@ FOR_LOOP:
 	}
 
 	close(pc.pongChannel)
-	for range pc.pongChannel {
-		// Drain
-	}
+	close(pc.heartbeatQueue)
+	close(pc.updateStateQueue)
+	tendermintlog.Info("peerConn stop recvRoutine", "peerIP", pc.ip.String())
 }
 
 func (pc *peerConn) updateStateRoutine() {
 FOR_LOOP:
 	for {
 		select {
+		case <-pc.quitUpdate:
+			pc.waitQuit.Done()
+			break FOR_LOOP
 		case msg := <-pc.updateStateQueue:
 			typeID := msg.TypeID
 			if typeID == ttypes.NewRoundStepID {
 				pc.state.ApplyNewRoundStepMessage(msg.Msg.(*tmtypes.NewRoundStepMsg))
 			} else if typeID == ttypes.ValidBlockID {
 				pc.state.ApplyValidBlockMessage(msg.Msg.(*tmtypes.ValidBlockMsg))
-			} else if typeID == ttypes.CommitStepID {
-				pc.state.ApplyCommitStepMessage(msg.Msg.(*tmtypes.CommitStepMsg))
 			} else if typeID == ttypes.HasVoteID {
 				pc.state.ApplyHasVoteMessage(msg.Msg.(*tmtypes.HasVoteMsg))
 			} else if typeID == ttypes.VoteSetMaj23ID {
@@ -655,41 +658,37 @@ FOR_LOOP:
 					pc.state.ApplyVoteSetBitsMessage(tmp, nil)
 				}
 			} else {
-				tendermintlog.Error("msg not deal in updateStateRoutine", "msgTypeName", msg.Msg.String())
+				tendermintlog.Error("Unknown message type in updateStateRoutine", "msg", msg)
 			}
-		case <-pc.quit:
-			pc.waitQuit.Done()
-			break FOR_LOOP
 		}
 	}
-	close(pc.updateStateQueue)
-	for range pc.updateStateQueue {
-		// Drain
-	}
+	tendermintlog.Info("peerConn stop updateStateRoutine", "peerIP", pc.ip.String())
 }
 
 func (pc *peerConn) heartbeatRoutine() {
+FOR_LOOP:
 	for {
-		heartbeat, ok := <-pc.heartbeatQueue
-		if !ok {
-			tendermintlog.Debug("heartbeatQueue closed")
-			return
+		select {
+		case <-pc.quitBeat:
+			pc.waitQuit.Done()
+			break FOR_LOOP
+		case heartbeat := <-pc.heartbeatQueue:
+			msg := heartbeat.(*tmtypes.Heartbeat)
+			tendermintlog.Debug("Received proposal heartbeat message",
+				"height", msg.Height, "round", msg.Round, "sequence", msg.Sequence,
+				"valIdx", msg.ValidatorIndex, "valAddr", msg.ValidatorAddress)
 		}
-		msg := heartbeat.(*tmtypes.Heartbeat)
-		tendermintlog.Debug("Received proposal heartbeat message",
-			"height", msg.Height, "round", msg.Round, "sequence", msg.Sequence,
-			"valIdx", msg.ValidatorIndex, "valAddr", msg.ValidatorAddress)
 	}
+	tendermintlog.Info("peerConn stop heartbeatRoutine", "peerIP", pc.ip.String())
 }
 
 func (pc *peerConn) gossipDataRoutine() {
 OUTER_LOOP:
 	for {
 		// Manage disconnects from self or peer.
-
 		if !pc.IsRunning() {
-			tendermintlog.Error("Stopping gossipDataRoutine for peer")
 			pc.waitQuit.Done()
+			tendermintlog.Info("peerConn stop gossipDataRoutine", "peerIP", pc.ip.String())
 			return
 		}
 
@@ -790,8 +789,8 @@ OUTER_LOOP:
 	for {
 		// Manage disconnects from self or peer.
 		if !pc.IsRunning() {
-			tendermintlog.Info("Stopping gossipVotesRoutine for peer")
 			pc.waitQuit.Done()
+			tendermintlog.Info("peerConn stop gossipVotesRoutine", "peerIP", pc.ip.String())
 			return
 		}
 
@@ -915,8 +914,8 @@ OUTER_LOOP:
 	for {
 		// Manage disconnects from self or peer.
 		if !pc.IsRunning() {
-			tendermintlog.Info("Stopping queryMaj23Routine for peer")
 			pc.waitQuit.Done()
+			tendermintlog.Info("peerConn stop queryMaj23Routine", "peerIP", pc.ip.String())
 			return
 		}
 
@@ -1294,16 +1293,6 @@ func (ps *PeerConnState) ApplyNewRoundStepMessage(msg *tmtypes.NewRoundStepMsg)
 	}
 }
 
-// ApplyCommitStepMessage updates the peer state for the new commit.
-func (ps *PeerConnState) ApplyCommitStepMessage(msg *tmtypes.CommitStepMsg) {
-	ps.mtx.Lock()
-	defer ps.mtx.Unlock()
-
-	if ps.Height != msg.Height {
-		return
-	}
-}
-
 // ApplyValidBlockMessage updates the peer state for the new valid block.
 func (ps *PeerConnState) ApplyValidBlockMessage(msg *tmtypes.ValidBlockMsg) {
 	ps.mtx.Lock()

plugin/consensus/tendermint/priv_validator.json

-{"address":"02A13174B92727C4902DB099E51A3339F48BD45E","pub_key":{"type":"ed25519","data":"220ACBE680DF2473A0CB48987A00FCC1812F106A7390BE6B8E2D31122C992A19"},"last_height":0,"last_round":0,"last_step":0,"priv_key":{"type":"ed25519","data":"B3DC4C0725884EBB7264B92F1D8D37584A64ADE1799D997EC64B4FE3973E08DE220ACBE680DF2473A0CB48987A00FCC1812F106A7390BE6B8E2D31122C992A19"}}
+{"address":"07FE011CE6F4C458FD9D417ED38CB262A4364FA1","pub_key":{"type":"ed25519","data":"8D80E15927EF2854C78D981015BD2AD469867957081357D0FADD88871752A7E1"},"last_height":0,"last_round":0,"last_step":0,"priv_key":{"type":"ed25519","data":"23278EA4CFE8B00360EBB376F2BBFAC345136EE5BC4549532C394C0AF2B80DFE8D80E15927EF2854C78D981015BD2AD469867957081357D0FADD88871752A7E1"}}
\ No newline at end of file

plugin/consensus/tendermint/state.go

@@ -10,9 +10,7 @@ import (
 	"errors"
 	"fmt"
 	"io/ioutil"
-	"math/rand"
 	"sync"
-	"time"
 
 	"github.com/33cn/chain33/common"
 	"github.com/33cn/chain33/common/address"
@@ -24,10 +22,6 @@ import (
 
 const fee = 1e6
 
-var (
-	r *rand.Rand
-)
-
 // State is a short description of the latest committed block of the Tendermint consensus.
 // It keeps all information necessary to validate new blocks,
 // including the last validator set and the consensus params.
@@ -91,6 +85,9 @@ func (s State) Copy() State {
 
 // Equals returns true if the States are identical.
 func (s State) Equals(s2 State) bool {
+	if s.Bytes() == nil || s2.Bytes() == nil {
+		return false
+	}
 	return bytes.Equal(s.Bytes(), s2.Bytes())
 }
 
@@ -98,7 +95,7 @@ func (s State) Equals(s2 State) bool {
 func (s State) Bytes() []byte {
 	sbytes, err := json.Marshal(s)
 	if err != nil {
-		fmt.Printf("Error reading GenesisDoc: %v", err)
+		fmt.Printf("Error State Marshal: %v", err)
 		return nil
 	}
 	return sbytes
@@ -214,7 +211,6 @@ type CSStateDB struct {
 
 // NewStateDB make a new one
 func NewStateDB(client *Client, state State) *CSStateDB {
-	r = rand.New(rand.NewSource(time.Now().UnixNano()))
 	return &CSStateDB{
 		client: client,
 		state:  state,
@@ -229,8 +225,8 @@ func LoadState(state *tmtypes.State) State {
 		LastBlockTotalTx:                 state.GetLastBlockTotalTx(),
 		LastBlockID:                      ttypes.BlockID{BlockID: *state.LastBlockID},
 		LastBlockTime:                    state.LastBlockTime,
-		Validators:                       nil,
-		LastValidators:                   nil,
+		Validators:                       &ttypes.ValidatorSet{Validators: make([]*ttypes.Validator, 0), Proposer: &ttypes.Validator{}},
+		LastValidators:                   &ttypes.ValidatorSet{Validators: make([]*ttypes.Validator, 0), Proposer: &ttypes.Validator{}},
 		LastHeightValidatorsChanged:      state.LastHeightValidatorsChanged,
 		ConsensusParams:                  ttypes.ConsensusParams{BlockSize: ttypes.BlockSize{}, TxSize: ttypes.TxSize{}, BlockGossip: ttypes.BlockGossip{}, EvidenceParams: ttypes.EvidenceParams{}},
 		LastHeightConsensusParamsChanged: state.LastHeightConsensusParamsChanged,
@@ -241,15 +237,11 @@ func LoadState(state *tmtypes.State) State {
 		if array := validators.GetValidators(); array != nil {
 			targetArray := make([]*ttypes.Validator, len(array))
 			LoadValidators(targetArray, array)
-			stateTmp.Validators = &ttypes.ValidatorSet{Validators: targetArray, Proposer: nil}
+			stateTmp.Validators.Validators = targetArray
 		}
 		if proposer := validators.GetProposer(); proposer != nil {
-			if stateTmp.Validators == nil {
-				tendermintlog.Error("LoadState validator is nil but proposer")
-			} else {
-				if val, err := LoadProposer(proposer); err == nil {
-					stateTmp.Validators.Proposer = val
-				}
+			if val, err := LoadProposer(proposer); err == nil {
+				stateTmp.Validators.Proposer = val
 			}
 		}
 	}
@@ -257,15 +249,11 @@ func LoadState(state *tmtypes.State) State {
 		if array := lastValidators.GetValidators(); array != nil {
 			targetArray := make([]*ttypes.Validator, len(array))
 			LoadValidators(targetArray, array)
-			stateTmp.LastValidators = &ttypes.ValidatorSet{Validators: targetArray, Proposer: nil}
+			stateTmp.LastValidators.Validators = targetArray
 		}
 		if proposer := lastValidators.GetProposer(); proposer != nil {
-			if stateTmp.LastValidators == nil {
-				tendermintlog.Error("LoadState last validator is nil but proposer")
-			} else {
-				if val, err := LoadProposer(proposer); err == nil {
-					stateTmp.LastValidators.Proposer = val
-				}
+			if val, err := LoadProposer(proposer); err == nil {
+				stateTmp.LastValidators.Proposer = val
 			}
 		}
 	}
@@ -306,32 +294,22 @@ func (csdb *CSStateDB) LoadState() State {
 
 // LoadValidators by height
 func (csdb *CSStateDB) LoadValidators(height int64) (*ttypes.ValidatorSet, error) {
-	if height == 0 {
-		return nil, nil
+	csdb.mtx.Lock()
+	defer csdb.mtx.Unlock()
+
+	if height < 1 {
+		return nil, ttypes.ErrHeightLessThanOne
 	}
 	if csdb.state.LastBlockHeight == height {
 		return csdb.state.Validators, nil
 	}
 
-	blockInfo, err := csdb.client.QueryBlockInfoByHeight(height)
-	if err != nil {
-		tendermintlog.Error("LoadValidators GetBlockInfo failed", "error", err)
-		panic(fmt.Sprintf("LoadValidators GetBlockInfo failed:%v", err))
-	}
-
-	var state State
-	if blockInfo == nil {
-		tendermintlog.Error("LoadValidators", "msg", "block height is not 0 but blockinfo is nil")
-		panic(fmt.Sprintf("LoadValidators block height is %v but block info is nil", height))
-	} else {
-		csState := blockInfo.GetState()
-		if csState == nil {
-			tendermintlog.Error("LoadValidators", "msg", "blockInfo.GetState is nil")
-			return nil, fmt.Errorf("LoadValidators get state from block info is nil")
-		}
-		state = LoadState(csState)
+	state := csdb.client.LoadBlockState(height)
+	if state == nil {
+		return nil, errors.New("ErrLoadBlockState")
 	}
-	return state.Validators.Copy(), nil
+	load := LoadState(state)
+	return load.Validators.Copy(), nil
 }
 
 func saveConsensusParams(dest *tmtypes.ConsensusParams, source ttypes.ConsensusParams) {
@@ -474,7 +452,7 @@ func CreateBlockInfoTx(pubkey string, state *tmtypes.State, block *tmtypes.Tende
 	action := &tmtypes.ValNodeAction{Value: nput, Ty: tmtypes.ValNodeActionBlockInfo}
 	tx := &types.Transaction{Execer: []byte("valnode"), Payload: types.Encode(action), Fee: fee}
 	tx.To = address.ExecAddress("valnode")
-	tx.Nonce = r.Int63()
+	tx.Nonce = random.Int63()
 	tx.Sign(types.SECP256K1, getprivkey(pubkey))
 
 	return tx

plugin/consensus/tendermint/tendermint.go

@@ -7,13 +7,13 @@ package tendermint
 import (
 	"bytes"
 	"fmt"
+	"math/rand"
 	"os"
 	"time"
 
 	"github.com/33cn/chain33/common/crypto"
 	dbm "github.com/33cn/chain33/common/db"
 	"github.com/33cn/chain33/common/log/log15"
-	"github.com/33cn/chain33/common/merkle"
 	"github.com/33cn/chain33/queue"
 	drivers "github.com/33cn/chain33/system/consensus"
 	cty "github.com/33cn/chain33/system/dapp/coins/types"
@@ -46,11 +46,13 @@ var (
 	peerGossipSleepDuration     int32 = 100
 	peerQueryMaj23SleepDuration int32 = 2000
 	zeroHash                    [32]byte
+	random                      *rand.Rand
 )
 
 func init() {
 	drivers.Reg("tendermint", New)
 	drivers.QueryData.Register("tendermint", &Client{})
+	random = rand.New(rand.NewSource(time.Now().UnixNano()))
 }
 
 // Client Tendermint implementation
@@ -63,7 +65,6 @@ type Client struct {
 	pubKey        string
 	csState       *ConsensusState
 	csStore       *ConsensusStore // save consensus state
-	evidenceDB    dbm.DB
 	crypto        crypto.Crypto
 	node          *Node
 	txsAvailable  chan int64
@@ -152,9 +153,6 @@ func New(cfg *types.Consensus, sub []byte) queue.Module {
 		return nil
 	}
 
-	// Make Evidence Reactor
-	evidenceDB := DefaultDBProvider("evidence")
-
 	cr, err := crypto.New(types.GetSignName("", types.ED25519))
 	if err != nil {
 		tendermintlog.Error("NewTendermintClient", "err", err)
@@ -186,7 +184,6 @@ func New(cfg *types.Consensus, sub []byte) queue.Module {
 		privKey:       priv,
 		pubKey:        pubkey,
 		csStore:       NewConsensusStore(),
-		evidenceDB:    evidenceDB,
 		crypto:        cr,
 		txsAvailable:  make(chan int64, 1),
 		stopC:         make(chan struct{}, 1),
@@ -198,7 +195,6 @@ func New(cfg *types.Consensus, sub []byte) queue.Module {
 }
 
 // PrivValidator returns the Node's PrivValidator.
-// XXX: for convenience only!
 func (client *Client) PrivValidator() ttypes.PrivValidator {
 	return client.privValidator
 }
@@ -208,6 +204,16 @@ func (client *Client) GenesisDoc() *ttypes.GenesisDoc {
 	return client.genesisDoc
 }
 
+// GenesisState returns the Node's GenesisState.
+func (client *Client) GenesisState() *State {
+	state, err := MakeGenesisState(client.genesisDoc)
+	if err != nil {
+		tendermintlog.Error("GenesisState", "err", err)
+		return nil
+	}
+	return &state
+}
+
 // Close TODO:may need optimize
 func (client *Client) Close() {
 	client.node.Stop()
@@ -249,9 +255,9 @@ OuterLoop:
 	// load state
 	var state State
 	if client.GetCurrentHeight() == 0 {
-		genState, err := MakeGenesisState(client.genesisDoc)
-		if err != nil {
-			panic(fmt.Sprintf("StartConsensus MakeGenesisState fail:%v", err))
+		genState := client.GenesisState()
+		if genState == nil {
+			panic("StartConsensus GenesisState fail")
 		}
 		state = genState.Copy()
 	} else if client.GetCurrentHeight() <= client.csStore.LoadStateHeight() {
@@ -336,21 +342,22 @@ func (client *Client) CreateGenesisTx() (ret []*types.Transaction) {
 }
 
 func (client *Client) getBlockInfoTx(current *types.Block) (*tmtypes.ValNodeAction, error) {
-	//检查第一个笔交易的execs, 以及执行状态
+	//检查第一笔交易
 	if len(current.Txs) == 0 {
 		return nil, types.ErrEmptyTx
 	}
 	baseTx := current.Txs[0]
-	//判断交易类型和执行情况
+
 	var valAction tmtypes.ValNodeAction
 	err := types.Decode(baseTx.GetPayload(), &valAction)
 	if err != nil {
 		return nil, err
 	}
+	//检查交易类型
 	if valAction.GetTy() != tmtypes.ValNodeActionBlockInfo {
 		return nil, ttypes.ErrBaseTxType
 	}
-	//判断交易执行是否OK
+	//检查交易内容
 	if valAction.GetBlockInfo() == nil {
 		return nil, ttypes.ErrBlockInfoTx
 	}
@@ -389,9 +396,10 @@ func (client *Client) CheckBlock(parent *types.Block, current *types.BlockDetail
 	return nil
 }
 
-// ProcEvent ...
+// ProcEvent reply not support action err
 func (client *Client) ProcEvent(msg *queue.Message) bool {
-	return false
+	msg.ReplyErr("Client", types.ErrActionNotSupport)
+	return true
 }
 
 // CreateBlock a routine monitor whether some transactions available and tell client by available channel
@@ -519,7 +527,7 @@ func (client *Client) WaitBlock(height int64) bool {
 		retry++
 		time.Sleep(100 * time.Millisecond)
 		if retry >= 100 {
-			tendermintlog.Warn("Wait block fail", "height", height, "CurrentHeight", newHeight)
+			tendermintlog.Error("Wait block fail", "height", height, "CurrentHeight", newHeight)
 			return false
 		}
 	}
@@ -527,8 +535,8 @@ func (client *Client) WaitBlock(height int64) bool {
 
 // QueryValidatorsByHeight ...
 func (client *Client) QueryValidatorsByHeight(height int64) (*tmtypes.ValNodes, error) {
-	if height <= 0 {
-		return nil, types.ErrInvalidParam
+	if height < 1 {
+		return nil, ttypes.ErrHeightLessThanOne
 	}
 	req := &tmtypes.ReqNodeInfo{Height: height}
 	param, err := proto.Marshal(req)
@@ -551,89 +559,56 @@ func (client *Client) QueryValidatorsByHeight(height int64) (*tmtypes.ValNodes,
 	return msg.GetData().(types.Message).(*tmtypes.ValNodes), nil
 }
 
-// QueryBlockInfoByHeight ...
-func (client *Client) QueryBlockInfoByHeight(height int64) (*tmtypes.TendermintBlockInfo, error) {
-	if height <= 0 {
-		return nil, types.ErrInvalidParam
+// QueryBlockInfoByHeight get blockInfo and block by height
+func (client *Client) QueryBlockInfoByHeight(height int64) (*tmtypes.TendermintBlockInfo, *types.Block, error) {
+	if height < 1 {
+		return nil, nil, ttypes.ErrHeightLessThanOne
 	}
-	req := &tmtypes.ReqBlockInfo{Height: height}
-	param, err := proto.Marshal(req)
+	block, err := client.RequestBlock(height)
 	if err != nil {
-		tendermintlog.Error("QueryBlockInfoByHeight marshal", "err", err)
-		return nil, types.ErrInvalidParam
+		return nil, nil, err
 	}
-	msg := client.GetQueueClient().NewMessage("execs", types.EventBlockChainQuery,
-		&types.ChainExecutor{Driver: "valnode", FuncName: "GetBlockInfoByHeight", StateHash: zeroHash[:], Param: param})
-	err = client.GetQueueClient().Send(msg, true)
+	valAction, err := client.getBlockInfoTx(block)
 	if err != nil {
-		tendermintlog.Error("QueryBlockInfoByHeight send", "err", err)
-		return nil, err
+		return nil, nil, err
 	}
-	msg, err = client.GetQueueClient().Wait(msg)
-	if err != nil {
-		return nil, err
-	}
-	return msg.GetData().(types.Message).(*tmtypes.TendermintBlockInfo), nil
+	return valAction.GetBlockInfo(), block, nil
 }
 
 // LoadBlockCommit by height
 func (client *Client) LoadBlockCommit(height int64) *tmtypes.TendermintCommit {
-	blockInfo, err := client.QueryBlockInfoByHeight(height)
+	blockInfo, _, err := client.QueryBlockInfoByHeight(height)
 	if err != nil {
 		tendermintlog.Error("LoadBlockCommit GetBlockInfo fail", "err", err)
 		return nil
 	}
-	if blockInfo == nil {
-		tendermintlog.Error("LoadBlockCommit get nil block info")
-		return nil
-	}
 	return blockInfo.GetBlock().GetLastCommit()
 }
 
 // LoadBlockState by height
 func (client *Client) LoadBlockState(height int64) *tmtypes.State {
-	blockInfo, err := client.QueryBlockInfoByHeight(height)
+	blockInfo, _, err := client.QueryBlockInfoByHeight(height)
 	if err != nil {
 		tendermintlog.Error("LoadBlockState GetBlockInfo fail", "err", err)
 		return nil
 	}
-	if blockInfo == nil {
-		tendermintlog.Error("LoadBlockState get nil block info")
-		return nil
-	}
 	return blockInfo.GetState()
 }
 
 // LoadProposalBlock by height
 func (client *Client) LoadProposalBlock(height int64) *tmtypes.TendermintBlock {
-	block, err := client.RequestBlock(height)
+	blockInfo, block, err := client.QueryBlockInfoByHeight(height)
 	if err != nil {
-		tendermintlog.Error("LoadProposal by height failed", "curHeight", client.GetCurrentHeight(), "requestHeight", height, "error", err)
+		tendermintlog.Error("LoadProposal GetBlockInfo fail", "err", err)
 		return nil
 	}
-	blockInfo, err := client.QueryBlockInfoByHeight(height)
-	if err != nil {
-		panic(fmt.Sprintf("LoadProposal GetBlockInfo failed:%v", err))
-	}
-	if blockInfo == nil {
-		tendermintlog.Error("LoadProposal get nil block info")
-		return nil
-	}
-
 	proposalBlock := blockInfo.GetBlock()
-	if proposalBlock != nil {
-		proposalBlock.Data = block
-		txHash := merkle.CalcMerkleRoot(proposalBlock.Data.Txs)
-		tendermintlog.Debug("LoadProposalBlock txs hash", "height", proposalBlock.Header.Height, "tx-hash", fmt.Sprintf("%X", txHash))
-	}
+	proposalBlock.Data = block
 	return proposalBlock
 }
 
 // Query_IsHealthy query whether consensus is sync
 func (client *Client) Query_IsHealthy(req *types.ReqNil) (types.Message, error) {
-	if client == nil {
-		return nil, fmt.Errorf("%s", "client not bind message queue.")
-	}
 	isHealthy := false
 	if client.IsCaughtUp() && client.GetCurrentHeight() <= client.csState.GetRoundState().Height+1 {
 		isHealthy = true
@@ -643,9 +618,6 @@ func (client *Client) Query_IsHealthy(req *types.ReqNil) (types.Message, error)
 
 // Query_NodeInfo query validator node info
 func (client *Client) Query_NodeInfo(req *types.ReqNil) (types.Message, error) {
-	if client == nil {
-		return nil, fmt.Errorf("%s", "client not bind message queue.")
-	}
 	nodes := client.csState.GetRoundState().Validators.Validators
 	validators := make([]*tmtypes.Validator, 0)
 	for _, node := range nodes {

plugin/consensus/tendermint/tendermint_test.go

@@ -16,8 +16,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
-
 	"github.com/33cn/chain33/blockchain"
 	"github.com/33cn/chain33/common/address"
 	"github.com/33cn/chain33/common/limits"
@@ -29,8 +27,10 @@ import (
 	"github.com/33cn/chain33/rpc"
 	"github.com/33cn/chain33/store"
 	"github.com/33cn/chain33/types"
+	ty "github.com/33cn/plugin/plugin/consensus/tendermint/types"
 	pty "github.com/33cn/plugin/plugin/dapp/norm/types"
-	ty "github.com/33cn/plugin/plugin/dapp/valnode/types"
+	vty "github.com/33cn/plugin/plugin/dapp/valnode/types"
+	"github.com/stretchr/testify/assert"
 	"google.golang.org/grpc"
 
 	_ "github.com/33cn/chain33/system"
@@ -39,7 +39,7 @@ import (
 )
 
 var (
-	random    *rand.Rand
+	r         *rand.Rand
 	loopCount = 3
 	conn      *grpc.ClientConn
 	c         types.Chain33Client
@@ -50,7 +50,7 @@ func init() {
 	if err != nil {
 		panic(err)
 	}
-	random = rand.New(rand.NewSource(types.Now().UnixNano()))
+	r = rand.New(rand.NewSource(types.Now().UnixNano()))
 	log.SetLogLevel("info")
 }
 func TestTendermintPerf(t *testing.T) {
@@ -128,7 +128,6 @@ func createConn() error {
 		return err
 	}
 	c = types.NewChain33Client(conn)
-	r = rand.New(rand.NewSource(types.Now().UnixNano()))
 	return nil
 }
 
@@ -164,7 +163,7 @@ func prepareTxList() *types.Transaction {
 	action := &pty.NormAction{Value: nput, Ty: pty.NormActionPut}
 	tx := &types.Transaction{Execer: []byte("norm"), Payload: types.Encode(action), Fee: fee}
 	tx.To = address.ExecAddress("norm")
-	tx.Nonce = random.Int63()
+	tx.Nonce = r.Int63()
 	tx.Sign(types.SECP256K1, getprivkey("CC38546E9E659D15E6B4893F0AB32A06D103931A8230B0BDE71459D2B27D6944"))
 	return tx
 }
@@ -198,11 +197,11 @@ func AddNode() {
 		fmt.Fprintln(os.Stderr, err)
 		return
 	}
-	nput := &ty.ValNodeAction_Node{Node: &ty.ValNode{PubKey: pubkeybyte, Power: int64(2)}}
-	action := &ty.ValNodeAction{Value: nput, Ty: ty.ValNodeActionUpdate}
+	nput := &vty.ValNodeAction_Node{Node: &vty.ValNode{PubKey: pubkeybyte, Power: int64(2)}}
+	action := &vty.ValNodeAction{Value: nput, Ty: vty.ValNodeActionUpdate}
 	tx := &types.Transaction{Execer: []byte("valnode"), Payload: types.Encode(action), Fee: fee}
 	tx.To = address.ExecAddress("valnode")
-	tx.Nonce = random.Int63()
+	tx.Nonce = r.Int63()
 	tx.Sign(types.SECP256K1, getprivkey("CC38546E9E659D15E6B4893F0AB32A06D103931A8230B0BDE71459D2B27D6944"))
 
 	reply, err := c.SendTransaction(context.Background(), tx)
@@ -217,11 +216,75 @@ func AddNode() {
 }
 
 func CheckState(t *testing.T, client *Client) {
+	state := client.csState.GetState()
+	assert.NotEmpty(t, state)
+	_, curVals := state.GetValidators()
+	assert.NotEmpty(t, curVals)
+	assert.True(t, state.Equals(state.Copy()))
+
+	_, vals := client.csState.GetValidators()
+	assert.Len(t, vals, 1)
+
+	storeHeight := client.csStore.LoadStateHeight()
+	assert.True(t, storeHeight > 0)
+
+	sc := client.csState.LoadCommit(storeHeight)
+	assert.NotEmpty(t, sc)
+	bc := client.csState.LoadCommit(storeHeight - 1)
+	assert.NotEmpty(t, bc)
+
+	assert.NotEmpty(t, client.LoadBlockState(storeHeight))
+	assert.NotEmpty(t, client.LoadProposalBlock(storeHeight))
+
+	assert.Nil(t, client.LoadBlockCommit(0))
+	assert.Nil(t, client.LoadBlockState(0))
+	assert.Nil(t, client.LoadProposalBlock(0))
+
+	csdb := client.csState.blockExec.db
+	assert.NotEmpty(t, csdb)
+	assert.NotEmpty(t, csdb.LoadState())
+	valset, err := csdb.LoadValidators(storeHeight - 1)
+	assert.Nil(t, err)
+	assert.NotEmpty(t, valset)
+
+	genState, err := MakeGenesisStateFromFile("genesis.json")
+	assert.Nil(t, err)
+	assert.Equal(t, genState.LastBlockHeight, int64(0))
+
+	assert.Equal(t, client.csState.Prevote(0), 1000*time.Millisecond)
+	assert.Equal(t, client.csState.Precommit(0), 1000*time.Millisecond)
+	assert.Equal(t, client.csState.PeerGossipSleep(), 100*time.Millisecond)
+	assert.Equal(t, client.csState.PeerQueryMaj23Sleep(), 2000*time.Millisecond)
+	assert.Equal(t, client.csState.IsProposer(), true)
+	assert.Nil(t, client.csState.GetPrevotesState(state.LastBlockHeight, 0, nil))
+	assert.Nil(t, client.csState.GetPrecommitsState(state.LastBlockHeight, 0, nil))
+
+	assert.NotEmpty(t, client.PrivValidator())
+	assert.Len(t, client.GenesisDoc().Validators, 1)
+
 	msg1, err := client.Query_IsHealthy(&types.ReqNil{})
 	assert.Nil(t, err)
-	flag := msg1.(*ty.IsHealthy).IsHealthy
+	flag := msg1.(*vty.IsHealthy).IsHealthy
 	assert.Equal(t, true, flag)
 
-	_, err = client.Query_NodeInfo(&types.ReqNil{})
+	msg2, err := client.Query_NodeInfo(&types.ReqNil{})
 	assert.Nil(t, err)
+	tvals := msg2.(*vty.ValidatorSet).Validators
+	assert.Len(t, tvals, 1)
+
+	err = client.CommitBlock(client.GetCurrentBlock())
+	assert.Nil(t, err)
+}
+
+func TestCompareHRS(t *testing.T) {
+	assert.Equal(t, CompareHRS(1, 1, ty.RoundStepNewHeight, 1, 1, ty.RoundStepNewHeight), 0)
+
+	assert.Equal(t, CompareHRS(1, 1, ty.RoundStepPrevote, 2, 1, ty.RoundStepNewHeight), -1)
+	assert.Equal(t, CompareHRS(1, 1, ty.RoundStepPrevote, 1, 2, ty.RoundStepNewHeight), -1)
+	assert.Equal(t, CompareHRS(1, 1, ty.RoundStepPrevote, 1, 1, ty.RoundStepPrecommit), -1)
+
+	assert.Equal(t, CompareHRS(2, 1, ty.RoundStepNewHeight, 1, 1, ty.RoundStepPrevote), 1)
+	assert.Equal(t, CompareHRS(1, 2, ty.RoundStepNewHeight, 1, 1, ty.RoundStepPrevote), 1)
+	assert.Equal(t, CompareHRS(1, 1, ty.RoundStepPrecommit, 1, 1, ty.RoundStepPrevote), 1)
+	fmt.Println("TestCompareHRS ok")
 }

plugin/consensus/tendermint/types/errors.go

@@ -7,6 +7,8 @@ package types
 import "errors"
 
 var (
+	// ErrHeightLessThanOne error type
+	ErrHeightLessThanOne = errors.New("ErrHeightLessThanOne")
 	// ErrBaseTxType error type
 	ErrBaseTxType = errors.New("ErrBaseTxType")
 	// ErrBlockInfoTx error type

plugin/consensus/tendermint/types/round_state.go

@@ -32,17 +32,16 @@ const (
 	RoundStepCommit        = RoundStepType(0x08) // Entered commit state machine
 	// NOTE: RoundStepNewHeight acts as RoundStepCommitWait.
 
-	NewRoundStepID      = byte(0x02)
-	CommitStepID        = byte(0x03)
-	ProposalID          = byte(0x04)
-	ProposalPOLID       = byte(0x05)
-	VoteID              = byte(0x06)
-	HasVoteID           = byte(0x07)
-	VoteSetMaj23ID      = byte(0x08)
-	VoteSetBitsID       = byte(0x09)
-	ProposalHeartbeatID = byte(0x0a)
-	ProposalBlockID     = byte(0x0b)
-	ValidBlockID        = byte(0x0c)
+	NewRoundStepID      = byte(0x01)
+	ProposalID          = byte(0x02)
+	ProposalPOLID       = byte(0x03)
+	VoteID              = byte(0x04)
+	HasVoteID           = byte(0x05)
+	VoteSetMaj23ID      = byte(0x06)
+	VoteSetBitsID       = byte(0x07)
+	ProposalHeartbeatID = byte(0x08)
+	ProposalBlockID     = byte(0x09)
+	ValidBlockID        = byte(0x0a)
 
 	PacketTypePing = byte(0xff)
 	PacketTypePong = byte(0xfe)
@@ -52,7 +51,6 @@ const (
 func InitMessageMap() {
 	MsgMap = map[byte]reflect.Type{
 		NewRoundStepID:      reflect.TypeOf(tmtypes.NewRoundStepMsg{}),
-		CommitStepID:        reflect.TypeOf(tmtypes.CommitStepMsg{}),
 		ProposalID:          reflect.TypeOf(tmtypes.Proposal{}),
 		ProposalPOLID:       reflect.TypeOf(tmtypes.ProposalPOLMsg{}),
 		VoteID:              reflect.TypeOf(tmtypes.Vote{}),

plugin/dapp/valnode/proto/tendermint.proto

@@ -135,10 +135,6 @@ message ValidBlockMsg {
     bool isCommit   = 4;
 }
 
-message CommitStepMsg {
-    int64 height = 1;
-}
-
 message ProposalPOLMsg {
     int64              height           = 1;
     int32              proposalPOLRound = 2;

plugin/dapp/valnode/types/tendermint.pb.go

@@ -5,12 +5,9 @@ package types
 
 import (
 	fmt "fmt"
-
+	types "github.com/33cn/chain33/types"
 	proto "github.com/golang/protobuf/proto"
-
 	math "math"
-
-	types "github.com/33cn/chain33/types"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -22,7 +19,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type BlockID struct {
 	Hash                 []byte   `protobuf:"bytes,1,opt,name=Hash,proto3" json:"Hash,omitempty"`
@@ -35,16 +32,17 @@ func (m *BlockID) Reset()         { *m = BlockID{} }
 func (m *BlockID) String() string { return proto.CompactTextString(m) }
 func (*BlockID) ProtoMessage()    {}
 func (*BlockID) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{0}
+	return fileDescriptor_04f926c8da23c367, []int{0}
 }
+
 func (m *BlockID) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BlockID.Unmarshal(m, b)
 }
 func (m *BlockID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_BlockID.Marshal(b, m, deterministic)
 }
-func (dst *BlockID) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BlockID.Merge(dst, src)
+func (m *BlockID) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlockID.Merge(m, src)
 }
 func (m *BlockID) XXX_Size() int {
 	return xxx_messageInfo_BlockID.Size(m)
@@ -74,16 +72,17 @@ func (m *TendermintBitArray) Reset()         { *m = TendermintBitArray{} }
 func (m *TendermintBitArray) String() string { return proto.CompactTextString(m) }
 func (*TendermintBitArray) ProtoMessage()    {}
 func (*TendermintBitArray) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{1}
+	return fileDescriptor_04f926c8da23c367, []int{1}
 }
+
 func (m *TendermintBitArray) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TendermintBitArray.Unmarshal(m, b)
 }
 func (m *TendermintBitArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_TendermintBitArray.Marshal(b, m, deterministic)
 }
-func (dst *TendermintBitArray) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TendermintBitArray.Merge(dst, src)
+func (m *TendermintBitArray) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TendermintBitArray.Merge(m, src)
 }
 func (m *TendermintBitArray) XXX_Size() int {
 	return xxx_messageInfo_TendermintBitArray.Size(m)
@@ -126,16 +125,17 @@ func (m *Vote) Reset()         { *m = Vote{} }
 func (m *Vote) String() string { return proto.CompactTextString(m) }
 func (*Vote) ProtoMessage()    {}
 func (*Vote) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{2}
+	return fileDescriptor_04f926c8da23c367, []int{2}
 }
+
 func (m *Vote) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Vote.Unmarshal(m, b)
 }
 func (m *Vote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Vote.Marshal(b, m, deterministic)
 }
-func (dst *Vote) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Vote.Merge(dst, src)
+func (m *Vote) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Vote.Merge(m, src)
 }
 func (m *Vote) XXX_Size() int {
 	return xxx_messageInfo_Vote.Size(m)
@@ -214,16 +214,17 @@ func (m *TendermintCommit) Reset()         { *m = TendermintCommit{} }
 func (m *TendermintCommit) String() string { return proto.CompactTextString(m) }
 func (*TendermintCommit) ProtoMessage()    {}
 func (*TendermintCommit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{3}
+	return fileDescriptor_04f926c8da23c367, []int{3}
 }
+
 func (m *TendermintCommit) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TendermintCommit.Unmarshal(m, b)
 }
 func (m *TendermintCommit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_TendermintCommit.Marshal(b, m, deterministic)
 }
-func (dst *TendermintCommit) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TendermintCommit.Merge(dst, src)
+func (m *TendermintCommit) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TendermintCommit.Merge(m, src)
 }
 func (m *TendermintCommit) XXX_Size() int {
 	return xxx_messageInfo_TendermintCommit.Size(m)
@@ -261,16 +262,17 @@ func (m *TendermintBlockInfo) Reset()         { *m = TendermintBlockInfo{} }
 func (m *TendermintBlockInfo) String() string { return proto.CompactTextString(m) }
 func (*TendermintBlockInfo) ProtoMessage()    {}
 func (*TendermintBlockInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{4}
+	return fileDescriptor_04f926c8da23c367, []int{4}
 }
+
 func (m *TendermintBlockInfo) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TendermintBlockInfo.Unmarshal(m, b)
 }
 func (m *TendermintBlockInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_TendermintBlockInfo.Marshal(b, m, deterministic)
 }
-func (dst *TendermintBlockInfo) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TendermintBlockInfo.Merge(dst, src)
+func (m *TendermintBlockInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TendermintBlockInfo.Merge(m, src)
 }
 func (m *TendermintBlockInfo) XXX_Size() int {
 	return xxx_messageInfo_TendermintBlockInfo.Size(m)
@@ -315,16 +317,17 @@ func (m *BlockSize) Reset()         { *m = BlockSize{} }
 func (m *BlockSize) String() string { return proto.CompactTextString(m) }
 func (*BlockSize) ProtoMessage()    {}
 func (*BlockSize) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{5}
+	return fileDescriptor_04f926c8da23c367, []int{5}
 }
+
 func (m *BlockSize) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BlockSize.Unmarshal(m, b)
 }
 func (m *BlockSize) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_BlockSize.Marshal(b, m, deterministic)
 }
-func (dst *BlockSize) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BlockSize.Merge(dst, src)
+func (m *BlockSize) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlockSize.Merge(m, src)
 }
 func (m *BlockSize) XXX_Size() int {
 	return xxx_messageInfo_BlockSize.Size(m)
@@ -368,16 +371,17 @@ func (m *TxSize) Reset()         { *m = TxSize{} }
 func (m *TxSize) String() string { return proto.CompactTextString(m) }
 func (*TxSize) ProtoMessage()    {}
 func (*TxSize) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{6}
+	return fileDescriptor_04f926c8da23c367, []int{6}
 }
+
 func (m *TxSize) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TxSize.Unmarshal(m, b)
 }
 func (m *TxSize) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_TxSize.Marshal(b, m, deterministic)
 }
-func (dst *TxSize) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TxSize.Merge(dst, src)
+func (m *TxSize) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TxSize.Merge(m, src)
 }
 func (m *TxSize) XXX_Size() int {
 	return xxx_messageInfo_TxSize.Size(m)
@@ -413,16 +417,17 @@ func (m *BlockGossip) Reset()         { *m = BlockGossip{} }
 func (m *BlockGossip) String() string { return proto.CompactTextString(m) }
 func (*BlockGossip) ProtoMessage()    {}
 func (*BlockGossip) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{7}
+	return fileDescriptor_04f926c8da23c367, []int{7}
 }
+
 func (m *BlockGossip) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BlockGossip.Unmarshal(m, b)
 }
 func (m *BlockGossip) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_BlockGossip.Marshal(b, m, deterministic)
 }
-func (dst *BlockGossip) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BlockGossip.Merge(dst, src)
+func (m *BlockGossip) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlockGossip.Merge(m, src)
 }
 func (m *BlockGossip) XXX_Size() int {
 	return xxx_messageInfo_BlockGossip.Size(m)
@@ -451,16 +456,17 @@ func (m *EvidenceParams) Reset()         { *m = EvidenceParams{} }
 func (m *EvidenceParams) String() string { return proto.CompactTextString(m) }
 func (*EvidenceParams) ProtoMessage()    {}
 func (*EvidenceParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{8}
+	return fileDescriptor_04f926c8da23c367, []int{8}
 }
+
 func (m *EvidenceParams) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_EvidenceParams.Unmarshal(m, b)
 }
 func (m *EvidenceParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_EvidenceParams.Marshal(b, m, deterministic)
 }
-func (dst *EvidenceParams) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EvidenceParams.Merge(dst, src)
+func (m *EvidenceParams) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EvidenceParams.Merge(m, src)
 }
 func (m *EvidenceParams) XXX_Size() int {
 	return xxx_messageInfo_EvidenceParams.Size(m)
@@ -492,16 +498,17 @@ func (m *ConsensusParams) Reset()         { *m = ConsensusParams{} }
 func (m *ConsensusParams) String() string { return proto.CompactTextString(m) }
 func (*ConsensusParams) ProtoMessage()    {}
 func (*ConsensusParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{9}
+	return fileDescriptor_04f926c8da23c367, []int{9}
 }
+
 func (m *ConsensusParams) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ConsensusParams.Unmarshal(m, b)
 }
 func (m *ConsensusParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ConsensusParams.Marshal(b, m, deterministic)
 }
-func (dst *ConsensusParams) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ConsensusParams.Merge(dst, src)
+func (m *ConsensusParams) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ConsensusParams.Merge(m, src)
 }
 func (m *ConsensusParams) XXX_Size() int {
 	return xxx_messageInfo_ConsensusParams.Size(m)
@@ -554,16 +561,17 @@ func (m *Validator) Reset()         { *m = Validator{} }
 func (m *Validator) String() string { return proto.CompactTextString(m) }
 func (*Validator) ProtoMessage()    {}
 func (*Validator) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{10}
+	return fileDescriptor_04f926c8da23c367, []int{10}
 }
+
 func (m *Validator) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Validator.Unmarshal(m, b)
 }
 func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Validator.Marshal(b, m, deterministic)
 }
-func (dst *Validator) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Validator.Merge(dst, src)
+func (m *Validator) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Validator.Merge(m, src)
 }
 func (m *Validator) XXX_Size() int {
 	return xxx_messageInfo_Validator.Size(m)
@@ -614,16 +622,17 @@ func (m *ValidatorSet) Reset()         { *m = ValidatorSet{} }
 func (m *ValidatorSet) String() string { return proto.CompactTextString(m) }
 func (*ValidatorSet) ProtoMessage()    {}
 func (*ValidatorSet) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{11}
+	return fileDescriptor_04f926c8da23c367, []int{11}
 }
+
 func (m *ValidatorSet) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ValidatorSet.Unmarshal(m, b)
 }
 func (m *ValidatorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ValidatorSet.Marshal(b, m, deterministic)
 }
-func (dst *ValidatorSet) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ValidatorSet.Merge(dst, src)
+func (m *ValidatorSet) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ValidatorSet.Merge(m, src)
 }
 func (m *ValidatorSet) XXX_Size() int {
 	return xxx_messageInfo_ValidatorSet.Size(m)
@@ -670,16 +679,17 @@ func (m *State) Reset()         { *m = State{} }
 func (m *State) String() string { return proto.CompactTextString(m) }
 func (*State) ProtoMessage()    {}
 func (*State) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{12}
+	return fileDescriptor_04f926c8da23c367, []int{12}
 }
+
 func (m *State) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_State.Unmarshal(m, b)
 }
 func (m *State) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_State.Marshal(b, m, deterministic)
 }
-func (dst *State) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_State.Merge(dst, src)
+func (m *State) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_State.Merge(m, src)
 }
 func (m *State) XXX_Size() int {
 	return xxx_messageInfo_State.Size(m)
@@ -797,16 +807,17 @@ func (m *TendermintBlockHeader) Reset()         { *m = TendermintBlockHeader{} }
 func (m *TendermintBlockHeader) String() string { return proto.CompactTextString(m) }
 func (*TendermintBlockHeader) ProtoMessage()    {}
 func (*TendermintBlockHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{13}
+	return fileDescriptor_04f926c8da23c367, []int{13}
 }
+
 func (m *TendermintBlockHeader) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TendermintBlockHeader.Unmarshal(m, b)
 }
 func (m *TendermintBlockHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_TendermintBlockHeader.Marshal(b, m, deterministic)
 }
-func (dst *TendermintBlockHeader) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TendermintBlockHeader.Merge(dst, src)
+func (m *TendermintBlockHeader) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TendermintBlockHeader.Merge(m, src)
 }
 func (m *TendermintBlockHeader) XXX_Size() int {
 	return xxx_messageInfo_TendermintBlockHeader.Size(m)
@@ -921,16 +932,17 @@ func (m *TendermintBlock) Reset()         { *m = TendermintBlock{} }
 func (m *TendermintBlock) String() string { return proto.CompactTextString(m) }
 func (*TendermintBlock) ProtoMessage()    {}
 func (*TendermintBlock) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{14}
+	return fileDescriptor_04f926c8da23c367, []int{14}
 }
+
 func (m *TendermintBlock) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TendermintBlock.Unmarshal(m, b)
 }
 func (m *TendermintBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_TendermintBlock.Marshal(b, m, deterministic)
 }
-func (dst *TendermintBlock) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TendermintBlock.Merge(dst, src)
+func (m *TendermintBlock) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TendermintBlock.Merge(m, src)
 }
 func (m *TendermintBlock) XXX_Size() int {
 	return xxx_messageInfo_TendermintBlock.Size(m)
@@ -979,16 +991,17 @@ func (m *Proposal) Reset()         { *m = Proposal{} }
 func (m *Proposal) String() string { return proto.CompactTextString(m) }
 func (*Proposal) ProtoMessage()    {}
 func (*Proposal) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{15}
+	return fileDescriptor_04f926c8da23c367, []int{15}
 }
+
 func (m *Proposal) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Proposal.Unmarshal(m, b)
 }
 func (m *Proposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Proposal.Marshal(b, m, deterministic)
 }
-func (dst *Proposal) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Proposal.Merge(dst, src)
+func (m *Proposal) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Proposal.Merge(m, src)
 }
 func (m *Proposal) XXX_Size() int {
 	return xxx_messageInfo_Proposal.Size(m)
@@ -1063,16 +1076,17 @@ func (m *NewRoundStepMsg) Reset()         { *m = NewRoundStepMsg{} }
 func (m *NewRoundStepMsg) String() string { return proto.CompactTextString(m) }
 func (*NewRoundStepMsg) ProtoMessage()    {}
 func (*NewRoundStepMsg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{16}
+	return fileDescriptor_04f926c8da23c367, []int{16}
 }
+
 func (m *NewRoundStepMsg) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_NewRoundStepMsg.Unmarshal(m, b)
 }
 func (m *NewRoundStepMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_NewRoundStepMsg.Marshal(b, m, deterministic)
 }
-func (dst *NewRoundStepMsg) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NewRoundStepMsg.Merge(dst, src)
+func (m *NewRoundStepMsg) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NewRoundStepMsg.Merge(m, src)
 }
 func (m *NewRoundStepMsg) XXX_Size() int {
 	return xxx_messageInfo_NewRoundStepMsg.Size(m)
@@ -1132,16 +1146,17 @@ func (m *ValidBlockMsg) Reset()         { *m = ValidBlockMsg{} }
 func (m *ValidBlockMsg) String() string { return proto.CompactTextString(m) }
 func (*ValidBlockMsg) ProtoMessage()    {}
 func (*ValidBlockMsg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{17}
+	return fileDescriptor_04f926c8da23c367, []int{17}
 }
+
 func (m *ValidBlockMsg) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ValidBlockMsg.Unmarshal(m, b)
 }
 func (m *ValidBlockMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ValidBlockMsg.Marshal(b, m, deterministic)
 }
-func (dst *ValidBlockMsg) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ValidBlockMsg.Merge(dst, src)
+func (m *ValidBlockMsg) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ValidBlockMsg.Merge(m, src)
 }
 func (m *ValidBlockMsg) XXX_Size() int {
 	return xxx_messageInfo_ValidBlockMsg.Size(m)
@@ -1180,44 +1195,6 @@ func (m *ValidBlockMsg) GetIsCommit() bool {
 	return false
 }
 
-type CommitStepMsg struct {
-	Height               int64    `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *CommitStepMsg) Reset()         { *m = CommitStepMsg{} }
-func (m *CommitStepMsg) String() string { return proto.CompactTextString(m) }
-func (*CommitStepMsg) ProtoMessage()    {}
-func (*CommitStepMsg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{18}
-}
-func (m *CommitStepMsg) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CommitStepMsg.Unmarshal(m, b)
-}
-func (m *CommitStepMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CommitStepMsg.Marshal(b, m, deterministic)
-}
-func (dst *CommitStepMsg) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CommitStepMsg.Merge(dst, src)
-}
-func (m *CommitStepMsg) XXX_Size() int {
-	return xxx_messageInfo_CommitStepMsg.Size(m)
-}
-func (m *CommitStepMsg) XXX_DiscardUnknown() {
-	xxx_messageInfo_CommitStepMsg.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CommitStepMsg proto.InternalMessageInfo
-
-func (m *CommitStepMsg) GetHeight() int64 {
-	if m != nil {
-		return m.Height
-	}
-	return 0
-}
-
 type ProposalPOLMsg struct {
 	Height               int64               `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
 	ProposalPOLRound     int32               `protobuf:"varint,2,opt,name=proposalPOLRound,proto3" json:"proposalPOLRound,omitempty"`
@@ -1231,16 +1208,17 @@ func (m *ProposalPOLMsg) Reset()         { *m = ProposalPOLMsg{} }
 func (m *ProposalPOLMsg) String() string { return proto.CompactTextString(m) }
 func (*ProposalPOLMsg) ProtoMessage()    {}
 func (*ProposalPOLMsg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{19}
+	return fileDescriptor_04f926c8da23c367, []int{18}
 }
+
 func (m *ProposalPOLMsg) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ProposalPOLMsg.Unmarshal(m, b)
 }
 func (m *ProposalPOLMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ProposalPOLMsg.Marshal(b, m, deterministic)
 }
-func (dst *ProposalPOLMsg) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ProposalPOLMsg.Merge(dst, src)
+func (m *ProposalPOLMsg) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ProposalPOLMsg.Merge(m, src)
 }
 func (m *ProposalPOLMsg) XXX_Size() int {
 	return xxx_messageInfo_ProposalPOLMsg.Size(m)
@@ -1286,16 +1264,17 @@ func (m *HasVoteMsg) Reset()         { *m = HasVoteMsg{} }
 func (m *HasVoteMsg) String() string { return proto.CompactTextString(m) }
 func (*HasVoteMsg) ProtoMessage()    {}
 func (*HasVoteMsg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{20}
+	return fileDescriptor_04f926c8da23c367, []int{19}
 }
+
 func (m *HasVoteMsg) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_HasVoteMsg.Unmarshal(m, b)
 }
 func (m *HasVoteMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_HasVoteMsg.Marshal(b, m, deterministic)
 }
-func (dst *HasVoteMsg) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_HasVoteMsg.Merge(dst, src)
+func (m *HasVoteMsg) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_HasVoteMsg.Merge(m, src)
 }
 func (m *HasVoteMsg) XXX_Size() int {
 	return xxx_messageInfo_HasVoteMsg.Size(m)
@@ -1348,16 +1327,17 @@ func (m *VoteSetMaj23Msg) Reset()         { *m = VoteSetMaj23Msg{} }
 func (m *VoteSetMaj23Msg) String() string { return proto.CompactTextString(m) }
 func (*VoteSetMaj23Msg) ProtoMessage()    {}
 func (*VoteSetMaj23Msg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{21}
+	return fileDescriptor_04f926c8da23c367, []int{20}
 }
+
 func (m *VoteSetMaj23Msg) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_VoteSetMaj23Msg.Unmarshal(m, b)
 }
 func (m *VoteSetMaj23Msg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_VoteSetMaj23Msg.Marshal(b, m, deterministic)
 }
-func (dst *VoteSetMaj23Msg) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VoteSetMaj23Msg.Merge(dst, src)
+func (m *VoteSetMaj23Msg) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VoteSetMaj23Msg.Merge(m, src)
 }
 func (m *VoteSetMaj23Msg) XXX_Size() int {
 	return xxx_messageInfo_VoteSetMaj23Msg.Size(m)
@@ -1411,16 +1391,17 @@ func (m *VoteSetBitsMsg) Reset()         { *m = VoteSetBitsMsg{} }
 func (m *VoteSetBitsMsg) String() string { return proto.CompactTextString(m) }
 func (*VoteSetBitsMsg) ProtoMessage()    {}
 func (*VoteSetBitsMsg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{22}
+	return fileDescriptor_04f926c8da23c367, []int{21}
 }
+
 func (m *VoteSetBitsMsg) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_VoteSetBitsMsg.Unmarshal(m, b)
 }
 func (m *VoteSetBitsMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_VoteSetBitsMsg.Marshal(b, m, deterministic)
 }
-func (dst *VoteSetBitsMsg) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VoteSetBitsMsg.Merge(dst, src)
+func (m *VoteSetBitsMsg) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VoteSetBitsMsg.Merge(m, src)
 }
 func (m *VoteSetBitsMsg) XXX_Size() int {
 	return xxx_messageInfo_VoteSetBitsMsg.Size(m)
@@ -1482,16 +1463,17 @@ func (m *Heartbeat) Reset()         { *m = Heartbeat{} }
 func (m *Heartbeat) String() string { return proto.CompactTextString(m) }
 func (*Heartbeat) ProtoMessage()    {}
 func (*Heartbeat) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{23}
+	return fileDescriptor_04f926c8da23c367, []int{22}
 }
+
 func (m *Heartbeat) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Heartbeat.Unmarshal(m, b)
 }
 func (m *Heartbeat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Heartbeat.Marshal(b, m, deterministic)
 }
-func (dst *Heartbeat) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Heartbeat.Merge(dst, src)
+func (m *Heartbeat) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Heartbeat.Merge(m, src)
 }
 func (m *Heartbeat) XXX_Size() int {
 	return xxx_messageInfo_Heartbeat.Size(m)
@@ -1555,16 +1537,17 @@ func (m *IsHealthy) Reset()         { *m = IsHealthy{} }
 func (m *IsHealthy) String() string { return proto.CompactTextString(m) }
 func (*IsHealthy) ProtoMessage()    {}
 func (*IsHealthy) Descriptor() ([]byte, []int) {
-	return fileDescriptor_tendermint_df861948ed10449a, []int{24}
+	return fileDescriptor_04f926c8da23c367, []int{23}
 }
+
 func (m *IsHealthy) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_IsHealthy.Unmarshal(m, b)
 }
 func (m *IsHealthy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_IsHealthy.Marshal(b, m, deterministic)
 }
-func (dst *IsHealthy) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_IsHealthy.Merge(dst, src)
+func (m *IsHealthy) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IsHealthy.Merge(m, src)
 }
 func (m *IsHealthy) XXX_Size() int {
 	return xxx_messageInfo_IsHealthy.Size(m)
@@ -1601,7 +1584,6 @@ func init() {
 	proto.RegisterType((*Proposal)(nil), "types.Proposal")
 	proto.RegisterType((*NewRoundStepMsg)(nil), "types.NewRoundStepMsg")
 	proto.RegisterType((*ValidBlockMsg)(nil), "types.ValidBlockMsg")
-	proto.RegisterType((*CommitStepMsg)(nil), "types.CommitStepMsg")
 	proto.RegisterType((*ProposalPOLMsg)(nil), "types.ProposalPOLMsg")
 	proto.RegisterType((*HasVoteMsg)(nil), "types.HasVoteMsg")
 	proto.RegisterType((*VoteSetMaj23Msg)(nil), "types.VoteSetMaj23Msg")
@@ -1610,92 +1592,92 @@ func init() {
 	proto.RegisterType((*IsHealthy)(nil), "types.IsHealthy")
 }
 
-func init() { proto.RegisterFile("tendermint.proto", fileDescriptor_tendermint_df861948ed10449a) }
-
-var fileDescriptor_tendermint_df861948ed10449a = []byte{
-	// 1339 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0xdd, 0x6e, 0x1b, 0x45,
-	0x14, 0xd6, 0xc6, 0x3f, 0x89, 0x8f, 0xf3, 0xa7, 0x29, 0x2d, 0xa6, 0x04, 0xc9, 0x1a, 0xf1, 0x63,
-	0xda, 0x2a, 0x54, 0x69, 0x25, 0x2e, 0x4a, 0x51, 0x93, 0xb4, 0x6a, 0x02, 0x09, 0xb5, 0xc6, 0x56,
-	0xb9, 0x9e, 0xd8, 0x83, 0xbd, 0x60, 0xef, 0x9a, 0x9d, 0xb1, 0x1b, 0x23, 0x71, 0xc3, 0x1b, 0x20,
-	0xf1, 0x04, 0xdc, 0x73, 0xc5, 0x05, 0x8f, 0xc0, 0x13, 0x70, 0x09, 0xcf, 0x82, 0xce, 0x99, 0xd9,
-	0xf5, 0xec, 0xda, 0x4d, 0x29, 0x42, 0xdc, 0xed, 0xf9, 0xce, 0x37, 0x73, 0xf6, 0xfc, 0xce, 0x0c,
-	0xec, 0x1a, 0x15, 0xf5, 0x55, 0x32, 0x0e, 0x23, 0xb3, 0x3f, 0x49, 0x62, 0x13, 0xb3, 0x8a, 0x99,
-	0x4f, 0x94, 0xbe, 0xb9, 0x7b, 0x31, 0x8a, 0x7b, 0xdf, 0xf4, 0x86, 0x32, 0x8c, 0xac, 0x82, 0xbf,
-	0x03, 0xeb, 0x47, 0x88, 0x9d, 0x3e, 0x66, 0x0c, 0xca, 0x27, 0x52, 0x0f, 0x1b, 0x41, 0x33, 0x68,
-	0x6d, 0x0a, 0xfa, 0xe6, 0x9f, 0x02, 0xeb, 0x66, 0x7b, 0x1d, 0x85, 0xe6, 0x30, 0x49, 0xe4, 0x1c,
-	0x99, 0x47, 0xa1, 0xd1, 0xc4, 0xac, 0x08, 0xfa, 0x66, 0x6f, 0x40, 0xe5, 0xc9, 0x48, 0x8d, 0x75,
-	0x63, 0xad, 0x59, 0x6a, 0x95, 0x85, 0x15, 0xf8, 0x0f, 0x6b, 0x50, 0x7e, 0x1e, 0x1b, 0xc5, 0x6e,
-	0xc1, 0xee, 0x73, 0x39, 0x0a, 0xfb, 0xd2, 0xc4, 0xc9, 0x61, 0xbf, 0x9f, 0x28, 0xad, 0x9d, 0xa1,
-	0x25, 0x9c, 0xbd, 0x0f, 0xdb, 0x19, 0x76, 0x1a, 0xf5, 0xd5, 0x65, 0x63, 0x8d, 0x0c, 0x15, 0x50,
-	0x76, 0x03, 0xaa, 0x27, 0x2a, 0x1c, 0x0c, 0x4d, 0xa3, 0xd4, 0x0c, 0x5a, 0x25, 0xe1, 0x24, 0xfc,
-	0x15, 0x11, 0x4f, 0xa3, 0x7e, 0xa3, 0x4c, 0xcb, 0xac, 0xc0, 0xf6, 0xa0, 0xd6, 0x0d, 0xc7, 0x4a,
-	0x1b, 0x39, 0x9e, 0x34, 0x2a, 0xb4, 0x60, 0x01, 0xa0, 0x4b, 0xdd, 0xf9, 0x44, 0x35, 0xaa, 0xcd,
-	0xa0, 0xb5, 0x25, 0xe8, 0x9b, 0xb5, 0xb2, 0xd8, 0x34, 0xd6, 0x9b, 0x41, 0xab, 0x7e, 0xb0, 0xbd,
-	0x4f, 0x61, 0xdc, 0x77, 0xa8, 0xc8, 0x42, 0xb7, 0x07, 0xb5, 0x4e, 0x38, 0x88, 0xa4, 0x99, 0x26,
-	0xaa, 0xb1, 0x41, 0x6e, 0x2d, 0x00, 0x1e, 0xc2, 0xee, 0x22, 0x88, 0xc7, 0xf1, 0x78, 0x1c, 0x1a,
-	0x7f, 0xef, 0xe0, 0xea, 0xbd, 0x6f, 0x03, 0xb4, 0x13, 0xd5, 0xa3, 0x65, 0x36, 0xba, 0xf5, 0x83,
-	0xba, 0x23, 0x63, 0x68, 0x85, 0xa7, 0xe6, 0x3f, 0x05, 0x70, 0xcd, 0x4b, 0x18, 0x6d, 0x11, 0x7d,
-	0x15, 0x33, 0x0e, 0x95, 0x8e, 0x91, 0x46, 0x51, 0x24, 0xeb, 0x07, 0x9b, 0x6e, 0x3d, 0x61, 0xc2,
-	0xaa, 0xd8, 0x6d, 0xd8, 0x68, 0x27, 0xf1, 0x24, 0xd6, 0x72, 0x44, 0x01, 0xad, 0x1f, 0xec, 0x38,
-	0x5a, 0x0a, 0x8b, 0x8c, 0xc0, 0xee, 0x40, 0x85, 0x6a, 0x89, 0x62, 0x5c, 0x3f, 0xb8, 0xe1, 0x98,
-	0x05, 0xdb, 0xc2, 0x92, 0xf8, 0x97, 0x50, 0x23, 0xb9, 0x13, 0x7e, 0xa7, 0xd8, 0x4d, 0xd8, 0x38,
-	0x97, 0x97, 0x47, 0x73, 0xa3, 0xd2, 0x0a, 0xca, 0x64, 0x4c, 0xe9, 0xb9, 0xbc, 0xec, 0x5e, 0x6a,
-	0x97, 0x72, 0x27, 0x39, 0xfc, 0xa9, 0xd4, 0x69, 0xaa, 0xad, 0xc4, 0x3f, 0x81, 0x6a, 0xf7, 0xf2,
-	0x1f, 0xee, 0x8a, 0xab, 0xd7, 0x72, 0xab, 0x1f, 0x42, 0x9d, 0x7e, 0xeb, 0x69, 0xac, 0x75, 0x38,
-	0x61, 0xfb, 0xc0, 0x48, 0x6c, 0xcb, 0xc4, 0xe0, 0x9e, 0xfe, 0x66, 0x2b, 0x34, 0xbc, 0x05, 0xdb,
-	0x4f, 0x66, 0x61, 0x5f, 0x45, 0x3d, 0xd5, 0x96, 0x89, 0x1c, 0xa7, 0x86, 0x0e, 0x07, 0x8a, 0x56,
-	0x59, 0x43, 0x87, 0x03, 0xc5, 0xff, 0x0c, 0x60, 0xe7, 0x38, 0x8e, 0xb4, 0x8a, 0xf4, 0x54, 0x3b,
-	0xee, 0xbe, 0x17, 0x13, 0x57, 0x03, 0xbb, 0x7e, 0x0d, 0x20, 0x2e, 0xbc, 0xb0, 0xbd, 0x97, 0xba,
-	0xea, 0x72, 0xb8, 0x95, 0x86, 0x9c, 0x40, 0x91, 0xc6, 0xe1, 0x7e, 0xce, 0x27, 0x97, 0x48, 0xe6,
-	0x6f, 0x6c, 0x35, 0x22, 0xe7, 0xfa, 0xc3, 0xa2, 0x2b, 0x2e, 0xaf, 0xd7, 0xdd, 0xc2, 0xbc, 0x52,
-	0x14, 0xc8, 0x7c, 0x0a, 0xb5, 0xac, 0x37, 0x59, 0x03, 0xd6, 0xf3, 0x1d, 0x9e, 0x8a, 0x18, 0x9e,
-	0xf6, 0xf4, 0xe2, 0x73, 0x35, 0x27, 0x17, 0x36, 0x85, 0x93, 0x58, 0x13, 0xea, 0xcf, 0x63, 0x13,
-	0x46, 0x83, 0x76, 0xfc, 0x42, 0x25, 0x2e, 0xc5, 0x3e, 0x84, 0x2d, 0x7d, 0xd8, 0xeb, 0x4d, 0xc7,
-	0xf4, 0x5b, 0x25, 0x61, 0x05, 0x1e, 0xc1, 0x66, 0x66, 0xb6, 0xa3, 0x0c, 0xbb, 0x0b, 0x90, 0xc9,
-	0x68, 0xbc, 0xe4, 0xc5, 0x34, 0x53, 0x08, 0x8f, 0xc3, 0xee, 0xa4, 0x35, 0xaf, 0x12, 0x17, 0xd6,
-	0x65, 0x7e, 0xc6, 0xe0, 0x7f, 0x94, 0x5d, 0x1b, 0xa1, 0x8f, 0xc7, 0x38, 0x45, 0x5d, 0xfb, 0xd6,
-	0x44, 0x2a, 0xb2, 0x16, 0xec, 0x9c, 0x49, 0x6d, 0xcb, 0xdf, 0x4d, 0x27, 0x5b, 0x74, 0x45, 0x18,
-	0x47, 0x62, 0x06, 0x75, 0x63, 0x23, 0x47, 0xdd, 0x4b, 0xe7, 0xfa, 0x12, 0xce, 0xee, 0x42, 0x3d,
-	0xc3, 0x4e, 0x1f, 0xbb, 0xe4, 0x14, 0x47, 0x86, 0x4f, 0x61, 0xef, 0xc2, 0xd6, 0x62, 0x97, 0x70,
-	0xac, 0xdc, 0xc8, 0xcb, 0x83, 0xec, 0x5e, 0x2e, 0x62, 0x55, 0xda, 0xf6, 0x5a, 0x31, 0x02, 0x1d,
-	0x65, 0x72, 0x41, 0x7b, 0x00, 0xdb, 0xb8, 0x8b, 0xb7, 0x70, 0xfd, 0xe5, 0x0b, 0x0b, 0x54, 0xf6,
-	0x08, 0xde, 0x46, 0xc4, 0xc6, 0x60, 0x81, 0x1f, 0x0f, 0x65, 0x34, 0x50, 0x7d, 0x1a, 0x9e, 0x25,
-	0x71, 0x15, 0x85, 0x3d, 0x5a, 0xea, 0xa5, 0x46, 0x2d, 0x37, 0x84, 0x0a, 0x5a, 0xb1, 0xd4, 0x7a,
-	0x9f, 0x41, 0x73, 0x61, 0xa0, 0xa0, 0x4c, 0x7f, 0x04, 0xe8, 0x47, 0x5e, 0xc9, 0x4b, 0xf3, 0x2d,
-	0x94, 0x9e, 0x8e, 0x8c, 0xa6, 0x03, 0xb4, 0x4e, 0xc5, 0x5d, 0x84, 0xa9, 0x2f, 0x26, 0x13, 0x62,
-	0x6c, 0xba, 0xbe, 0xb0, 0x22, 0xff, 0xad, 0x04, 0xd7, 0x0b, 0x93, 0xf3, 0x44, 0xc9, 0xbe, 0xa2,
-	0x5e, 0xea, 0xe5, 0xeb, 0xcc, 0x89, 0xd8, 0x4b, 0x43, 0xbf, 0xbc, 0x9c, 0x84, 0x9d, 0x92, 0xd0,
-	0xe1, 0x67, 0x4b, 0xc9, 0x0a, 0x78, 0xbc, 0x19, 0x2c, 0x02, 0xdb, 0x3e, 0xf4, 0x8d, 0x3b, 0x44,
-	0xd3, 0x31, 0xce, 0x5a, 0x5b, 0x1a, 0x4e, 0xc2, 0x5a, 0x1b, 0x79, 0xb5, 0x56, 0x5d, 0x5d, 0x6b,
-	0x1e, 0x05, 0x67, 0xaf, 0xb1, 0x85, 0x6a, 0x4b, 0xa1, 0x24, 0x32, 0x19, 0x0f, 0x73, 0xa4, 0xda,
-	0x63, 0x8f, 0x9c, 0xb7, 0xe7, 0x63, 0x01, 0x45, 0xde, 0x2c, 0x4b, 0x35, 0xf1, 0x6a, 0x96, 0x97,
-	0x47, 0xb1, 0xae, 0x7b, 0x69, 0x26, 0x88, 0x06, 0x44, 0xcb, 0x83, 0x18, 0x37, 0xe9, 0x62, 0x6d,
-	0xb3, 0x91, 0x8a, 0x98, 0xaf, 0x51, 0x21, 0x5f, 0x36, 0x1b, 0x45, 0x98, 0x71, 0xd8, 0x9c, 0xb8,
-	0xce, 0xc7, 0x01, 0xd6, 0xd8, 0x22, 0x5a, 0x0e, 0xe3, 0x3f, 0x07, 0xb0, 0x53, 0xc8, 0x1c, 0xbb,
-	0x8f, 0x99, 0xc1, 0xec, 0xb9, 0xa9, 0xbe, 0xb7, 0xfa, 0x6c, 0xb4, 0x19, 0x16, 0x8e, 0xcb, 0x9a,
-	0x50, 0xee, 0x4b, 0x23, 0x0b, 0x07, 0xb4, 0x3d, 0x45, 0x49, 0xc3, 0x3e, 0x06, 0x58, 0xc4, 0xcc,
-	0x8d, 0x80, 0x37, 0x97, 0xf6, 0xb6, 0x6a, 0xe1, 0x51, 0xf9, 0x5f, 0xc1, 0xe2, 0x64, 0xf7, 0xea,
-	0x26, 0x58, 0x5d, 0x37, 0xf6, 0xe0, 0x75, 0x75, 0xb3, 0x07, 0x35, 0x93, 0x5d, 0x9a, 0x6c, 0x45,
-	0x2d, 0x00, 0xcc, 0x7b, 0xfb, 0xd9, 0x99, 0x7f, 0xd7, 0xca, 0x64, 0xb6, 0x0f, 0xd0, 0x7e, 0x76,
-	0x96, 0x16, 0x51, 0x65, 0x65, 0x11, 0x79, 0x0c, 0xb4, 0xa4, 0xb3, 0x2b, 0x54, 0xd5, 0x5e, 0xa1,
-	0x32, 0x00, 0xb5, 0x74, 0x93, 0x18, 0x62, 0xbe, 0xd6, 0xad, 0x36, 0x03, 0xf8, 0xaf, 0x01, 0xec,
-	0x7c, 0xa1, 0x5e, 0x90, 0xe1, 0x8e, 0x51, 0x93, 0x73, 0x3d, 0x78, 0x4d, 0x3f, 0x19, 0x94, 0xb5,
-	0x51, 0xd6, 0xc5, 0x8a, 0xa0, 0x6f, 0x76, 0x1f, 0xae, 0x6b, 0xd5, 0x8b, 0xa3, 0xbe, 0xee, 0x84,
-	0x51, 0x4f, 0x75, 0x8c, 0x4c, 0x4c, 0x37, 0x6d, 0xa2, 0x8a, 0x58, 0xad, 0x4c, 0xeb, 0xcb, 0xa5,
-	0x81, 0x2c, 0x55, 0x88, 0x5f, 0x84, 0xf9, 0x0b, 0xd8, 0xa2, 0xe1, 0x46, 0x11, 0x78, 0xfd, 0x5f,
-	0xce, 0x85, 0xa4, 0x54, 0x08, 0x09, 0xa6, 0x26, 0xd4, 0x5e, 0xa9, 0x6c, 0x88, 0x4c, 0xe6, 0x1f,
-	0xc0, 0x96, 0xfd, 0x7a, 0x45, 0xac, 0xf8, 0x8f, 0x01, 0x6c, 0xa7, 0x85, 0xd3, 0x7e, 0x76, 0x76,
-	0xd5, 0x3f, 0xde, 0x82, 0xdd, 0xc9, 0x82, 0x29, 0xbc, 0xdf, 0x5d, 0xc2, 0xd9, 0x03, 0xa8, 0x7b,
-	0x98, 0xbb, 0xa2, 0xbc, 0xb5, 0xdc, 0x25, 0xee, 0xb9, 0x21, 0x7c, 0x36, 0xef, 0x03, 0x9c, 0x48,
-	0x8d, 0x17, 0xdf, 0x7f, 0x95, 0x65, 0x34, 0x92, 0x66, 0x19, 0xbf, 0x91, 0x19, 0xd2, 0x1b, 0xc3,
-	0x3d, 0x16, 0x48, 0xe0, 0xdf, 0xc3, 0x0e, 0x9a, 0xe8, 0x28, 0x73, 0x2e, 0xbf, 0x3e, 0xb8, 0xf7,
-	0xdf, 0x98, 0x6a, 0xc1, 0xfa, 0xc5, 0x95, 0x07, 0x78, 0xaa, 0xe6, 0xbf, 0x04, 0xb0, 0xed, 0xec,
-	0xe3, 0xe3, 0xea, 0x7f, 0x36, 0xcf, 0x3e, 0x82, 0xca, 0x2c, 0xc6, 0xbb, 0x6f, 0xe5, 0x55, 0xa9,
-	0xb1, 0x3c, 0xfe, 0x7b, 0x00, 0xb5, 0x13, 0x25, 0x13, 0x73, 0xa1, 0x24, 0xd5, 0xc2, 0xec, 0x25,
-	0x6f, 0xbd, 0xd9, 0x8a, 0xb7, 0xde, 0x6c, 0xe5, 0x5b, 0x6f, 0xb6, 0xf4, 0xd6, 0x1b, 0xe6, 0xde,
-	0x7a, 0x45, 0xf7, 0xcb, 0xbe, 0xfb, 0x37, 0x61, 0x43, 0xab, 0x6f, 0xa7, 0x78, 0x43, 0x75, 0xdd,
-	0x97, 0xc9, 0x57, 0x0f, 0x1a, 0xfe, 0x21, 0xd4, 0x4e, 0xf5, 0x89, 0x92, 0x23, 0x33, 0x9c, 0x23,
-	0x35, 0x4c, 0x05, 0xf2, 0x60, 0x43, 0x2c, 0x80, 0x8b, 0x2a, 0xbd, 0xa0, 0xef, 0xfd, 0x1d, 0x00,
-	0x00, 0xff, 0xff, 0xe7, 0xeb, 0xd6, 0x7a, 0x6e, 0x0f, 0x00, 0x00,
+func init() { proto.RegisterFile("tendermint.proto", fileDescriptor_04f926c8da23c367) }
+
+var fileDescriptor_04f926c8da23c367 = []byte{
+	// 1334 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0xdf, 0x6e, 0x1b, 0xc5,
+	0x17, 0xd6, 0xc6, 0x7f, 0x12, 0x1f, 0xe7, 0x9f, 0xa6, 0xbf, 0xf6, 0x67, 0x4a, 0x90, 0xac, 0x11,
+	0x20, 0xd3, 0x56, 0xa1, 0x4a, 0x2b, 0x71, 0x51, 0x8a, 0x9a, 0xa4, 0x55, 0x13, 0x48, 0xa8, 0x35,
+	0xb6, 0xca, 0xf5, 0xc4, 0x1e, 0xec, 0x05, 0x7b, 0xd7, 0xec, 0x8c, 0x9d, 0x18, 0x89, 0x1b, 0xde,
+	0x00, 0x89, 0x27, 0xe0, 0x9e, 0x2b, 0x2e, 0x78, 0x04, 0x9e, 0x80, 0x4b, 0x78, 0x16, 0x74, 0xce,
+	0xcc, 0xae, 0x67, 0xd7, 0x6e, 0x4a, 0x11, 0xe2, 0x6e, 0xcf, 0x37, 0xdf, 0xcc, 0xd9, 0x39, 0xe7,
+	0x3b, 0x67, 0x66, 0x60, 0xd7, 0xa8, 0xa8, 0xaf, 0x92, 0x71, 0x18, 0x99, 0xfd, 0x49, 0x12, 0x9b,
+	0x98, 0x55, 0xcc, 0x7c, 0xa2, 0xf4, 0xed, 0xdd, 0x8b, 0x51, 0xdc, 0xfb, 0xba, 0x37, 0x94, 0x61,
+	0x64, 0x07, 0xf8, 0x3b, 0xb0, 0x7e, 0x84, 0xd8, 0xe9, 0x53, 0xc6, 0xa0, 0x7c, 0x22, 0xf5, 0xb0,
+	0x11, 0x34, 0x83, 0xd6, 0xa6, 0xa0, 0x6f, 0xfe, 0x09, 0xb0, 0x6e, 0xb6, 0xd6, 0x51, 0x68, 0x0e,
+	0x93, 0x44, 0xce, 0x91, 0x79, 0x14, 0x1a, 0x4d, 0xcc, 0x8a, 0xa0, 0x6f, 0xf6, 0x3f, 0xa8, 0x3c,
+	0x1b, 0xa9, 0xb1, 0x6e, 0xac, 0x35, 0x4b, 0xad, 0xb2, 0xb0, 0x06, 0xff, 0x7e, 0x0d, 0xca, 0x2f,
+	0x63, 0xa3, 0xd8, 0x1d, 0xd8, 0x7d, 0x29, 0x47, 0x61, 0x5f, 0x9a, 0x38, 0x39, 0xec, 0xf7, 0x13,
+	0xa5, 0xb5, 0x73, 0xb4, 0x84, 0xb3, 0xf7, 0x61, 0x3b, 0xc3, 0x4e, 0xa3, 0xbe, 0xba, 0x6a, 0xac,
+	0x91, 0xa3, 0x02, 0xca, 0x6e, 0x41, 0xf5, 0x44, 0x85, 0x83, 0xa1, 0x69, 0x94, 0x9a, 0x41, 0xab,
+	0x24, 0x9c, 0x85, 0xbf, 0x22, 0xe2, 0x69, 0xd4, 0x6f, 0x94, 0x69, 0x9a, 0x35, 0xd8, 0x1e, 0xd4,
+	0xba, 0xe1, 0x58, 0x69, 0x23, 0xc7, 0x93, 0x46, 0x85, 0x26, 0x2c, 0x00, 0xdc, 0x52, 0x77, 0x3e,
+	0x51, 0x8d, 0x6a, 0x33, 0x68, 0x6d, 0x09, 0xfa, 0x66, 0xad, 0x2c, 0x36, 0x8d, 0xf5, 0x66, 0xd0,
+	0xaa, 0x1f, 0x6c, 0xef, 0x53, 0x18, 0xf7, 0x1d, 0x2a, 0xb2, 0xd0, 0xed, 0x41, 0xad, 0x13, 0x0e,
+	0x22, 0x69, 0xa6, 0x89, 0x6a, 0x6c, 0xd0, 0xb6, 0x16, 0x00, 0x0f, 0x61, 0x77, 0x11, 0xc4, 0xe3,
+	0x78, 0x3c, 0x0e, 0x8d, 0xbf, 0x76, 0x70, 0xfd, 0xda, 0x77, 0x01, 0xda, 0x89, 0xea, 0xd1, 0x34,
+	0x1b, 0xdd, 0xfa, 0x41, 0xdd, 0x91, 0x31, 0xb4, 0xc2, 0x1b, 0xe6, 0x3f, 0x06, 0x70, 0xc3, 0x4b,
+	0x18, 0x2d, 0x11, 0x7d, 0x19, 0x33, 0x0e, 0x95, 0x8e, 0x91, 0x46, 0x51, 0x24, 0xeb, 0x07, 0x9b,
+	0x6e, 0x3e, 0x61, 0xc2, 0x0e, 0xb1, 0xbb, 0xb0, 0xd1, 0x4e, 0xe2, 0x49, 0xac, 0xe5, 0x88, 0x02,
+	0x5a, 0x3f, 0xd8, 0x71, 0xb4, 0x14, 0x16, 0x19, 0x81, 0xdd, 0x83, 0x0a, 0x69, 0x89, 0x62, 0x5c,
+	0x3f, 0xb8, 0xe5, 0x98, 0x05, 0xdf, 0xc2, 0x92, 0xf8, 0x17, 0x50, 0x23, 0xbb, 0x13, 0x7e, 0xab,
+	0xd8, 0x6d, 0xd8, 0x38, 0x97, 0x57, 0x47, 0x73, 0xa3, 0x52, 0x05, 0x65, 0x36, 0xa6, 0xf4, 0x5c,
+	0x5e, 0x75, 0xaf, 0xb4, 0x4b, 0xb9, 0xb3, 0x1c, 0xfe, 0x5c, 0xea, 0x34, 0xd5, 0xd6, 0xe2, 0x1f,
+	0x43, 0xb5, 0x7b, 0xf5, 0x37, 0x57, 0xc5, 0xd9, 0x6b, 0xb9, 0xd9, 0x8f, 0xa1, 0x4e, 0xbf, 0xf5,
+	0x3c, 0xd6, 0x3a, 0x9c, 0xb0, 0x7d, 0x60, 0x64, 0xb6, 0x65, 0x62, 0x70, 0x4d, 0x7f, 0xb1, 0x15,
+	0x23, 0xbc, 0x05, 0xdb, 0xcf, 0x66, 0x61, 0x5f, 0x45, 0x3d, 0xd5, 0x96, 0x89, 0x1c, 0xa7, 0x8e,
+	0x0e, 0x07, 0x8a, 0x66, 0x59, 0x47, 0x87, 0x03, 0xc5, 0xff, 0x08, 0x60, 0xe7, 0x38, 0x8e, 0xb4,
+	0x8a, 0xf4, 0x54, 0x3b, 0xee, 0xbe, 0x17, 0x13, 0xa7, 0x81, 0x5d, 0x5f, 0x03, 0x88, 0x0b, 0x2f,
+	0x6c, 0xef, 0xa5, 0x5b, 0x75, 0x39, 0xdc, 0x4a, 0x43, 0x4e, 0xa0, 0x48, 0xe3, 0xf0, 0x30, 0xb7,
+	0x27, 0x97, 0x48, 0xe6, 0x2f, 0x6c, 0x47, 0x44, 0x6e, 0xeb, 0x8f, 0x8b, 0x5b, 0x71, 0x79, 0xbd,
+	0xe9, 0x26, 0xe6, 0x07, 0x45, 0x81, 0xcc, 0xa7, 0x50, 0xcb, 0x6a, 0x93, 0x35, 0x60, 0x3d, 0x5f,
+	0xe1, 0xa9, 0x89, 0xe1, 0x69, 0x4f, 0x2f, 0x3e, 0x53, 0x73, 0xda, 0xc2, 0xa6, 0x70, 0x16, 0x6b,
+	0x42, 0xfd, 0x65, 0x6c, 0xc2, 0x68, 0xd0, 0x8e, 0x2f, 0x55, 0xe2, 0x52, 0xec, 0x43, 0x58, 0xd2,
+	0x87, 0xbd, 0xde, 0x74, 0x4c, 0xbf, 0x55, 0x12, 0xd6, 0xe0, 0x11, 0x6c, 0x66, 0x6e, 0x3b, 0xca,
+	0xb0, 0xfb, 0x00, 0x99, 0x8d, 0xce, 0x4b, 0x5e, 0x4c, 0xb3, 0x01, 0xe1, 0x71, 0xd8, 0xbd, 0x54,
+	0xf3, 0x2a, 0x71, 0x61, 0x5d, 0xe6, 0x67, 0x0c, 0xfe, 0x7b, 0xd9, 0x95, 0x11, 0xee, 0xf1, 0x18,
+	0xbb, 0xa8, 0x2b, 0xdf, 0x9a, 0x48, 0x4d, 0xd6, 0x82, 0x9d, 0x33, 0xa9, 0xad, 0xfc, 0x5d, 0x77,
+	0xb2, 0xa2, 0x2b, 0xc2, 0xd8, 0x12, 0x33, 0xa8, 0x1b, 0x1b, 0x39, 0xea, 0x5e, 0xb9, 0xad, 0x2f,
+	0xe1, 0xec, 0x3e, 0xd4, 0x33, 0xec, 0xf4, 0xa9, 0x4b, 0x4e, 0xb1, 0x65, 0xf8, 0x14, 0xf6, 0x2e,
+	0x6c, 0x2d, 0x56, 0x09, 0xc7, 0xca, 0xb5, 0xbc, 0x3c, 0xc8, 0x1e, 0xe4, 0x22, 0x56, 0xa5, 0x65,
+	0x6f, 0x14, 0x23, 0xd0, 0x51, 0x26, 0x17, 0xb4, 0x47, 0xb0, 0x8d, 0xab, 0x78, 0x13, 0xd7, 0x5f,
+	0x3d, 0xb1, 0x40, 0x65, 0x4f, 0xe0, 0x6d, 0x44, 0x6c, 0x0c, 0x16, 0xf8, 0xf1, 0x50, 0x46, 0x03,
+	0xd5, 0xa7, 0xe6, 0x59, 0x12, 0xd7, 0x51, 0xd8, 0x93, 0xa5, 0x5a, 0x6a, 0xd4, 0x72, 0x4d, 0xa8,
+	0x30, 0x2a, 0x96, 0x4a, 0xef, 0x53, 0x68, 0x2e, 0x1c, 0x14, 0x06, 0xd3, 0x1f, 0x01, 0xfa, 0x91,
+	0xd7, 0xf2, 0xd2, 0x7c, 0x0b, 0xa5, 0xa7, 0x23, 0xa3, 0xe9, 0x00, 0xad, 0x93, 0xb8, 0x8b, 0x30,
+	0xd5, 0xc5, 0x64, 0x42, 0x8c, 0x4d, 0x57, 0x17, 0xd6, 0xe4, 0xbf, 0x96, 0xe0, 0x66, 0xa1, 0x73,
+	0x9e, 0x28, 0xd9, 0x57, 0x54, 0x4b, 0xbd, 0xbc, 0xce, 0x9c, 0x89, 0xb5, 0x34, 0xf4, 0xe5, 0xe5,
+	0x2c, 0xac, 0x94, 0x84, 0x0e, 0x3f, 0x2b, 0x25, 0x6b, 0xe0, 0xf1, 0x66, 0x50, 0x04, 0xb6, 0x7c,
+	0xe8, 0x1b, 0x57, 0x88, 0xa6, 0x63, 0xec, 0xb5, 0x56, 0x1a, 0xce, 0x42, 0xad, 0x8d, 0x3c, 0xad,
+	0x55, 0x57, 0x6b, 0xcd, 0xa3, 0x60, 0xef, 0x35, 0x56, 0xa8, 0x56, 0x0a, 0x25, 0x91, 0xd9, 0x78,
+	0x98, 0x23, 0xd5, 0x1e, 0x7b, 0xb4, 0x79, 0x7b, 0x3e, 0x16, 0x50, 0xe4, 0xcd, 0xb2, 0x54, 0x13,
+	0xaf, 0x66, 0x79, 0x79, 0x14, 0x75, 0xdd, 0x4b, 0x33, 0x41, 0x34, 0x20, 0x5a, 0x1e, 0xc4, 0xb8,
+	0x49, 0x17, 0x6b, 0x9b, 0x8d, 0xd4, 0xc4, 0x7c, 0x8d, 0x0a, 0xf9, 0xb2, 0xd9, 0x28, 0xc2, 0x8c,
+	0xc3, 0xe6, 0xc4, 0x55, 0x3e, 0x36, 0xb0, 0xc6, 0x16, 0xd1, 0x72, 0x18, 0xff, 0x29, 0x80, 0x9d,
+	0x42, 0xe6, 0xd8, 0x43, 0xcc, 0x0c, 0x66, 0xcf, 0x75, 0xf5, 0xbd, 0xd5, 0x67, 0xa3, 0xcd, 0xb0,
+	0x70, 0x5c, 0xd6, 0x84, 0x72, 0x5f, 0x1a, 0x59, 0x38, 0xa0, 0xed, 0x29, 0x4a, 0x23, 0xec, 0x23,
+	0x80, 0x45, 0xcc, 0x5c, 0x0b, 0xf8, 0xff, 0xd2, 0xda, 0x76, 0x58, 0x78, 0x54, 0xfe, 0x67, 0xb0,
+	0x38, 0xd9, 0x3d, 0xdd, 0x04, 0xab, 0x75, 0x63, 0x0f, 0x5e, 0xa7, 0x9b, 0x3d, 0xa8, 0x99, 0xec,
+	0xd2, 0x64, 0x15, 0xb5, 0x00, 0x30, 0xef, 0xed, 0x17, 0x67, 0xfe, 0x5d, 0x2b, 0xb3, 0xd9, 0x3e,
+	0x40, 0xfb, 0xc5, 0x59, 0x2a, 0xa2, 0xca, 0x4a, 0x11, 0x79, 0x0c, 0xf4, 0xa4, 0xb3, 0x2b, 0x54,
+	0xd5, 0x5e, 0xa1, 0x32, 0x00, 0x47, 0xe9, 0x26, 0x31, 0xc4, 0x7c, 0xad, 0xdb, 0xd1, 0x0c, 0xe0,
+	0xbf, 0x04, 0xb0, 0xf3, 0xb9, 0xba, 0x24, 0xc7, 0x1d, 0xa3, 0x26, 0xe7, 0x7a, 0xf0, 0x86, 0xfb,
+	0x64, 0x50, 0xd6, 0x46, 0xd9, 0x2d, 0x56, 0x04, 0x7d, 0xb3, 0x87, 0x70, 0x53, 0xab, 0x5e, 0x1c,
+	0xf5, 0x75, 0x27, 0x8c, 0x7a, 0xaa, 0x63, 0x64, 0x62, 0xba, 0x69, 0x11, 0x55, 0xc4, 0xea, 0xc1,
+	0x54, 0x5f, 0x2e, 0x0d, 0xe4, 0xa9, 0x42, 0xfc, 0x22, 0xcc, 0x2f, 0x61, 0x8b, 0x9a, 0x1b, 0x45,
+	0xe0, 0xcd, 0x7f, 0x39, 0x17, 0x92, 0x52, 0x21, 0x24, 0x98, 0x9a, 0x50, 0x7b, 0x52, 0xd9, 0x10,
+	0x99, 0xcd, 0x7f, 0x08, 0x60, 0x3b, 0xd5, 0x43, 0xfb, 0xc5, 0xd9, 0x75, 0xae, 0xef, 0xc0, 0xee,
+	0x64, 0xc1, 0x14, 0xde, 0x5f, 0x2c, 0xe1, 0xec, 0x11, 0xd4, 0x3d, 0xcc, 0xdd, 0x3c, 0xde, 0x5a,
+	0x16, 0xbf, 0x7b, 0x45, 0x08, 0x9f, 0xcd, 0xfb, 0x00, 0x27, 0x52, 0xe3, 0x7d, 0xf6, 0x1f, 0x25,
+	0x0f, 0x9d, 0xa4, 0xc9, 0xc3, 0x6f, 0x64, 0x86, 0xf4, 0x74, 0x70, 0x6f, 0x00, 0x32, 0xf8, 0x77,
+	0xb0, 0x83, 0x2e, 0x3a, 0xca, 0x9c, 0xcb, 0xaf, 0x0e, 0x1e, 0xfc, 0x3b, 0xae, 0x5a, 0xb0, 0x7e,
+	0x71, 0xed, 0xb9, 0x9c, 0x0e, 0xf3, 0x9f, 0x03, 0xd8, 0x76, 0xfe, 0xf1, 0xcd, 0xf4, 0x1f, 0xbb,
+	0x67, 0x1f, 0x42, 0x65, 0x16, 0xe3, 0x95, 0xb6, 0xf2, 0xba, 0xd4, 0x58, 0x1e, 0xff, 0x2d, 0x80,
+	0xda, 0x89, 0x92, 0x89, 0xb9, 0x50, 0x92, 0xb4, 0x30, 0x7b, 0xc5, 0x13, 0x6e, 0xb6, 0xe2, 0x09,
+	0x37, 0x5b, 0xf9, 0x84, 0x9b, 0x2d, 0x3d, 0xe1, 0x86, 0xb9, 0x27, 0x5c, 0x71, 0xfb, 0x65, 0x7f,
+	0xfb, 0xb7, 0x61, 0x43, 0xab, 0x6f, 0xa6, 0x78, 0xf1, 0x74, 0x45, 0x95, 0xd9, 0xd7, 0xf7, 0x0f,
+	0xfe, 0x01, 0xd4, 0x4e, 0xf5, 0x89, 0x92, 0x23, 0x33, 0x9c, 0x23, 0x35, 0x4c, 0x0d, 0xda, 0xc1,
+	0x86, 0x58, 0x00, 0x17, 0x55, 0x7a, 0x18, 0x3f, 0xf8, 0x2b, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x0d,
+	0x4d, 0x91, 0x45, 0x0f, 0x00, 0x00,
 }