first stab on checked ints

2026-01-12 15:52:50 +00:00 · 2018-10-26 18:55:19 +02:00
223 changed files with 3374 additions and 6343 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -92,7 +92,6 @@ jobs:
          command: |
            export PATH="$GOBIN:$PATH"
            make get_tools
-            make get_dev_tools
      - run:
          name: dependencies
          command: |
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,283 +1,5 @@
 # Changelog

-## v0.26.4
-
-*November 27th, 2018*
-
-Special thanks to external contributors on this release:
-ackratos, goolAdapter, james-ray, joe-bowman, kostko,
-nagarajmanjunath, tomtau
-
-
-Friendly reminder, we have a [bug bounty
-program](https://hackerone.com/tendermint).
-
-### FEATURES:
-
- [rpc] [\#2747](https://github.com/tendermint/tendermint/issues/2747) Enable subscription to tags emitted from `BeginBlock`/`EndBlock` (@kostko)
- [types] [\#2747](https://github.com/tendermint/tendermint/issues/2747) Add `ResultBeginBlock` and `ResultEndBlock` fields to `EventDataNewBlock`
-    and `EventDataNewBlockHeader` to support subscriptions (@kostko)
- [types] [\#2918](https://github.com/tendermint/tendermint/issues/2918) Add Marshal, MarshalTo, Unmarshal methods to various structs
-  to support Protobuf compatibility (@nagarajmanjunath)
-
-### IMPROVEMENTS:
-
- [config] [\#2877](https://github.com/tendermint/tendermint/issues/2877) Add `blocktime_iota` to the config.toml (@ackratos)
-    - NOTE: this should be a ConsensusParam, not part of the config, and will be
-      removed from the config at a later date
-      ([\#2920](https://github.com/tendermint/tendermint/issues/2920).
- [mempool] [\#2882](https://github.com/tendermint/tendermint/issues/2882) Add txs from Update to cache
- [mempool] [\#2891](https://github.com/tendermint/tendermint/issues/2891) Remove local int64 counter from being stored in every tx
- [node] [\#2866](https://github.com/tendermint/tendermint/issues/2866) Add ability to instantiate IPCVal (@joe-bowman)
-
-### BUG FIXES:
-
- [blockchain] [\#2731](https://github.com/tendermint/tendermint/issues/2731) Retry both blocks if either is bad to avoid getting stuck during fast sync (@goolAdapter)
- [consensus] [\#2893](https://github.com/tendermint/tendermint/issues/2893) Use genDoc.Validators instead of state.NextValidators on replay when appHeight==0 (@james-ray)
- [log] [\#2868](https://github.com/tendermint/tendermint/issues/2868) Fix `module=main` setting overriding all others
-    - NOTE: this changes the default logging behaviour to be much less verbose.
-      Set `log_level="info"` to restore the previous behaviour.
- [rpc] [\#2808](https://github.com/tendermint/tendermint/issues/2808) Fix `accum` field in `/validators` by calling `IncrementAccum` if necessary
- [rpc] [\#2811](https://github.com/tendermint/tendermint/issues/2811) Allow integer IDs in JSON-RPC requests (@tomtau)
- [txindex/kv] [\#2759](https://github.com/tendermint/tendermint/issues/2759) Fix tx.height range queries
- [txindex/kv] [\#2775](https://github.com/tendermint/tendermint/issues/2775) Order tx results by index if height is the same
- [txindex/kv] [\#2908](https://github.com/tendermint/tendermint/issues/2908) Don't return false positives when searching for a prefix of a tag value
-
-## v0.26.3
-
-*November 17th, 2018*
-
-Special thanks to external contributors on this release:
-@danil-lashin, @kevlubkcm, @krhubert, @srmo
-
-Friendly reminder, we have a [bug bounty
-program](https://hackerone.com/tendermint).
-
-### BREAKING CHANGES:
-
-* Go API
-  - [rpc] [\#2791](https://github.com/tendermint/tendermint/issues/2791) Functions that start HTTP servers are now blocking:
-    - Impacts `StartHTTPServer`, `StartHTTPAndTLSServer`, and `StartGRPCServer`
-    - These functions now take a `net.Listener` instead of an address
-  - [rpc] [\#2767](https://github.com/tendermint/tendermint/issues/2767) Subscribing to events
-  `NewRound` and `CompleteProposal` return new types `EventDataNewRound` and
-  `EventDataCompleteProposal`, respectively, instead of the generic `EventDataRoundState`. (@kevlubkcm)
-
-### FEATURES:
-
- [log] [\#2843](https://github.com/tendermint/tendermint/issues/2843) New `log_format` config option, which can be set to 'plain' for colored
-  text or 'json' for JSON output
- [types] [\#2767](https://github.com/tendermint/tendermint/issues/2767) New event types EventDataNewRound (with ProposerInfo) and EventDataCompleteProposal (with BlockID). (@kevlubkcm)
-
-### IMPROVEMENTS:
-
- [dep] [\#2844](https://github.com/tendermint/tendermint/issues/2844) Dependencies are no longer pinned to an exact version in the
-  Gopkg.toml:
-  - Serialization libs are allowed to vary by patch release
-  - Other libs are allowed to vary by minor release
- [p2p] [\#2857](https://github.com/tendermint/tendermint/issues/2857) "Send failed" is logged at debug level instead of error.
- [rpc] [\#2780](https://github.com/tendermint/tendermint/issues/2780) Add read and write timeouts to HTTP servers
- [state] [\#2848](https://github.com/tendermint/tendermint/issues/2848) Make "Update to validators" msg value pretty (@danil-lashin)
-
-### BUG FIXES:
- [consensus] [\#2819](https://github.com/tendermint/tendermint/issues/2819) Don't send proposalHearbeat if not a validator
- [docs] [\#2859](https://github.com/tendermint/tendermint/issues/2859) Fix ConsensusParams details in spec
- [libs/autofile] [\#2760](https://github.com/tendermint/tendermint/issues/2760) Comment out autofile permissions check - should fix
-  running Tendermint on Windows
- [p2p] [\#2869](https://github.com/tendermint/tendermint/issues/2869) Set connection config properly instead of always using default
- [p2p/pex] [\#2802](https://github.com/tendermint/tendermint/issues/2802) Seed mode fixes:
-  - Only disconnect from inbound peers
-  - Use FlushStop instead of Sleep to ensure all messages are sent before
-    disconnecting
-
-## v0.26.2
-
-*November 15th, 2018*
-
-Special thanks to external contributors on this release: @hleb-albau, @zhuzeyu
-
-Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
-
-### FEATURES:
-
- [rpc] [\#2582](https://github.com/tendermint/tendermint/issues/2582) Enable CORS on RPC API (@hleb-albau)
-
-### BUG FIXES:
-
- [abci] [\#2748](https://github.com/tendermint/tendermint/issues/2748) Unlock mutex in localClient so even when app panics (e.g. during CheckTx), consensus continue working
- [abci] [\#2748](https://github.com/tendermint/tendermint/issues/2748) Fix DATA RACE in localClient
- [amino] [\#2822](https://github.com/tendermint/tendermint/issues/2822) Update to v0.14.1 to support compiling on 32-bit platforms
- [rpc] [\#2748](https://github.com/tendermint/tendermint/issues/2748) Drain channel before calling Unsubscribe(All) in `/broadcast_tx_commit`
-
-## v0.26.1
-
-*November 11, 2018*
-
-Special thanks to external contributors on this release: @katakonst
-
-Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
-
-### IMPROVEMENTS:
-
- [consensus] [\#2704](https://github.com/tendermint/tendermint/issues/2704) Simplify valid POL round logic
- [docs] [\#2749](https://github.com/tendermint/tendermint/issues/2749) Deduplicate some ABCI docs
- [mempool] More detailed log messages
-    - [\#2724](https://github.com/tendermint/tendermint/issues/2724)
-    - [\#2762](https://github.com/tendermint/tendermint/issues/2762)
-
-### BUG FIXES:
-
- [autofile] [\#2703](https://github.com/tendermint/tendermint/issues/2703) Do not panic when checking Head size
- [crypto/merkle] [\#2756](https://github.com/tendermint/tendermint/issues/2756) Fix crypto/merkle ProofOperators.Verify to check bounds on keypath parts.
- [mempool] fix a bug where we create a WAL despite `wal_dir` being empty
- [p2p] [\#2771](https://github.com/tendermint/tendermint/issues/2771) Fix `peer-id` label name to `peer_id` in prometheus metrics
- [p2p] [\#2797](https://github.com/tendermint/tendermint/pull/2797) Fix IDs in peer NodeInfo and require them for addresses
-  in AddressBook
- [p2p] [\#2797](https://github.com/tendermint/tendermint/pull/2797) Do not close conn immediately after sending pex addrs in seed mode. Partial fix for [\#2092](https://github.com/tendermint/tendermint/issues/2092).
-
-## v0.26.0
-
-*November 2, 2018*
-
-Special thanks to external contributors on this release:
-@bradyjoestar, @connorwstein, @goolAdapter, @HaoyangLiu,
-@james-ray, @overbool, @phymbert, @Slamper, @Uzair1995, @yutianwu.
-
-Special thanks to @Slamper for a series of bug reports in our [bug bounty
-program](https://hackerone.com/tendermint) which are fixed in this release.
-
-This release is primarily about adding Version fields to various data structures,
-optimizing consensus messages for signing and verification in
-restricted environments (like HSMs and the Ethereum Virtual Machine), and
-aligning the consensus code with the [specification](https://arxiv.org/abs/1807.04938).
-It also includes our first take at a generalized merkle proof system, and
-changes the length of hashes used for hashing data structures from 20 to 32
-bytes.
-
-See the [UPGRADING.md](UPGRADING.md#v0.26.0) for details on upgrading to the new
-version.
-
-Please note that we are still making breaking changes to the protocols.
-While the new Version fields should help us to keep the software backwards compatible
-even while upgrading the protocols, we cannot guarantee that new releases will
-be compatible with old chains just yet. We expect there will be another breaking
-release or two before the Cosmos Hub launch, but we will otherwise be paying
-increasing attention to backwards compatibility. Thanks for bearing with us!
-
-### BREAKING CHANGES:
-
-* CLI/RPC/Config
-  * [config] [\#2232](https://github.com/tendermint/tendermint/issues/2232) Timeouts are now strings like "3s" and "100ms", not ints
-  * [config] [\#2505](https://github.com/tendermint/tendermint/issues/2505) Remove Mempool.RecheckEmpty (it was effectively useless anyways)
-  * [config] [\#2490](https://github.com/tendermint/tendermint/issues/2490) `mempool.wal` is disabled by default
-  * [privval] [\#2459](https://github.com/tendermint/tendermint/issues/2459) Split `SocketPVMsg`s implementations into Request and Response, where the Response may contain a error message (returned by the remote signer)
-  * [state] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Add Version field to State, breaking the format of State as
-    encoded on disk.
-  * [rpc] [\#2298](https://github.com/tendermint/tendermint/issues/2298) `/abci_query` takes `prove` argument instead of `trusted` and switches the default
-    behaviour to `prove=false`
-  * [rpc] [\#2654](https://github.com/tendermint/tendermint/issues/2654) Remove all `node_info.other.*_version` fields in `/status` and
-    `/net_info`
-  * [rpc] [\#2636](https://github.com/tendermint/tendermint/issues/2636) Remove
-    `_params` suffix from fields in `consensus_params`.
-
-* Apps
-  * [abci] [\#2298](https://github.com/tendermint/tendermint/issues/2298) ResponseQuery.Proof is now a structured merkle.Proof, not just
-    arbitrary bytes
-  * [abci] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Add Version to Header and shift all fields by one
-  * [abci] [\#2662](https://github.com/tendermint/tendermint/issues/2662) Bump the field numbers for some `ResponseInfo` fields to make room for
-      `AppVersion`
-  * [abci] [\#2636](https://github.com/tendermint/tendermint/issues/2636) Updates to ConsensusParams
-    * Remove `Params` suffix from field names
-    * Add `Params` suffix to message types
-    * Add new field and type, `Validator ValidatorParams`, to control what types of validator keys are allowed.
-
-* Go API
-  * [config] [\#2232](https://github.com/tendermint/tendermint/issues/2232) Timeouts are time.Duration, not ints
-  * [crypto/merkle & lite] [\#2298](https://github.com/tendermint/tendermint/issues/2298) Various changes to accomodate General Merkle trees
-  * [crypto/merkle] [\#2595](https://github.com/tendermint/tendermint/issues/2595) Remove all Hasher objects in favor of byte slices
-  * [crypto/merkle] [\#2635](https://github.com/tendermint/tendermint/issues/2635) merkle.SimpleHashFromTwoHashes is no longer exported
-  * [node] [\#2479](https://github.com/tendermint/tendermint/issues/2479) Remove node.RunForever
-  * [rpc/client] [\#2298](https://github.com/tendermint/tendermint/issues/2298) `ABCIQueryOptions.Trusted` -> `ABCIQueryOptions.Prove`
-  * [types] [\#2298](https://github.com/tendermint/tendermint/issues/2298) Remove `Index` and `Total` fields from `TxProof`.
-  * [types] [\#2598](https://github.com/tendermint/tendermint/issues/2598)
-    `VoteTypeXxx` are now of type `SignedMsgType byte` and named `XxxType`, eg.
-    `PrevoteType`, `PrecommitType`.
-  * [types] [\#2636](https://github.com/tendermint/tendermint/issues/2636) Rename fields in ConsensusParams to remove `Params` suffixes
-  * [types] [\#2735](https://github.com/tendermint/tendermint/issues/2735) Simplify Proposal message to align with spec
-
-* Blockchain Protocol
-  * [crypto/tmhash] [\#2732](https://github.com/tendermint/tendermint/issues/2732) TMHASH is now full 32-byte SHA256
-    * All hashes in the block header and Merkle trees are now 32-bytes
-    * PubKey Addresses are still only 20-bytes
-  * [state] [\#2587](https://github.com/tendermint/tendermint/issues/2587) Require block.Time of the fist block to be genesis time
-  * [state] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Require block.Version to match state.Version
-  * [types] Update SignBytes for `Vote`/`Proposal`/`Heartbeat`:
-    * [\#2459](https://github.com/tendermint/tendermint/issues/2459) Use amino encoding instead of JSON in `SignBytes`.
-    * [\#2598](https://github.com/tendermint/tendermint/issues/2598) Reorder fields and use fixed sized encoding.
-    * [\#2598](https://github.com/tendermint/tendermint/issues/2598) Change `Type` field from `string` to `byte` and use new
-      `SignedMsgType` to enumerate.
-  * [types] [\#2730](https://github.com/tendermint/tendermint/issues/2730) Use
-    same order for fields in `Vote` as in the SignBytes
-  * [types] [\#2732](https://github.com/tendermint/tendermint/issues/2732) Remove the address field from the validator hash
-  * [types] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Add Version struct to Header
-  * [types] [\#2609](https://github.com/tendermint/tendermint/issues/2609) ConsensusParams.Hash() is the hash of the amino encoded
-    struct instead of the Merkle tree of the fields
-  * [types] [\#2670](https://github.com/tendermint/tendermint/issues/2670) Header.Hash() builds Merkle tree out of fields in the same
-    order they appear in the header, instead of sorting by field name
-  * [types] [\#2682](https://github.com/tendermint/tendermint/issues/2682) Use proto3 `varint` encoding for ints that are usually unsigned (instead of zigzag encoding).
-  * [types] [\#2636](https://github.com/tendermint/tendermint/issues/2636) Add Validator field to ConsensusParams
-      (Used to control which pubkey types validators can use, by abci type).
-
-* P2P Protocol
-  * [consensus] [\#2652](https://github.com/tendermint/tendermint/issues/2652)
-    Replace `CommitStepMessage` with `NewValidBlockMessage`
-  * [consensus] [\#2735](https://github.com/tendermint/tendermint/issues/2735) Simplify `Proposal` message to align with spec
-  * [consensus] [\#2730](https://github.com/tendermint/tendermint/issues/2730)
-    Add `Type` field to `Proposal` and use same order of fields as in the
-    SignBytes for both `Proposal` and `Vote`
-  * [p2p] [\#2654](https://github.com/tendermint/tendermint/issues/2654) Add `ProtocolVersion` struct with protocol versions to top of
-    DefaultNodeInfo and require `ProtocolVersion.Block` to match during peer handshake
-
-
-### FEATURES:
- [abci] [\#2557](https://github.com/tendermint/tendermint/issues/2557) Add `Codespace` field to `Response{CheckTx, DeliverTx, Query}`
- [abci] [\#2662](https://github.com/tendermint/tendermint/issues/2662) Add `BlockVersion` and `P2PVersion` to `RequestInfo`
- [crypto/merkle] [\#2298](https://github.com/tendermint/tendermint/issues/2298) General Merkle Proof scheme for chaining various types of Merkle trees together
- [docs/architecture] [\#1181](https://github.com/tendermint/tendermint/issues/1181) S
-plit immutable and mutable parts of priv_validator.json
-
-### IMPROVEMENTS:
- Additional Metrics
-    - [consensus] [\#2169](https://github.com/cosmos/cosmos-sdk/issues/2169)
-    - [p2p] [\#2169](https://github.com/cosmos/cosmos-sdk/issues/2169)
- [config] [\#2232](https://github.com/tendermint/tendermint/issues/2232) Added ValidateBasic method, which performs basic checks
- [crypto/ed25519] [\#2558](https://github.com/tendermint/tendermint/issues/2558) Switch to use latest `golang.org/x/crypto` through our fork at
-  github.com/tendermint/crypto
- [libs/log] [\#2707](https://github.com/tendermint/tendermint/issues/2707) Add year to log format (@yutianwu)
- [tools] [\#2238](https://github.com/tendermint/tendermint/issues/2238) Binary dependencies are now locked to a specific git commit
-
-### BUG FIXES:
- [\#2711](https://github.com/tendermint/tendermint/issues/2711) Validate all incoming reactor messages. Fixes various bugs due to negative ints.
- [autofile] [\#2428](https://github.com/tendermint/tendermint/issues/2428) Group.RotateFile need call Flush() before rename (@goolAdapter)
- [common] [\#2533](https://github.com/tendermint/tendermint/issues/2533) Fixed a bug in the `BitArray.Or` method
- [common] [\#2506](https://github.com/tendermint/tendermint/issues/2506) Fixed a bug in the `BitArray.Sub` method (@james-ray)
- [common] [\#2534](https://github.com/tendermint/tendermint/issues/2534) Fix `BitArray.PickRandom` to choose uniformly from true bits
- [consensus] [\#1690](https://github.com/tendermint/tendermint/issues/1690) Wait for
-  timeoutPrecommit before starting next round
- [consensus] [\#1745](https://github.com/tendermint/tendermint/issues/1745) Wait for
-  Proposal or timeoutProposal before entering prevote
- [consensus] [\#2642](https://github.com/tendermint/tendermint/issues/2642) Only propose ValidBlock, not LockedBlock
- [consensus] [\#2642](https://github.com/tendermint/tendermint/issues/2642) Initialized ValidRound and LockedRound to -1
- [consensus] [\#1637](https://github.com/tendermint/tendermint/issues/1637) Limit the amount of evidence that can be included in a
-  block
- [consensus] [\#2652](https://github.com/tendermint/tendermint/issues/2652) Ensure valid block property with faulty proposer
- [evidence] [\#2515](https://github.com/tendermint/tendermint/issues/2515) Fix db iter leak (@goolAdapter)
- [libs/event] [\#2518](https://github.com/tendermint/tendermint/issues/2518) Fix event concurrency flaw (@goolAdapter)
- [node] [\#2434](https://github.com/tendermint/tendermint/issues/2434) Make node respond to signal interrupts while sleeping for genesis time
- [state] [\#2616](https://github.com/tendermint/tendermint/issues/2616) Pass nil to NewValidatorSet() when genesis file's Validators field is nil
- [p2p] [\#2555](https://github.com/tendermint/tendermint/issues/2555) Fix p2p switch FlushThrottle value (@goolAdapter)
- [p2p] [\#2668](https://github.com/tendermint/tendermint/issues/2668) Reconnect to originally dialed address (not self-reported address) for persistent peers
-
 ## v0.25.0

 *September 22, 2018*
@@ -442,8 +164,8 @@ BUG FIXES:
 *August 22nd, 2018*

 BUG FIXES:
- [libs/autofile] [\#2261](https://github.com/tendermint/tendermint/issues/2261) Fix log rotation so it actually happens.
-    - Fixes issues with consensus WAL growing unbounded ala [\#2259](https://github.com/tendermint/tendermint/issues/2259)
+- [libs/autofile] \#2261 Fix log rotation so it actually happens.
+    - Fixes issues with consensus WAL growing unbounded ala \#2259

 ## 0.23.0

--- a/CHANGELOG_PENDING.md
+++ b/CHANGELOG_PENDING.md
@@ -1,34 +1,107 @@
 # Pending

-## v0.27.0
+## v0.26.0

-*TBD*
+*October 19, 2018*

 Special thanks to external contributors on this release:
+@bradyjoestar, @connorwstein, @goolAdapter, @HaoyangLiu,
+@james-ray, @overbool, @phymbert, @Slamper, @Uzair1995

-Friendly reminder, we have a [bug bounty
-program](https://hackerone.com/tendermint).
+This release is primarily about adding Version fields to various data structures,
+optimizing consensus messages for signing and verification in
+restricted environments (like HSMs and the Ethereum Virtual Machine), and
+aligning the consensus code with the [specification](https://arxiv.org/abs/1807.04938).
+It also includes our first take at a generalized merkle proof system.

-### BREAKING CHANGES:
+See the [UPGRADING.md](UPGRADING.md#v0.26.0) for details on upgrading to the new
+version.
+
+Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
+
+BREAKING CHANGES:

 * CLI/RPC/Config
+  * [config] [\#2232](https://github.com/tendermint/tendermint/issues/2232) timeouts as time.Duration, not ints
+  * [config] [\#2505](https://github.com/tendermint/tendermint/issues/2505) Remove Mempool.RecheckEmpty (it was effectively useless anyways)
+  * [config] [\#2490](https://github.com/tendermint/tendermint/issues/2490) `mempool.wal` is disabled by default
+  * [privval] [\#2459](https://github.com/tendermint/tendermint/issues/2459) Split `SocketPVMsg`s implementations into Request and Response, where the Response may contain a error message (returned by the remote signer)
+  * [state] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Add Version field to State, breaking the format of State as
+    encoded on disk.
+  * [rpc] [\#2298](https://github.com/tendermint/tendermint/issues/2298) `/abci_query` takes `prove` argument instead of `trusted` and switches the default
+    behaviour to `prove=false`
+  * [rpc] [\#2654](https://github.com/tendermint/tendermint/issues/2654) Remove all `node_info.other.*_version` fields in `/status` and
+    `/net_info`

 * Apps
+  * [abci] [\#2298](https://github.com/tendermint/tendermint/issues/2298) ResponseQuery.Proof is now a structured merkle.Proof, not just
+    arbitrary bytes
+  * [abci] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Add Version to Header and shift all fields by one
+  * [abci] [\#2662](https://github.com/tendermint/tendermint/issues/2662) Bump the field numbers for some `ResponseInfo` fields to make room for
+      `AppVersion`

 * Go API
-
- [db] [\#2913](https://github.com/tendermint/tendermint/pull/2913) ReverseIterator API change -- start < end, and end is exclusive.
+  * [config] [\#2232](https://github.com/tendermint/tendermint/issues/2232) timeouts as time.Duration, not ints
+  * [crypto/merkle & lite] [\#2298](https://github.com/tendermint/tendermint/issues/2298) Various changes to accomodate General Merkle trees
+  * [crypto/merkle] [\#2595](https://github.com/tendermint/tendermint/issues/2595) Remove all Hasher objects in favor of byte slices
+  * [crypto/merkle] [\#2635](https://github.com/tendermint/tendermint/issues/2635) merkle.SimpleHashFromTwoHashes is no longer exported
+  * [node] [\#2479](https://github.com/tendermint/tendermint/issues/2479) Remove node.RunForever
+  * [rpc/client] [\#2298](https://github.com/tendermint/tendermint/issues/2298) `ABCIQueryOptions.Trusted` -> `ABCIQueryOptions.Prove`
+  * [types] [\#2298](https://github.com/tendermint/tendermint/issues/2298) Remove `Index` and `Total` fields from `TxProof`.
+  * [types] [\#2598](https://github.com/tendermint/tendermint/issues/2598) `VoteTypeXxx` are now of type `SignedMsgType byte` and named `XxxType`, eg. `PrevoteType`,
+    `PrecommitType`.

 * Blockchain Protocol
-  * [state] \#2714 Validators can now only use pubkeys allowed within ConsensusParams.ValidatorParams
+  * [types] Update SignBytes for `Vote`/`Proposal`/`Heartbeat`:
+    * [\#2459](https://github.com/tendermint/tendermint/issues/2459) Use amino encoding instead of JSON in `SignBytes`.
+    * [\#2598](https://github.com/tendermint/tendermint/issues/2598) Reorder fields and use fixed sized encoding.
+    * [\#2598](https://github.com/tendermint/tendermint/issues/2598) Change `Type` field fromt `string` to `byte` and use new
+      `SignedMsgType` to enumerate.
+  * [types] [\#2512](https://github.com/tendermint/tendermint/issues/2512) Remove the pubkey field from the validator hash
+  * [types] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Add Version struct to Header
+  * [types] [\#2609](https://github.com/tendermint/tendermint/issues/2609) ConsensusParams.Hash() is the hash of the amino encoded
+    struct instead of the Merkle tree of the fields
+  * [state] [\#2587](https://github.com/tendermint/tendermint/issues/2587) Require block.Time of the fist block to be genesis time
+  * [state] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Require block.Version to match state.Version
+  * [types] [\#2670](https://github.com/tendermint/tendermint/issues/2670) Header.Hash() builds Merkle tree out of fields in the same
+    order they appear in the header, instead of sorting by field name

 * P2P Protocol
+  * [p2p] [\#2654](https://github.com/tendermint/tendermint/issues/2654) Add `ProtocolVersion` struct with protocol versions to top of
+    DefaultNodeInfo and require `ProtocolVersion.Block` to match during peer handshake

-### FEATURES:
+FEATURES:
+- [abci] [\#2557](https://github.com/tendermint/tendermint/issues/2557) Add `Codespace` field to `Response{CheckTx, DeliverTx, Query}`
+- [abci] [\#2662](https://github.com/tendermint/tendermint/issues/2662) Add `BlockVersion` and `P2PVersion` to `RequestInfo`
+- [crypto/merkle] [\#2298](https://github.com/tendermint/tendermint/issues/2298) General Merkle Proof scheme for chaining various types of Merkle trees together

-### IMPROVEMENTS:
- [consensus] [\#2871](https://github.com/tendermint/tendermint/issues/2871) Remove *ProposalHeartbeat* infrastructure as it serves no real purpose
+IMPROVEMENTS:
+- Additional Metrics
+    - [consensus] [\#2169](https://github.com/cosmos/cosmos-sdk/issues/2169)
+    - [p2p] [\#2169](https://github.com/cosmos/cosmos-sdk/issues/2169)
+- [config] [\#2232](https://github.com/tendermint/tendermint/issues/2232) Added ValidateBasic method, which performs basic checks
+- [crypto/ed25519] [\#2558](https://github.com/tendermint/tendermint/issues/2558) Switch to use latest `golang.org/x/crypto` through our fork at
+  github.com/tendermint/crypto
+- [tools] [\#2238](https://github.com/tendermint/tendermint/issues/2238) Binary dependencies are now locked to a specific git commit
+
+BUG FIXES:
+- [autofile] [\#2428](https://github.com/tendermint/tendermint/issues/2428) Group.RotateFile need call Flush() before rename (@goolAdapter)
+- [common] [\#2533](https://github.com/tendermint/tendermint/issues/2533) Fixed a bug in the `BitArray.Or` method
+- [common] [\#2506](https://github.com/tendermint/tendermint/issues/2506) Fixed a bug in the `BitArray.Sub` method (@james-ray)
+- [common] [\#2534](https://github.com/tendermint/tendermint/issues/2534) Fix `BitArray.PickRandom` to choose uniformly from true bits
+- [consensus] [\#1690](https://github.com/tendermint/tendermint/issues/1690) Wait for
+  timeoutPrecommit before starting next round
+- [consensus] [\#1745](https://github.com/tendermint/tendermint/issues/1745) Wait for
+  Proposal or timeoutProposal before entering prevote
+- [consensus] [\#2642](https://github.com/tendermint/tendermint/issues/2642) Only propose ValidBlock, not LockedBlock
+- [consensus] [\#2642](https://github.com/tendermint/tendermint/issues/2642) Initialized ValidRound and LockedRound to -1
+- [consensus] [\#1637](https://github.com/tendermint/tendermint/issues/1637) Limit the amount of evidence that can be included in a
+  block
+- [evidence] [\#2515](https://github.com/tendermint/tendermint/issues/2515) Fix db iter leak (@goolAdapter)
+- [libs/event] [\#2518](https://github.com/tendermint/tendermint/issues/2518) Fix event concurrency flaw (@goolAdapter)
+- [node] [\#2434](https://github.com/tendermint/tendermint/issues/2434) Make node respond to signal interrupts while sleeping for genesis time
+- [state] [\#2616](https://github.com/tendermint/tendermint/issues/2616) Pass nil to NewValidatorSet() when genesis file's Validators field is nil
+- [p2p] [\#2555](https://github.com/tendermint/tendermint/issues/2555) Fix p2p switch FlushThrottle value (@goolAdapter)
+- [p2p] [\#2668](https://github.com/tendermint/tendermint/issues/2668) Reconnect to originally dialed address (not self-reported
+  address) for persistent peers

-### BUG FIXES:
- [types] \#2938 Fix regression in v0.26.4 where we panic on empty
-  genDoc.Validators
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -6,7 +6,7 @@ This code of conduct applies to all projects run by the Tendermint/COSMOS team a


 # Conduct
-## Contact: conduct@tendermint.com
+## Contact: adrian@tendermint.com

 * We are committed to providing a friendly, safe and welcoming environment for all, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, nationality, or other similar characteristic.

--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -27,8 +27,8 @@ Of course, replace `ebuchman` with your git handle.

 To pull in updates from the origin repo, run

-  * `git fetch upstream`
-  * `git rebase upstream/master` (or whatever branch you want)
+    * `git fetch upstream`
+    * `git rebase upstream/master` (or whatever branch you want)

 Please don't make Pull Requests to `master`.

@@ -50,11 +50,6 @@ as apps, tools, and the core, should use dep.
 Run `dep status` to get a list of vendor dependencies that may not be
 up-to-date.

-When updating dependencies, please only update the particular dependencies you
-need. Instead of running `dep ensure -update`, which will update anything,
-specify exactly the dependency you want to update, eg.
-`dep ensure -update github.com/tendermint/go-amino`.
-
 ## Vagrant

 If you are a [Vagrant](https://www.vagrantup.com/) user, you can get started
@@ -69,74 +64,43 @@ vagrant ssh
 make test
 ```

-## Changelog
+## Testing

-Every fix, improvement, feature, or breaking change should be made in a
-pull-request that includes an update to the `CHANGELOG_PENDING.md` file.
+All repos should be hooked up to [CircleCI](https://circleci.com/).

-Changelog entries should be formatted as follows:
-
-```
- [module] \#xxx Some description about the change (@contributor)
-```
-
-Here, `module` is the part of the code that changed (typically a
-top-level Go package), `xxx` is the pull-request number, and `contributor`
-is the author/s of the change.
-
-It's also acceptable for `xxx` to refer to the relevent issue number, but pull-request
-numbers are preferred.
-Note this means pull-requests should be opened first so the changelog can then
-be updated with the pull-request's number.
-There is no need to include the full link, as this will be added
-automatically during release. But please include the backslash and pound, eg. `\#2313`.
-
-Changelog entries should be ordered alphabetically according to the
-`module`, and numerically according to the pull-request number.
-
-Changes with multiple classifications should be doubly included (eg. a bug fix
-that is also a breaking change should be recorded under both).
-
-Breaking changes are further subdivided according to the APIs/users they impact.
-Any change that effects multiple APIs/users should be recorded multiply - for
-instance, a change to the `Blockchain Protocol` that removes a field from the
-header should also be recorded under `CLI/RPC/Config` since the field will be
-removed from the header in rpc responses as well.
+If they have `.go` files in the root directory, they will be automatically
+tested by circle using `go test -v -race ./...`. If not, they will need a
+`circle.yml`. Ideally, every repo has a `Makefile` that defines `make test` and
+includes its continuous integration status using a badge in the `README.md`.

 ## Branching Model and Release

-All repos should adhere to the branching model: http://nvie.com/posts/a-successful-git-branching-model/.
-This means that all pull-requests should be made against develop. Any merge to
-master constitutes a tagged release.
+User-facing repos should adhere to the branching model: http://nvie.com/posts/a-successful-git-branching-model/.
+That is, these repos should be well versioned, and any merge to master requires a version bump and tagged release.
+
+Libraries need not follow the model strictly, but would be wise to,
+especially `go-p2p` and `go-rpc`, as their versions are referenced in tendermint core.

 ### Development Procedure:
 - the latest state of development is on `develop`
 - `develop` must never fail `make test`
- never --force onto `develop` (except when reverting a broken commit, which should seldom happen)
+- no --force onto `develop` (except when reverting a broken commit, which should seldom happen)
 - create a development branch either on github.com/tendermint/tendermint, or your fork (using `git remote add origin`)
- make changes and update the `CHANGELOG_PENDING.md` to record your change
- before submitting a pull request, run `git rebase` on top of the latest `develop`
+- before submitting a pull request, begin `git rebase` on top of `develop`

 ### Pull Merge Procedure:
- ensure pull branch is based on a recent develop
+- ensure pull branch is rebased on develop
 - run `make test` to ensure that all tests pass
 - merge pull request
- the `unstable` branch may be used to aggregate pull merges before fixing tests
+- the `unstable` branch may be used to aggregate pull merges before testing once
+- push master may request that pull requests be rebased on top of `unstable`

 ### Release Procedure:
 - start on `develop`
 - run integration tests (see `test_integrations` in Makefile)
- prepare changelog:
-    - copy `CHANGELOG_PENDING.md` to top of `CHANGELOG.md`
-    - run `python ./scripts/linkify_changelog.py CHANGELOG.md` to add links for
-      all issues
-    - run `bash ./scripts/authors.sh` to get a list of authors since the latest
-      release, and add the github aliases of external contributors to the top of
-      the changelog. To lookup an alias from an email, try `bash
-      ./scripts/authors.sh <email>`
-    - reset the `CHANGELOG_PENDING.md`
+- prepare changelog/release issue
 - bump versions
- push to release/vX.X.X to run the extended integration tests on the CI
+- push to release-vX.X.X to run the extended integration tests on the CI
 - merge to master
 - merge master back to develop

@@ -151,13 +115,3 @@ master constitutes a tagged release.
 - merge hotfix-vX.X.X to master
 - merge hotfix-vX.X.X to develop
 - delete the hotfix-vX.X.X branch
-
-
-## Testing
-
-All repos should be hooked up to [CircleCI](https://circleci.com/).
-
-If they have `.go` files in the root directory, they will be automatically
-tested by circle using `go test -v -race ./...`. If not, they will need a
-`circle.yml`. Ideally, every repo has a `Makefile` that defines `make test` and
-includes its continuous integration status using a badge in the `README.md`.
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -35,6 +35,13 @@
  revision = "8991bc29aa16c548c550c7ff78260e27b9ab7c73"
  version = "v1.1.1"

+[[projects]]
+  digest = "1:c7644c73a3d23741fdba8a99b1464e021a224b7e205be497271a8003a15ca41b"
+  name = "github.com/ebuchman/fail-test"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "95f809107225be108efcf10a3509e4ea6ceef3c4"
+
 [[projects]]
  digest = "1:544229a3ca0fb2dd5ebc2896d3d2ff7ce096d9751635301e44e37e761349ee70"
  name = "github.com/fortytw2/leaktest"
@@ -218,16 +225,14 @@
  version = "v1.0.0"

 [[projects]]
-  digest = "1:26663fafdea73a38075b07e8e9d82fc0056379d2be8bb4e13899e8fda7c7dd23"
+  digest = "1:c1a04665f9613e082e1209cf288bf64f4068dcd6c87a64bf1c4ff006ad422ba0"
  name = "github.com/prometheus/client_golang"
  packages = [
    "prometheus",
-    "prometheus/internal",
    "prometheus/promhttp",
  ]
  pruneopts = "UT"
-  revision = "abad2d1bd44235a26707c172eab6bca5bf2dbad3"
-  version = "v0.9.1"
+  revision = "ae27198cdd90bf12cd134ad79d1366a6cf49f632"

 [[projects]]
  branch = "master"
@@ -269,14 +274,6 @@
  pruneopts = "UT"
  revision = "e2704e165165ec55d062f5919b4b29494e9fa790"

-[[projects]]
-  digest = "1:b0c25f00bad20d783d259af2af8666969e2fc343fa0dc9efe52936bbd67fb758"
-  name = "github.com/rs/cors"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "9a47f48565a795472d43519dd49aac781f3034fb"
-  version = "v1.6.0"
-
 [[projects]]
  digest = "1:6a4a11ba764a56d2758899ec6f3848d24698d48442ebce85ee7a3f63284526cd"
  name = "github.com/spf13/afero"
@@ -289,12 +286,12 @@
  version = "v1.1.2"

 [[projects]]
-  digest = "1:08d65904057412fc0270fc4812a1c90c594186819243160dc779a402d4b6d0bc"
+  digest = "1:516e71bed754268937f57d4ecb190e01958452336fa73dbac880894164e91c1f"
  name = "github.com/spf13/cast"
  packages = ["."]
  pruneopts = "UT"
-  revision = "8c9545af88b134710ab1cd196795e7f2388358d7"
-  version = "v1.3.0"
+  revision = "8965335b8c7107321228e3e3702cab9832751bac"
+  version = "v1.2.0"

 [[projects]]
  digest = "1:7ffc0983035bc7e297da3688d9fe19d60a420e9c38bef23f845c53788ed6a05e"
@@ -368,12 +365,12 @@
  revision = "e5840949ff4fff0c56f9b6a541e22b63581ea9df"

 [[projects]]
-  digest = "1:ad9c4c1a4e7875330b1f62906f2830f043a23edb5db997e3a5ac5d3e6eadf80a"
+  digest = "1:5f52e817b6c9d52ddba70dece0ea31134d82a52c05bce98fbc739ab2a832df28"
  name = "github.com/tendermint/go-amino"
  packages = ["."]
  pruneopts = "UT"
-  revision = "dc14acf9ef15f85828bfbc561ed9dd9d2a284885"
-  version = "v0.14.1"
+  revision = "cb07448b240918aa8d8df4505153549b86b77134"
+  version = "v0.13.0"

 [[projects]]
  digest = "1:72b71e3a29775e5752ed7a8012052a3dee165e27ec18cedddae5288058f09acf"
@@ -418,14 +415,14 @@

 [[projects]]
  branch = "master"
-  digest = "1:6f86e2f2e2217cd4d74dec6786163cf80e4d2b99adb341ecc60a45113b844dca"
+  digest = "1:d1da39c9bac61327dbef1d8ef9f210425e99fd2924b6fb5f0bc587a193353637"
  name = "golang.org/x/sys"
  packages = [
    "cpu",
    "unix",
  ]
  pruneopts = "UT"
-  revision = "7e31e0c00fa05cb5fbf4347b585621d6709e19a4"
+  revision = "8a28ead16f52c8aaeffbf79239b251dfdf6c4f96"

 [[projects]]
  digest = "1:a2ab62866c75542dd18d2b069fec854577a20211d7c0ea6ae746072a1dccdd18"
@@ -456,7 +453,7 @@
  name = "google.golang.org/genproto"
  packages = ["googleapis/rpc/status"]
  pruneopts = "UT"
-  revision = "b69ba1387ce2108ac9bc8e8e5e5a46e7d5c72313"
+  revision = "94acd270e44e65579b9ee3cdab25034d33fed608"

 [[projects]]
  digest = "1:2dab32a43451e320e49608ff4542fdfc653c95dcc35d0065ec9c6c3dd540ed74"
@@ -506,6 +503,7 @@
  input-imports = [
    "github.com/btcsuite/btcutil/base58",
    "github.com/btcsuite/btcutil/bech32",
+    "github.com/ebuchman/fail-test",
    "github.com/fortytw2/leaktest",
    "github.com/go-kit/kit/log",
    "github.com/go-kit/kit/log/level",
@@ -526,7 +524,6 @@
    "github.com/prometheus/client_golang/prometheus",
    "github.com/prometheus/client_golang/prometheus/promhttp",
    "github.com/rcrowley/go-metrics",
-    "github.com/rs/cors",
    "github.com/spf13/cobra",
    "github.com/spf13/viper",
    "github.com/stretchr/testify/assert",
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -20,60 +20,53 @@
 #   unused-packages = true
 #
 ###########################################################
+# NOTE: All packages should be pinned to specific versions.
+# Packages without releases must pin to a commit.
+

-# Allow only patch releases for serialization libraries
 [[constraint]]
-  name = "github.com/tendermint/go-amino"
-  version = "~0.14.1"
+  name = "github.com/go-kit/kit"
+  version = "=0.6.0"

 [[constraint]]
  name = "github.com/gogo/protobuf"
-  version = "~1.1.1"
+  version = "=1.1.1"

 [[constraint]]
  name = "github.com/golang/protobuf"
-  version = "~1.1.0"
-
-# Allow only minor releases for other libraries
-[[constraint]]
-  name = "github.com/go-kit/kit"
-  version = "^0.6.0"
+  version = "=1.1.0"

 [[constraint]]
  name = "github.com/gorilla/websocket"
-  version = "^1.2.0"
-
-[[constraint]]
-  name = "github.com/rs/cors"
-  version = "^1.6.0"
+  version = "=1.2.0"

 [[constraint]]
  name = "github.com/pkg/errors"
-  version = "^0.8.0"
+  version = "=0.8.0"

 [[constraint]]
  name = "github.com/spf13/cobra"
-  version = "^0.0.1"
+  version = "=0.0.1"

 [[constraint]]
  name = "github.com/spf13/viper"
-  version = "^1.0.0"
+  version = "=1.0.0"

 [[constraint]]
  name = "github.com/stretchr/testify"
-  version = "^1.2.1"
+  version = "=1.2.1"
+
+[[constraint]]
+  name = "github.com/tendermint/go-amino"
+  version = "v0.13.0"

 [[constraint]]
  name = "google.golang.org/grpc"
-  version = "^1.13.0"
+  version = "=1.13.0"

 [[constraint]]
  name = "github.com/fortytw2/leaktest"
-  version = "^1.2.0"
-
-[[constraint]]
-  name = "github.com/prometheus/client_golang"
-  version = "^0.9.1"
+  version = "=1.2.0"

 ###################################
 ## Some repos dont have releases.
@@ -88,6 +81,10 @@
  name = "github.com/jmhodges/levigo"
  revision = "c42d9e0ca023e2198120196f842701bb4c55d7b9"

+[[constraint]]
+  name = "github.com/ebuchman/fail-test"
+  revision = "95f809107225be108efcf10a3509e4ea6ceef3c4"
+
 # last revision used by go-crypto
 [[constraint]]
  name = "github.com/btcsuite/btcutil"
@@ -97,6 +94,11 @@
  name = "github.com/tendermint/btcd"
  revision = "e5840949ff4fff0c56f9b6a541e22b63581ea9df"

+# Haven't made a release since 2016.
+[[constraint]]
+  name = "github.com/prometheus/client_golang"
+  revision = "ae27198cdd90bf12cd134ad79d1366a6cf49f632"
+
 [[constraint]]
  name = "github.com/rcrowley/go-metrics"
  revision = "e2704e165165ec55d062f5919b4b29494e9fa790"
--- a/12
+++ b/12
@@ -17,6 +17,7 @@ all: check build test install

 check: check_tools get_vendor_deps

+
 ########################################
 ### Build Tendermint

@@ -32,13 +33,10 @@ build_race:
 install:
 	CGO_ENABLED=0 go install  $(BUILD_FLAGS) -tags $(BUILD_TAGS) ./cmd/tendermint

-install_c:
-	CGO_ENABLED=1 go install  $(BUILD_FLAGS) -tags "$(BUILD_TAGS) gcc" ./cmd/tendermint
-
 ########################################
 ### Protobuf

-protoc_all: protoc_libs protoc_merkle protoc_abci protoc_grpc protoc_proto3types
+protoc_all: protoc_libs protoc_merkle protoc_abci protoc_grpc

 %.pb.go: %.proto
 	## If you get the following error,
@@ -54,8 +52,6 @@ protoc_all: protoc_libs protoc_merkle protoc_abci protoc_grpc protoc_proto3types
 # see protobuf section above
 protoc_abci: abci/types/types.pb.go

-protoc_proto3types: types/proto3/block.pb.go
-
 build_abci:
 	@go build -i ./abci/cmd/...

@@ -81,8 +77,6 @@ check_tools:
 get_tools:
 	@echo "--> Installing tools"
 	./scripts/get_tools.sh
-
-get_dev_tools:
 	@echo "--> Downloading linters (this may take awhile)"
 	$(GOPATH)/src/github.com/alecthomas/gometalinter/scripts/install.sh -b $(GOBIN)

@@ -331,4 +325,4 @@ build-slate:
 # To avoid unintended conflicts with file names, always add to .PHONY
 # unless there is a reason not to.
 # https://www.gnu.org/software/make/manual/html_node/Phony-Targets.html
-.PHONY: check build build_race build_abci dist install install_abci check_dep check_tools get_tools get_dev_tools update_tools get_vendor_deps draw_deps get_protoc protoc_abci protoc_libs gen_certs clean_certs grpc_dbserver test_cover test_apps test_persistence test_p2p test test_race test_integrations test_release test100 vagrant_test fmt rpc-docs build-linux localnet-start localnet-stop build-docker build-docker-localnode sentry-start sentry-config sentry-stop build-slate protoc_grpc protoc_all build_c install_c
+.PHONY: check build build_race build_abci dist install install_abci check_dep check_tools get_tools update_tools get_vendor_deps draw_deps get_protoc protoc_abci protoc_libs gen_certs clean_certs grpc_dbserver test_cover test_apps test_persistence test_p2p test test_race test_integrations test_release test100 vagrant_test fmt rpc-docs build-linux localnet-start localnet-stop build-docker build-docker-localnode sentry-start sentry-config sentry-stop build-slate protoc_grpc protoc_all
--- a/README.md
+++ b/README.md
@@ -36,12 +36,12 @@ We are also still making breaking changes to the protocol and the APIs.
 Thus, we tag the releases as *alpha software*.

 In any case, if you intend to run Tendermint in production,
-please [contact us](mailto:partners@tendermint.com) and [join the chat](https://riot.im/app/#/room/#tendermint:matrix.org).
+please [contact us](https://riot.im/app/#/room/#tendermint:matrix.org) :)

 ## Security

 To report a security vulnerability, see our [bug bounty
-program](https://hackerone.com/tendermint)
+program](https://tendermint.com/security).

 For examples of the kinds of bugs we're looking for, see [SECURITY.md](SECURITY.md)

@@ -51,18 +51,14 @@ Requirement|Notes
 ---|---
 Go version | Go1.10 or higher

-## Documentation
-
-Complete documentation can be found on the [website](https://tendermint.com/docs/).
-
-### Install
+## Install

 See the [install instructions](/docs/introduction/install.md)

-### Quick Start
+## Quick Start

- [Single node](/docs/introduction/quick-start.md)
- [Local cluster using docker-compose](/docs/networks/docker-compose.md)
+- [Single node](/docs/tendermint-core/using-tendermint.md)
+- [Local cluster using docker-compose](/networks/local)
 - [Remote cluster using terraform and ansible](/docs/networks/terraform-and-ansible.md)
 - [Join the Cosmos testnet](https://cosmos.network/testnet)

@@ -95,7 +91,6 @@ Additional documentation is found [here](/docs/tools).

 ### Research

-* [The latest gossip on BFT consensus](https://arxiv.org/abs/1807.04938)
 * [Master's Thesis on Tendermint](https://atrium.lib.uoguelph.ca/xmlui/handle/10214/9769)
 * [Original Whitepaper](https://tendermint.com/static/docs/tendermint.pdf)
 * [Blog](https://blog.cosmos.network/tendermint/home)
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,8 +1,7 @@
 # Security

 As part of our [Coordinated Vulnerability Disclosure
-Policy](https://tendermint.com/security), we operate a [bug
-bounty](https://hackerone.com/tendermint).
+Policy](https://tendermint.com/security), we operate a bug bounty.
 See the policy for more details on submissions and rewards.

 Here is a list of examples of the kinds of bugs we're most interested in:
--- a/UPGRADING.md
+++ b/UPGRADING.md
@@ -5,7 +5,7 @@ a newer version of Tendermint Core.

 ## v0.26.0

-New 0.26.0 release contains a lot of changes to core data types and protocols. It is not
+New 0.26.0 release contains a lot of changes to core data types. It is not
 compatible to the old versions and there is no straight forward way to update
 old data to be compatible with the new version.

@@ -33,7 +33,7 @@ to `prove`. To get proofs with your queries, ensure you set `prove=true`.
 Various version fields like `amino_version`, `p2p_version`, `consensus_version`,
 and `rpc_version` have been removed from the `node_info.other` and are
 consolidated under the tendermint semantic version (ie. `node_info.version`) and
-the new `block` and `p2p` protocol versions under `node_info.protocol_version`.
+the new `block` and `p2p` protocol versions under `node_info.protocol_version`..

 ### ABCI Changes

@@ -45,7 +45,7 @@ protobuf file for these changes.

 The `ResponseQuery.Proof` field is now structured as a `[]ProofOp` to support
 generalized Merkle tree constructions where the leaves of one Merkle tree are
-the root of another. If you don't need this functionality, and you used to
+the root of another. If you don't need this functionaluty, and you used to
 return `<proof bytes>` here, you should instead return a single `ProofOp` with
 just the `Data` field set:

@@ -79,10 +79,6 @@ The `node.RunForever` function was removed. Signal handling and running forever
 should instead be explicitly configured by the caller. See how we do it
 [here](https://github.com/tendermint/tendermint/blob/30519e8361c19f4bf320ef4d26288ebc621ad725/cmd/tendermint/commands/run_node.go#L60).

-### Other
-
-All hashes, except for public key addresses, are now 32-bytes.
-
 ## v0.25.0

 This release has minimal impact.
--- a/2
+++ b/2
@@ -53,6 +53,6 @@ Vagrant.configure("2") do |config|

    # get all deps and tools, ready to install/test
    su - vagrant  -c 'source /home/vagrant/.bash_profile'
-    su - vagrant -c 'cd /home/vagrant/go/src/github.com/tendermint/tendermint && make get_tools && make get_dev_tools && make get_vendor_deps'
+    su - vagrant -c 'cd /home/vagrant/go/src/github.com/tendermint/tendermint && make get_tools && make get_vendor_deps'
  SHELL
 end
--- a/abci/README.md
+++ b/abci/README.md
@@ -1,5 +1,7 @@
 # Application BlockChain Interface (ABCI)

+[![CircleCI](https://circleci.com/gh/tendermint/abci.svg?style=svg)](https://circleci.com/gh/tendermint/abci)
+
 Blockchains are systems for multi-master state machine replication.
 **ABCI** is an interface that defines the boundary between the replication engine (the blockchain),
 and the state machine (the application).
@@ -10,28 +12,160 @@ Previously, the ABCI was referred to as TMSP.

 The community has provided a number of addtional implementations, see the [Tendermint Ecosystem](https://tendermint.com/ecosystem)

-
-## Installation & Usage
-
-To get up and running quickly, see the [getting started guide](../docs/app-dev/getting-started.md) along with the [abci-cli documentation](../docs/app-dev/abci-cli.md) which will go through the examples found in the [examples](./example/) directory.
-
 ## Specification

 A detailed description of the ABCI methods and message types is contained in:

- [The main spec](../docs/spec/abci/abci.md)
- [A protobuf file](./types/types.proto)
- [A Go interface](./types/application.go)
+- [A prose specification](specification.md)
+- [A protobuf file](https://github.com/tendermint/tendermint/blob/master/abci/types/types.proto)
+- [A Go interface](https://github.com/tendermint/tendermint/blob/master/abci/types/application.go).
+
+For more background information on ABCI, motivations, and tendermint, please visit [the documentation](https://tendermint.com/docs/).
+The two guides to focus on are the `Application Development Guide` and `Using ABCI-CLI`.
+

 ## Protocol Buffers

-To compile the protobuf file, run (from the root of the repo):
+To compile the protobuf file, run:

 ```
-make protoc_abci
+cd $GOPATH/src/github.com/tendermint/tendermint/; make protoc_abci
 ```

 See `protoc --help` and [the Protocol Buffers site](https://developers.google.com/protocol-buffers)
-for details on compiling for other languages. Note we also include a [GRPC](https://www.grpc.io/docs)
+for details on compiling for other languages. Note we also include a [GRPC](http://www.grpc.io/docs)
 service definition.

+## Install ABCI-CLI
+
+The `abci-cli` is a simple tool for debugging ABCI servers and running some
+example apps. To install it:
+
+```
+mkdir -p $GOPATH/src/github.com/tendermint
+cd $GOPATH/src/github.com/tendermint
+git clone https://github.com/tendermint/tendermint.git
+cd tendermint
+make get_tools
+make get_vendor_deps
+make install_abci
+```
+
+## Implementation
+
+We provide three implementations of the ABCI in Go:
+
+- Golang in-process
+- ABCI-socket
+- GRPC
+
+Note the GRPC version is maintained primarily to simplify onboarding and prototyping and is not receiving the same
+attention to security and performance as the others
+
+### In Process
+
+The simplest implementation just uses function calls within Go.
+This means ABCI applications written in Golang can be compiled with TendermintCore and run as a single binary.
+
+See the [examples](#examples) below for more information.
+
+### Socket (TSP)
+
+ABCI is best implemented as a streaming protocol.
+The socket implementation provides for asynchronous, ordered message passing over unix or tcp.
+Messages are serialized using Protobuf3 and length-prefixed with a [signed Varint](https://developers.google.com/protocol-buffers/docs/encoding?csw=1#signed-integers)
+
+For example, if the Protobuf3 encoded ABCI message is `0xDEADBEEF` (4 bytes), the length-prefixed message is `0x08DEADBEEF`, since `0x08` is the signed varint
+encoding of `4`. If the Protobuf3 encoded ABCI message is 65535 bytes long, the length-prefixed message would be like `0xFEFF07...`.
+
+Note the benefit of using this `varint` encoding over the old version (where integers were encoded as `<len of len><big endian len>` is that
+it is the standard way to encode integers in Protobuf. It is also generally shorter.
+
+### GRPC
+
+GRPC is an rpc framework native to Protocol Buffers with support in many languages.
+Implementing the ABCI using GRPC can allow for faster prototyping, but is expected to be much slower than
+the ordered, asynchronous socket protocol. The implementation has also not received as much testing or review.
+
+Note the length-prefixing used in the socket implementation does not apply for GRPC.
+
+## Usage
+
+The `abci-cli` tool wraps an ABCI client and can be used for probing/testing an ABCI server.
+For instance, `abci-cli test` will run a test sequence against a listening server running the Counter application (see below).
+It can also be used to run some example applications.
+See [the documentation](https://tendermint.com/docs/) for more details.
+
+### Examples
+
+Check out the variety of example applications in the [example directory](example/).
+It also contains the code refered to by the `counter` and `kvstore` apps; these apps come
+built into the `abci-cli` binary.
+
+#### Counter
+
+The `abci-cli counter` application illustrates nonce checking in transactions. It's code looks like:
+
+```golang
+func cmdCounter(cmd *cobra.Command, args []string) error {
+
+	app := counter.NewCounterApplication(flagSerial)
+
+	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
+
+	// Start the listener
+	srv, err := server.NewServer(flagAddrC, flagAbci, app)
+	if err != nil {
+		return err
+	}
+	srv.SetLogger(logger.With("module", "abci-server"))
+	if err := srv.Start(); err != nil {
+		return err
+	}
+
+	// Wait forever
+	cmn.TrapSignal(func() {
+		// Cleanup
+		srv.Stop()
+	})
+	return nil
+}
+```
+
+and can be found in [this file](cmd/abci-cli/abci-cli.go).
+
+#### kvstore
+
+The `abci-cli kvstore` application, which illustrates a simple key-value Merkle tree
+
+```golang
+func cmdKVStore(cmd *cobra.Command, args []string) error {
+	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
+
+	// Create the application - in memory or persisted to disk
+	var app types.Application
+	if flagPersist == "" {
+		app = kvstore.NewKVStoreApplication()
+	} else {
+		app = kvstore.NewPersistentKVStoreApplication(flagPersist)
+		app.(*kvstore.PersistentKVStoreApplication).SetLogger(logger.With("module", "kvstore"))
+	}
+
+	// Start the listener
+	srv, err := server.NewServer(flagAddrD, flagAbci, app)
+	if err != nil {
+		return err
+	}
+	srv.SetLogger(logger.With("module", "abci-server"))
+	if err := srv.Start(); err != nil {
+		return err
+	}
+
+	// Wait forever
+	cmn.TrapSignal(func() {
+		// Cleanup
+		srv.Stop()
+	})
+	return nil
+}
+```
--- a/abci/client/client.go
+++ b/abci/client/client.go
@@ -105,8 +105,8 @@ func (reqRes *ReqRes) SetCallback(cb func(res *types.Response)) {
 		return
 	}

+	defer reqRes.mtx.Unlock()
 	reqRes.cb = cb
-	reqRes.mtx.Unlock()
 }

 func (reqRes *ReqRes) GetCallback() func(*types.Response) {
--- a/abci/client/grpc_client.go
+++ b/abci/client/grpc_client.go
@@ -54,7 +54,7 @@ RETRY_LOOP:
 			if cli.mustConnect {
 				return err
 			}
-			cli.Logger.Error(fmt.Sprintf("abci.grpcClient failed to connect to %v.  Retrying...\n", cli.addr), "err", err)
+			cli.Logger.Error(fmt.Sprintf("abci.grpcClient failed to connect to %v.  Retrying...\n", cli.addr))
 			time.Sleep(time.Second * dialRetryIntervalSeconds)
 			continue RETRY_LOOP
 		}
@@ -111,8 +111,8 @@ func (cli *grpcClient) Error() error {
 // NOTE: callback may get internally generated flush responses.
 func (cli *grpcClient) SetResponseCallback(resCb Callback) {
 	cli.mtx.Lock()
+	defer cli.mtx.Unlock()
 	cli.resCb = resCb
-	cli.mtx.Unlock()
 }

 //----------------------------------------
--- a/abci/client/local_client.go
+++ b/abci/client/local_client.go
@@ -9,13 +9,8 @@ import (

 var _ Client = (*localClient)(nil)

-// NOTE: use defer to unlock mutex because Application might panic (e.g., in
-// case of malicious tx or query). It only makes sense for publicly exposed
-// methods like CheckTx (/broadcast_tx_* RPC endpoint) or Query (/abci_query
-// RPC endpoint), but defers are used everywhere for the sake of consistency.
 type localClient struct {
 	cmn.BaseService
-
 	mtx *sync.Mutex
 	types.Application
 	Callback
@@ -35,8 +30,8 @@ func NewLocalClient(mtx *sync.Mutex, app types.Application) *localClient {

 func (app *localClient) SetResponseCallback(cb Callback) {
 	app.mtx.Lock()
+	defer app.mtx.Unlock()
 	app.Callback = cb
-	app.mtx.Unlock()
 }

 // TODO: change types.Application to include Error()?
@@ -50,9 +45,6 @@ func (app *localClient) FlushAsync() *ReqRes {
 }

 func (app *localClient) EchoAsync(msg string) *ReqRes {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	return app.callback(
 		types.ToRequestEcho(msg),
 		types.ToResponseEcho(msg),
@@ -61,9 +53,8 @@ func (app *localClient) EchoAsync(msg string) *ReqRes {

 func (app *localClient) InfoAsync(req types.RequestInfo) *ReqRes {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.Info(req)
+	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestInfo(req),
 		types.ToResponseInfo(res),
@@ -72,9 +63,8 @@ func (app *localClient) InfoAsync(req types.RequestInfo) *ReqRes {

 func (app *localClient) SetOptionAsync(req types.RequestSetOption) *ReqRes {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.SetOption(req)
+	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestSetOption(req),
 		types.ToResponseSetOption(res),
@@ -83,9 +73,8 @@ func (app *localClient) SetOptionAsync(req types.RequestSetOption) *ReqRes {

 func (app *localClient) DeliverTxAsync(tx []byte) *ReqRes {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.DeliverTx(tx)
+	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestDeliverTx(tx),
 		types.ToResponseDeliverTx(res),
@@ -94,9 +83,8 @@ func (app *localClient) DeliverTxAsync(tx []byte) *ReqRes {

 func (app *localClient) CheckTxAsync(tx []byte) *ReqRes {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.CheckTx(tx)
+	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestCheckTx(tx),
 		types.ToResponseCheckTx(res),
@@ -105,9 +93,8 @@ func (app *localClient) CheckTxAsync(tx []byte) *ReqRes {

 func (app *localClient) QueryAsync(req types.RequestQuery) *ReqRes {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.Query(req)
+	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestQuery(req),
 		types.ToResponseQuery(res),
@@ -116,9 +103,8 @@ func (app *localClient) QueryAsync(req types.RequestQuery) *ReqRes {

 func (app *localClient) CommitAsync() *ReqRes {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.Commit()
+	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestCommit(),
 		types.ToResponseCommit(res),
@@ -127,20 +113,19 @@ func (app *localClient) CommitAsync() *ReqRes {

 func (app *localClient) InitChainAsync(req types.RequestInitChain) *ReqRes {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.InitChain(req)
-	return app.callback(
+	reqRes := app.callback(
 		types.ToRequestInitChain(req),
 		types.ToResponseInitChain(res),
 	)
+	app.mtx.Unlock()
+	return reqRes
 }

 func (app *localClient) BeginBlockAsync(req types.RequestBeginBlock) *ReqRes {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.BeginBlock(req)
+	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestBeginBlock(req),
 		types.ToResponseBeginBlock(res),
@@ -149,9 +134,8 @@ func (app *localClient) BeginBlockAsync(req types.RequestBeginBlock) *ReqRes {

 func (app *localClient) EndBlockAsync(req types.RequestEndBlock) *ReqRes {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.EndBlock(req)
+	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestEndBlock(req),
 		types.ToResponseEndBlock(res),
@@ -170,73 +154,64 @@ func (app *localClient) EchoSync(msg string) (*types.ResponseEcho, error) {

 func (app *localClient) InfoSync(req types.RequestInfo) (*types.ResponseInfo, error) {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.Info(req)
+	app.mtx.Unlock()
 	return &res, nil
 }

 func (app *localClient) SetOptionSync(req types.RequestSetOption) (*types.ResponseSetOption, error) {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.SetOption(req)
+	app.mtx.Unlock()
 	return &res, nil
 }

 func (app *localClient) DeliverTxSync(tx []byte) (*types.ResponseDeliverTx, error) {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.DeliverTx(tx)
+	app.mtx.Unlock()
 	return &res, nil
 }

 func (app *localClient) CheckTxSync(tx []byte) (*types.ResponseCheckTx, error) {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.CheckTx(tx)
+	app.mtx.Unlock()
 	return &res, nil
 }

 func (app *localClient) QuerySync(req types.RequestQuery) (*types.ResponseQuery, error) {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.Query(req)
+	app.mtx.Unlock()
 	return &res, nil
 }

 func (app *localClient) CommitSync() (*types.ResponseCommit, error) {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.Commit()
+	app.mtx.Unlock()
 	return &res, nil
 }

 func (app *localClient) InitChainSync(req types.RequestInitChain) (*types.ResponseInitChain, error) {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.InitChain(req)
+	app.mtx.Unlock()
 	return &res, nil
 }

 func (app *localClient) BeginBlockSync(req types.RequestBeginBlock) (*types.ResponseBeginBlock, error) {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.BeginBlock(req)
+	app.mtx.Unlock()
 	return &res, nil
 }

 func (app *localClient) EndBlockSync(req types.RequestEndBlock) (*types.ResponseEndBlock, error) {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
 	res := app.Application.EndBlock(req)
+	app.mtx.Unlock()
 	return &res, nil
 }

--- a/abci/client/socket_client.go
+++ b/abci/client/socket_client.go
@@ -67,7 +67,7 @@ RETRY_LOOP:
 			if cli.mustConnect {
 				return err
 			}
-			cli.Logger.Error(fmt.Sprintf("abci.socketClient failed to connect to %v.  Retrying...", cli.addr), "err", err)
+			cli.Logger.Error(fmt.Sprintf("abci.socketClient failed to connect to %v.  Retrying...", cli.addr))
 			time.Sleep(time.Second * dialRetryIntervalSeconds)
 			continue RETRY_LOOP
 		}
@@ -118,8 +118,8 @@ func (cli *socketClient) Error() error {
 // NOTE: callback may get internally generated flush responses.
 func (cli *socketClient) SetResponseCallback(resCb Callback) {
 	cli.mtx.Lock()
+	defer cli.mtx.Unlock()
 	cli.resCb = resCb
-	cli.mtx.Unlock()
 }

 //----------------------------------------
--- a/abci/types/types.pb.go
+++ b/abci/types/types.pb.go
--- a/abci/types/types.proto
+++ b/abci/types/types.proto
@@ -74,6 +74,7 @@ message RequestQuery {
  bool prove = 4;
 }

+// NOTE: validators here have empty pubkeys.
 message RequestBeginBlock {
  bytes hash = 1;
  Header header = 2 [(gogoproto.nullable)=false];
@@ -207,13 +208,12 @@ message ResponseCommit {
 // ConsensusParams contains all consensus-relevant parameters
 // that can be adjusted by the abci app
 message ConsensusParams {
-  BlockSizeParams block_size = 1;
-  EvidenceParams evidence = 2;
-  ValidatorParams validator = 3;
+  BlockSize block_size = 1;
+  EvidenceParams evidence_params = 2;
 }

 // BlockSize contains limits on the block size.
-message BlockSizeParams {
+message BlockSize {
  // Note: must be greater than 0
  int64 max_bytes = 1;
  // Note: must be greater or equal to -1
@@ -226,11 +226,6 @@ message EvidenceParams {
  int64 max_age = 1;
 }

-// ValidatorParams contains limits on validators.
-message ValidatorParams {
-  repeated string pub_key_types = 1;
-}
-
 message LastCommitInfo {
  int32 round = 1;
  repeated VoteInfo votes = 2 [(gogoproto.nullable)=false];
--- a/abci/types/typespb_test.go
+++ b/abci/types/typespb_test.go
@@ -1479,15 +1479,15 @@ func TestConsensusParamsMarshalTo(t *testing.T) {
 	}
 }

-func TestBlockSizeParamsProto(t *testing.T) {
+func TestBlockSizeProto(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedBlockSizeParams(popr, false)
+	p := NewPopulatedBlockSize(popr, false)
 	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
-	msg := &BlockSizeParams{}
+	msg := &BlockSize{}
 	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -1510,10 +1510,10 @@ func TestBlockSizeParamsProto(t *testing.T) {
 	}
 }

-func TestBlockSizeParamsMarshalTo(t *testing.T) {
+func TestBlockSizeMarshalTo(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedBlockSizeParams(popr, false)
+	p := NewPopulatedBlockSize(popr, false)
 	size := p.Size()
 	dAtA := make([]byte, size)
 	for i := range dAtA {
@@ -1523,7 +1523,7 @@ func TestBlockSizeParamsMarshalTo(t *testing.T) {
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
-	msg := &BlockSizeParams{}
+	msg := &BlockSize{}
 	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -1591,62 +1591,6 @@ func TestEvidenceParamsMarshalTo(t *testing.T) {
 	}
 }

-func TestValidatorParamsProto(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedValidatorParams(popr, false)
-	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
-	if err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	msg := &ValidatorParams{}
-	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	littlefuzz := make([]byte, len(dAtA))
-	copy(littlefuzz, dAtA)
-	for i := range dAtA {
-		dAtA[i] = byte(popr.Intn(256))
-	}
-	if !p.Equal(msg) {
-		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
-	}
-	if len(littlefuzz) > 0 {
-		fuzzamount := 100
-		for i := 0; i < fuzzamount; i++ {
-			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
-			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
-		}
-		// shouldn't panic
-		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
-	}
-}
-
-func TestValidatorParamsMarshalTo(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedValidatorParams(popr, false)
-	size := p.Size()
-	dAtA := make([]byte, size)
-	for i := range dAtA {
-		dAtA[i] = byte(popr.Intn(256))
-	}
-	_, err := p.MarshalTo(dAtA)
-	if err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	msg := &ValidatorParams{}
-	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	for i := range dAtA {
-		dAtA[i] = byte(popr.Intn(256))
-	}
-	if !p.Equal(msg) {
-		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
-	}
-}
-
 func TestLastCommitInfoProto(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
@@ -2675,16 +2619,16 @@ func TestConsensusParamsJSON(t *testing.T) {
 		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
 	}
 }
-func TestBlockSizeParamsJSON(t *testing.T) {
+func TestBlockSizeJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedBlockSizeParams(popr, true)
+	p := NewPopulatedBlockSize(popr, true)
 	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
 	jsondata, err := marshaler.MarshalToString(p)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
-	msg := &BlockSizeParams{}
+	msg := &BlockSize{}
 	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
 	if err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
@@ -2711,24 +2655,6 @@ func TestEvidenceParamsJSON(t *testing.T) {
 		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
 	}
 }
-func TestValidatorParamsJSON(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedValidatorParams(popr, true)
-	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
-	jsondata, err := marshaler.MarshalToString(p)
-	if err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	msg := &ValidatorParams{}
-	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
-	if err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	if !p.Equal(msg) {
-		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
-	}
-}
 func TestLastCommitInfoJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
@@ -3637,12 +3563,12 @@ func TestConsensusParamsProtoCompactText(t *testing.T) {
 	}
 }

-func TestBlockSizeParamsProtoText(t *testing.T) {
+func TestBlockSizeProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedBlockSizeParams(popr, true)
+	p := NewPopulatedBlockSize(popr, true)
 	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
-	msg := &BlockSizeParams{}
+	msg := &BlockSize{}
 	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3651,12 +3577,12 @@ func TestBlockSizeParamsProtoText(t *testing.T) {
 	}
 }

-func TestBlockSizeParamsProtoCompactText(t *testing.T) {
+func TestBlockSizeProtoCompactText(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedBlockSizeParams(popr, true)
+	p := NewPopulatedBlockSize(popr, true)
 	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
-	msg := &BlockSizeParams{}
+	msg := &BlockSize{}
 	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
 		t.Fatalf("seed = %d, err = %v", seed, err)
 	}
@@ -3693,34 +3619,6 @@ func TestEvidenceParamsProtoCompactText(t *testing.T) {
 	}
 }

-func TestValidatorParamsProtoText(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedValidatorParams(popr, true)
-	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
-	msg := &ValidatorParams{}
-	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	if !p.Equal(msg) {
-		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
-	}
-}
-
-func TestValidatorParamsProtoCompactText(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedValidatorParams(popr, true)
-	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
-	msg := &ValidatorParams{}
-	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	if !p.Equal(msg) {
-		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
-	}
-}
-
 func TestLastCommitInfoProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
@@ -4573,10 +4471,10 @@ func TestConsensusParamsSize(t *testing.T) {
 	}
 }

-func TestBlockSizeParamsSize(t *testing.T) {
+func TestBlockSizeSize(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedBlockSizeParams(popr, true)
+	p := NewPopulatedBlockSize(popr, true)
 	size2 := github_com_gogo_protobuf_proto.Size(p)
 	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
 	if err != nil {
@@ -4617,28 +4515,6 @@ func TestEvidenceParamsSize(t *testing.T) {
 	}
 }

-func TestValidatorParamsSize(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedValidatorParams(popr, true)
-	size2 := github_com_gogo_protobuf_proto.Size(p)
-	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
-	if err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	size := p.Size()
-	if len(dAtA) != size {
-		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
-	}
-	if size2 != size {
-		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
-	}
-	size3 := github_com_gogo_protobuf_proto.Size(p)
-	if size3 != size {
-		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
-	}
-}
-
 func TestLastCommitInfoSize(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
--- a/blockchain/pool.go
+++ b/blockchain/pool.go
@@ -168,12 +168,9 @@ func (pool *BlockPool) IsCaughtUp() bool {
 		return false
 	}

-	// Some conditions to determine if we're caught up.
-	// Ensures we've either received a block or waited some amount of time,
-	// and that we're synced to the highest known height. Note we use maxPeerHeight - 1
-	// because to sync block H requires block H+1 to verify the LastCommit.
-	receivedBlockOrTimedOut := pool.height > 0 || time.Since(pool.startTime) > 5*time.Second
-	ourChainIsLongestAmongPeers := pool.maxPeerHeight == 0 || pool.height >= (pool.maxPeerHeight-1)
+	// some conditions to determine if we're caught up
+	receivedBlockOrTimedOut := (pool.height > 0 || time.Since(pool.startTime) > 5*time.Second)
+	ourChainIsLongestAmongPeers := pool.maxPeerHeight == 0 || pool.height >= pool.maxPeerHeight
 	isCaughtUp := receivedBlockOrTimedOut && ourChainIsLongestAmongPeers
 	return isCaughtUp
 }
@@ -255,8 +252,7 @@ func (pool *BlockPool) AddBlock(peerID p2p.ID, block *types.Block, blockSize int
 			peer.decrPending(blockSize)
 		}
 	} else {
-		pool.Logger.Info("invalid peer", "peer", peerID, "blockHeight", block.Height)
-		pool.sendError(errors.New("invalid peer"), peerID)
+		// Bad peer?
 	}
 }

@@ -296,7 +292,7 @@ func (pool *BlockPool) RemovePeer(peerID p2p.ID) {
 func (pool *BlockPool) removePeer(peerID p2p.ID) {
 	for _, requester := range pool.requesters {
 		if requester.getPeerID() == peerID {
-			requester.redo(peerID)
+			requester.redo()
 		}
 	}
 	delete(pool.peers, peerID)
@@ -330,11 +326,8 @@ func (pool *BlockPool) makeNextRequester() {
 	defer pool.mtx.Unlock()

 	nextHeight := pool.height + pool.requestersLen()
-	if nextHeight > pool.maxPeerHeight {
-		return
-	}
-
 	request := newBPRequester(pool, nextHeight)
+	// request.SetLogger(pool.Logger.With("height", nextHeight))

 	pool.requesters[nextHeight] = request
 	atomic.AddInt32(&pool.numPending, 1)
@@ -460,7 +453,7 @@ type bpRequester struct {
 	pool       *BlockPool
 	height     int64
 	gotBlockCh chan struct{}
-	redoCh     chan p2p.ID //redo may send multitime, add peerId to identify repeat
+	redoCh     chan struct{}

 	mtx    sync.Mutex
 	peerID p2p.ID
@@ -472,7 +465,7 @@ func newBPRequester(pool *BlockPool, height int64) *bpRequester {
 		pool:       pool,
 		height:     height,
 		gotBlockCh: make(chan struct{}, 1),
-		redoCh:     make(chan p2p.ID, 1),
+		redoCh:     make(chan struct{}, 1),

 		peerID: "",
 		block:  nil,
@@ -531,9 +524,9 @@ func (bpr *bpRequester) reset() {
 // Tells bpRequester to pick another peer and try again.
 // NOTE: Nonblocking, and does nothing if another redo
 // was already requested.
-func (bpr *bpRequester) redo(peerId p2p.ID) {
+func (bpr *bpRequester) redo() {
 	select {
-	case bpr.redoCh <- peerId:
+	case bpr.redoCh <- struct{}{}:
 	default:
 	}
 }
@@ -572,13 +565,9 @@ OUTER_LOOP:
 				return
 			case <-bpr.Quit():
 				return
-			case peerID := <-bpr.redoCh:
-				if peerID == bpr.peerID {
-					bpr.reset()
-					continue OUTER_LOOP
-				} else {
-					continue WAIT_LOOP
-				}
+			case <-bpr.redoCh:
+				bpr.reset()
+				continue OUTER_LOOP
 			case <-bpr.gotBlockCh:
 				// We got a block!
 				// Continue the for-loop and wait til Quit.
--- a/blockchain/pool_test.go
+++ b/blockchain/pool_test.go
@@ -16,52 +16,16 @@ func init() {
 }

 type testPeer struct {
-	id        p2p.ID
-	height    int64
-	inputChan chan inputData //make sure each peer's data is sequential
+	id     p2p.ID
+	height int64
 }

-type inputData struct {
-	t       *testing.T
-	pool    *BlockPool
-	request BlockRequest
-}
-
-func (p testPeer) runInputRoutine() {
-	go func() {
-		for input := range p.inputChan {
-			p.simulateInput(input)
-		}
-	}()
-}
-
-// Request desired, pretend like we got the block immediately.
-func (p testPeer) simulateInput(input inputData) {
-	block := &types.Block{Header: types.Header{Height: input.request.Height}}
-	input.pool.AddBlock(input.request.PeerID, block, 123)
-	input.t.Logf("Added block from peer %v (height: %v)", input.request.PeerID, input.request.Height)
-}
-
-type testPeers map[p2p.ID]testPeer
-
-func (ps testPeers) start() {
-	for _, v := range ps {
-		v.runInputRoutine()
-	}
-}
-
-func (ps testPeers) stop() {
-	for _, v := range ps {
-		close(v.inputChan)
-	}
-}
-
-func makePeers(numPeers int, minHeight, maxHeight int64) testPeers {
-	peers := make(testPeers, numPeers)
+func makePeers(numPeers int, minHeight, maxHeight int64) map[p2p.ID]testPeer {
+	peers := make(map[p2p.ID]testPeer, numPeers)
 	for i := 0; i < numPeers; i++ {
 		peerID := p2p.ID(cmn.RandStr(12))
 		height := minHeight + cmn.RandInt63n(maxHeight-minHeight)
-		peers[peerID] = testPeer{peerID, height, make(chan inputData, 10)}
+		peers[peerID] = testPeer{peerID, height}
 	}
 	return peers
 }
@@ -81,9 +45,6 @@ func TestBasic(t *testing.T) {

 	defer pool.Stop()

-	peers.start()
-	defer peers.stop()
-
 	// Introduce each peer.
 	go func() {
 		for _, peer := range peers {
@@ -116,8 +77,12 @@ func TestBasic(t *testing.T) {
 			if request.Height == 300 {
 				return // Done!
 			}
-
-			peers[request.PeerID].inputChan <- inputData{t, pool, request}
+			// Request desired, pretend like we got the block immediately.
+			go func() {
+				block := &types.Block{Header: types.Header{Height: request.Height}}
+				pool.AddBlock(request.PeerID, block, 123)
+				t.Logf("Added block from peer %v (height: %v)", request.PeerID, request.Height)
+			}()
 		}
 	}
 }
--- a/blockchain/reactor.go
+++ b/blockchain/reactor.go
@@ -1,7 +1,6 @@
 package blockchain

 import (
-	"errors"
 	"fmt"
 	"reflect"
 	"time"
@@ -181,12 +180,6 @@ func (bcR *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)
 		return
 	}

-	if err = msg.ValidateBasic(); err != nil {
-		bcR.Logger.Error("Peer sent us invalid msg", "peer", src, "msg", msg, "err", err)
-		bcR.Switch.StopPeerForError(src, err)
-		return
-	}
-
 	bcR.Logger.Debug("Receive", "src", src, "chID", chID, "msg", msg)

 	switch msg := msg.(type) {
@@ -195,6 +188,7 @@ func (bcR *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)
 			// Unfortunately not queued since the queue is full.
 		}
 	case *bcBlockResponseMessage:
+		// Got a block.
 		bcR.pool.AddBlock(src.ID(), msg.Block, len(msgBytes))
 	case *bcStatusRequestMessage:
 		// Send peer our state.
@@ -264,12 +258,8 @@ FOR_LOOP:
 				bcR.Logger.Info("Time to switch to consensus reactor!", "height", height)
 				bcR.pool.Stop()

-				conR, ok := bcR.Switch.Reactor("CONSENSUS").(consensusReactor)
-				if ok {
-					conR.SwitchToConsensus(state, blocksSynced)
-				} else {
-					// should only happen during testing
-				}
+				conR := bcR.Switch.Reactor("CONSENSUS").(consensusReactor)
+				conR.SwitchToConsensus(state, blocksSynced)

 				break FOR_LOOP
 			}
@@ -318,13 +308,6 @@ FOR_LOOP:
 					// still need to clean up the rest.
 					bcR.Switch.StopPeerForError(peer, fmt.Errorf("BlockchainReactor validation error: %v", err))
 				}
-				peerID2 := bcR.pool.RedoRequest(second.Height)
-				peer2 := bcR.Switch.Peers().Get(peerID2)
-				if peer2 != nil && peer2 != peer {
-					// NOTE: we've already removed the peer's request, but we
-					// still need to clean up the rest.
-					bcR.Switch.StopPeerForError(peer2, fmt.Errorf("BlockchainReactor validation error: %v", err))
-				}
 				continue FOR_LOOP
 			} else {
 				bcR.pool.PopRequest()
@@ -369,9 +352,7 @@ func (bcR *BlockchainReactor) BroadcastStatusRequest() error {
 // Messages

 // BlockchainMessage is a generic message for this reactor.
-type BlockchainMessage interface {
-	ValidateBasic() error
-}
+type BlockchainMessage interface{}

 func RegisterBlockchainMessages(cdc *amino.Codec) {
 	cdc.RegisterInterface((*BlockchainMessage)(nil), nil)
@@ -396,14 +377,6 @@ type bcBlockRequestMessage struct {
 	Height int64
 }

-// ValidateBasic performs basic validation.
-func (m *bcBlockRequestMessage) ValidateBasic() error {
-	if m.Height < 0 {
-		return errors.New("Negative Height")
-	}
-	return nil
-}
-
 func (m *bcBlockRequestMessage) String() string {
 	return fmt.Sprintf("[bcBlockRequestMessage %v]", m.Height)
 }
@@ -412,14 +385,6 @@ type bcNoBlockResponseMessage struct {
 	Height int64
 }

-// ValidateBasic performs basic validation.
-func (m *bcNoBlockResponseMessage) ValidateBasic() error {
-	if m.Height < 0 {
-		return errors.New("Negative Height")
-	}
-	return nil
-}
-
 func (brm *bcNoBlockResponseMessage) String() string {
 	return fmt.Sprintf("[bcNoBlockResponseMessage %d]", brm.Height)
 }
@@ -430,15 +395,6 @@ type bcBlockResponseMessage struct {
 	Block *types.Block
 }

-// ValidateBasic performs basic validation.
-func (m *bcBlockResponseMessage) ValidateBasic() error {
-	if err := m.Block.ValidateBasic(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
 func (m *bcBlockResponseMessage) String() string {
 	return fmt.Sprintf("[bcBlockResponseMessage %v]", m.Block.Height)
 }
@@ -449,14 +405,6 @@ type bcStatusRequestMessage struct {
 	Height int64
 }

-// ValidateBasic performs basic validation.
-func (m *bcStatusRequestMessage) ValidateBasic() error {
-	if m.Height < 0 {
-		return errors.New("Negative Height")
-	}
-	return nil
-}
-
 func (m *bcStatusRequestMessage) String() string {
 	return fmt.Sprintf("[bcStatusRequestMessage %v]", m.Height)
 }
@@ -467,14 +415,6 @@ type bcStatusResponseMessage struct {
 	Height int64
 }

-// ValidateBasic performs basic validation.
-func (m *bcStatusResponseMessage) ValidateBasic() error {
-	if m.Height < 0 {
-		return errors.New("Negative Height")
-	}
-	return nil
-}
-
 func (m *bcStatusResponseMessage) String() string {
 	return fmt.Sprintf("[bcStatusResponseMessage %v]", m.Height)
 }
--- a/blockchain/reactor_test.go
+++ b/blockchain/reactor_test.go
@@ -1,151 +1,72 @@
 package blockchain

 import (
-	"sort"
+	"net"
 	"testing"
-	"time"

-	"github.com/stretchr/testify/assert"
-
-	abci "github.com/tendermint/tendermint/abci/types"
-	cfg "github.com/tendermint/tendermint/config"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"
+
+	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
-	tmtime "github.com/tendermint/tendermint/types/time"
 )

-var config *cfg.Config
-
-func randGenesisDoc(numValidators int, randPower bool, minPower int64) (*types.GenesisDoc, []types.PrivValidator) {
-	validators := make([]types.GenesisValidator, numValidators)
-	privValidators := make([]types.PrivValidator, numValidators)
-	for i := 0; i < numValidators; i++ {
-		val, privVal := types.RandValidator(randPower, minPower)
-		validators[i] = types.GenesisValidator{
-			PubKey: val.PubKey,
-			Power:  val.VotingPower,
-		}
-		privValidators[i] = privVal
-	}
-	sort.Sort(types.PrivValidatorsByAddress(privValidators))
-
-	return &types.GenesisDoc{
-		GenesisTime: tmtime.Now(),
-		ChainID:     config.ChainID(),
-		Validators:  validators,
-	}, privValidators
-}
-
-func makeVote(header *types.Header, blockID types.BlockID, valset *types.ValidatorSet, privVal types.PrivValidator) *types.Vote {
-	addr := privVal.GetAddress()
-	idx, _ := valset.GetByAddress(addr)
-	vote := &types.Vote{
-		ValidatorAddress: addr,
-		ValidatorIndex:   idx,
-		Height:           header.Height,
-		Round:            1,
-		Timestamp:        tmtime.Now(),
-		Type:             types.PrecommitType,
-		BlockID:          blockID,
-	}
-
-	privVal.SignVote(header.ChainID, vote)
-
-	return vote
-}
-
-type BlockchainReactorPair struct {
-	reactor *BlockchainReactor
-	app     proxy.AppConns
-}
-
-func newBlockchainReactor(logger log.Logger, genDoc *types.GenesisDoc, privVals []types.PrivValidator, maxBlockHeight int64) BlockchainReactorPair {
-	if len(privVals) != 1 {
-		panic("only support one validator")
-	}
-
-	app := &testApp{}
-	cc := proxy.NewLocalClientCreator(app)
-	proxyApp := proxy.NewAppConns(cc)
-	err := proxyApp.Start()
-	if err != nil {
-		panic(cmn.ErrorWrap(err, "error start app"))
-	}
-
+func makeStateAndBlockStore(logger log.Logger) (sm.State, *BlockStore) {
+	config := cfg.ResetTestRoot("blockchain_reactor_test")
+	// blockDB := dbm.NewDebugDB("blockDB", dbm.NewMemDB())
+	// stateDB := dbm.NewDebugDB("stateDB", dbm.NewMemDB())
 	blockDB := dbm.NewMemDB()
 	stateDB := dbm.NewMemDB()
 	blockStore := NewBlockStore(blockDB)
-
-	state, err := sm.LoadStateFromDBOrGenesisDoc(stateDB, genDoc)
+	state, err := sm.LoadStateFromDBOrGenesisFile(stateDB, config.GenesisFile())
 	if err != nil {
 		panic(cmn.ErrorWrap(err, "error constructing state from genesis file"))
 	}
+	return state, blockStore
+}

-	// Make the BlockchainReactor itself.
-	// NOTE we have to create and commit the blocks first because
-	// pool.height is determined from the store.
+func newBlockchainReactor(logger log.Logger, maxBlockHeight int64) *BlockchainReactor {
+	state, blockStore := makeStateAndBlockStore(logger)
+
+	// Make the blockchainReactor itself
 	fastSync := true
-	blockExec := sm.NewBlockExecutor(dbm.NewMemDB(), log.TestingLogger(), proxyApp.Consensus(),
+	var nilApp proxy.AppConnConsensus
+	blockExec := sm.NewBlockExecutor(dbm.NewMemDB(), log.TestingLogger(), nilApp,
 		sm.MockMempool{}, sm.MockEvidencePool{})

-	// let's add some blocks in
-	for blockHeight := int64(1); blockHeight <= maxBlockHeight; blockHeight++ {
-		lastCommit := &types.Commit{}
-		if blockHeight > 1 {
-			lastBlockMeta := blockStore.LoadBlockMeta(blockHeight - 1)
-			lastBlock := blockStore.LoadBlock(blockHeight - 1)
-
-			vote := makeVote(&lastBlock.Header, lastBlockMeta.BlockID, state.Validators, privVals[0])
-			lastCommit = &types.Commit{Precommits: []*types.Vote{vote}, BlockID: lastBlockMeta.BlockID}
-		}
-
-		thisBlock := makeBlock(blockHeight, state, lastCommit)
-
-		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
-		blockID := types.BlockID{thisBlock.Hash(), thisParts.Header()}
-
-		state, err = blockExec.ApplyBlock(state, blockID, thisBlock)
-		if err != nil {
-			panic(cmn.ErrorWrap(err, "error apply block"))
-		}
-
-		blockStore.SaveBlock(thisBlock, thisParts, lastCommit)
-	}
-
 	bcReactor := NewBlockchainReactor(state.Copy(), blockExec, blockStore, fastSync)
 	bcReactor.SetLogger(logger.With("module", "blockchain"))

-	return BlockchainReactorPair{bcReactor, proxyApp}
+	// Next: we need to set a switch in order for peers to be added in
+	bcReactor.Switch = p2p.NewSwitch(cfg.DefaultP2PConfig(), nil)
+
+	// Lastly: let's add some blocks in
+	for blockHeight := int64(1); blockHeight <= maxBlockHeight; blockHeight++ {
+		firstBlock := makeBlock(blockHeight, state)
+		secondBlock := makeBlock(blockHeight+1, state)
+		firstParts := firstBlock.MakePartSet(types.BlockPartSizeBytes)
+		blockStore.SaveBlock(firstBlock, firstParts, secondBlock.LastCommit)
+	}
+
+	return bcReactor
 }

 func TestNoBlockResponse(t *testing.T) {
-	config = cfg.ResetTestRoot("blockchain_reactor_test")
-	genDoc, privVals := randGenesisDoc(1, false, 30)
+	maxBlockHeight := int64(20)

-	maxBlockHeight := int64(65)
+	bcr := newBlockchainReactor(log.TestingLogger(), maxBlockHeight)
+	bcr.Start()
+	defer bcr.Stop()

-	reactorPairs := make([]BlockchainReactorPair, 2)
+	// Add some peers in
+	peer := newbcrTestPeer(p2p.ID(cmn.RandStr(12)))
+	bcr.AddPeer(peer)

-	reactorPairs[0] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, maxBlockHeight)
-	reactorPairs[1] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
-
-	p2p.MakeConnectedSwitches(config.P2P, 2, func(i int, s *p2p.Switch) *p2p.Switch {
-		s.AddReactor("BLOCKCHAIN", reactorPairs[i].reactor)
-		return s
-
-	}, p2p.Connect2Switches)
-
-	defer func() {
-		for _, r := range reactorPairs {
-			r.reactor.Stop()
-			r.app.Stop()
-		}
-	}()
+	chID := byte(0x01)

 	tests := []struct {
 		height   int64
@@ -157,100 +78,72 @@ func TestNoBlockResponse(t *testing.T) {
 		{100, false},
 	}

-	for {
-		if reactorPairs[1].reactor.pool.IsCaughtUp() {
-			break
-		}
-
-		time.Sleep(10 * time.Millisecond)
-	}
-
-	assert.Equal(t, maxBlockHeight, reactorPairs[0].reactor.store.Height())
-
+	// receive a request message from peer,
+	// wait for our response to be received on the peer
 	for _, tt := range tests {
-		block := reactorPairs[1].reactor.store.LoadBlock(tt.height)
+		reqBlockMsg := &bcBlockRequestMessage{tt.height}
+		reqBlockBytes := cdc.MustMarshalBinaryBare(reqBlockMsg)
+		bcr.Receive(chID, peer, reqBlockBytes)
+		msg := peer.lastBlockchainMessage()
+
 		if tt.existent {
-			assert.True(t, block != nil)
+			if blockMsg, ok := msg.(*bcBlockResponseMessage); !ok {
+				t.Fatalf("Expected to receive a block response for height %d", tt.height)
+			} else if blockMsg.Block.Height != tt.height {
+				t.Fatalf("Expected response to be for height %d, got %d", tt.height, blockMsg.Block.Height)
+			}
 		} else {
-			assert.True(t, block == nil)
+			if noBlockMsg, ok := msg.(*bcNoBlockResponseMessage); !ok {
+				t.Fatalf("Expected to receive a no block response for height %d", tt.height)
+			} else if noBlockMsg.Height != tt.height {
+				t.Fatalf("Expected response to be for height %d, got %d", tt.height, noBlockMsg.Height)
+			}
 		}
 	}
 }

+/*
 // NOTE: This is too hard to test without
 // an easy way to add test peer to switch
 // or without significant refactoring of the module.
 // Alternatively we could actually dial a TCP conn but
 // that seems extreme.
 func TestBadBlockStopsPeer(t *testing.T) {
-	config = cfg.ResetTestRoot("blockchain_reactor_test")
-	genDoc, privVals := randGenesisDoc(1, false, 30)
+	maxBlockHeight := int64(20)

-	maxBlockHeight := int64(148)
+	bcr := newBlockchainReactor(log.TestingLogger(), maxBlockHeight)
+	bcr.Start()
+	defer bcr.Stop()

-	otherChain := newBlockchainReactor(log.TestingLogger(), genDoc, privVals, maxBlockHeight)
-	defer func() {
-		otherChain.reactor.Stop()
-		otherChain.app.Stop()
-	}()
+	// Add some peers in
+	peer := newbcrTestPeer(p2p.ID(cmn.RandStr(12)))

-	reactorPairs := make([]BlockchainReactorPair, 4)
+	// XXX: This doesn't add the peer to anything,
+	// so it's hard to check that it's later removed
+	bcr.AddPeer(peer)
+	assert.True(t, bcr.Switch.Peers().Size() > 0)

-	reactorPairs[0] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, maxBlockHeight)
-	reactorPairs[1] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
-	reactorPairs[2] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
-	reactorPairs[3] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
-
-	switches := p2p.MakeConnectedSwitches(config.P2P, 4, func(i int, s *p2p.Switch) *p2p.Switch {
-		s.AddReactor("BLOCKCHAIN", reactorPairs[i].reactor)
-		return s
-
-	}, p2p.Connect2Switches)
-
-	defer func() {
-		for _, r := range reactorPairs {
-			r.reactor.Stop()
-			r.app.Stop()
-		}
-	}()
+	// send a bad block from the peer
+	// default blocks already dont have commits, so should fail
+	block := bcr.store.LoadBlock(3)
+	msg := &bcBlockResponseMessage{Block: block}
+	peer.Send(BlockchainChannel, struct{ BlockchainMessage }{msg})

+	ticker := time.NewTicker(time.Millisecond * 10)
+	timer := time.NewTimer(time.Second * 2)
+LOOP:
 	for {
-		if reactorPairs[3].reactor.pool.IsCaughtUp() {
-			break
+		select {
+		case <-ticker.C:
+			if bcr.Switch.Peers().Size() == 0 {
+				break LOOP
+			}
+		case <-timer.C:
+			t.Fatal("Timed out waiting to disconnect peer")
 		}
-
-		time.Sleep(1 * time.Second)
 	}
-
-	//at this time, reactors[0-3] is the newest
-	assert.Equal(t, 3, reactorPairs[1].reactor.Switch.Peers().Size())
-
-	//mark reactorPairs[3] is an invalid peer
-	reactorPairs[3].reactor.store = otherChain.reactor.store
-
-	lastReactorPair := newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
-	reactorPairs = append(reactorPairs, lastReactorPair)
-
-	switches = append(switches, p2p.MakeConnectedSwitches(config.P2P, 1, func(i int, s *p2p.Switch) *p2p.Switch {
-		s.AddReactor("BLOCKCHAIN", reactorPairs[len(reactorPairs)-1].reactor)
-		return s
-
-	}, p2p.Connect2Switches)...)
-
-	for i := 0; i < len(reactorPairs)-1; i++ {
-		p2p.Connect2Switches(switches, i, len(reactorPairs)-1)
-	}
-
-	for {
-		if lastReactorPair.reactor.pool.IsCaughtUp() || lastReactorPair.reactor.Switch.Peers().Size() == 0 {
-			break
-		}
-
-		time.Sleep(1 * time.Second)
-	}
-
-	assert.True(t, lastReactorPair.reactor.Switch.Peers().Size() < len(reactorPairs)-1)
 }
+*/

 //----------------------------------------------
 // utility funcs
@@ -262,41 +155,55 @@ func makeTxs(height int64) (txs []types.Tx) {
 	return txs
 }

-func makeBlock(height int64, state sm.State, lastCommit *types.Commit) *types.Block {
-	block, _ := state.MakeBlock(height, makeTxs(height), lastCommit, nil, state.Validators.GetProposer().Address)
+func makeBlock(height int64, state sm.State) *types.Block {
+	block, _ := state.MakeBlock(height, makeTxs(height), new(types.Commit), nil, state.Validators.GetProposer().Address)
 	return block
 }

-type testApp struct {
-	abci.BaseApplication
+// The Test peer
+type bcrTestPeer struct {
+	cmn.BaseService
+	id p2p.ID
+	ch chan interface{}
 }

-var _ abci.Application = (*testApp)(nil)
+var _ p2p.Peer = (*bcrTestPeer)(nil)

-func (app *testApp) Info(req abci.RequestInfo) (resInfo abci.ResponseInfo) {
-	return abci.ResponseInfo{}
+func newbcrTestPeer(id p2p.ID) *bcrTestPeer {
+	bcr := &bcrTestPeer{
+		id: id,
+		ch: make(chan interface{}, 2),
+	}
+	bcr.BaseService = *cmn.NewBaseService(nil, "bcrTestPeer", bcr)
+	return bcr
 }

-func (app *testApp) BeginBlock(req abci.RequestBeginBlock) abci.ResponseBeginBlock {
-	return abci.ResponseBeginBlock{}
+func (tp *bcrTestPeer) lastBlockchainMessage() interface{} { return <-tp.ch }
+
+func (tp *bcrTestPeer) TrySend(chID byte, msgBytes []byte) bool {
+	var msg BlockchainMessage
+	err := cdc.UnmarshalBinaryBare(msgBytes, &msg)
+	if err != nil {
+		panic(cmn.ErrorWrap(err, "Error while trying to parse a BlockchainMessage"))
+	}
+	if _, ok := msg.(*bcStatusResponseMessage); ok {
+		// Discard status response messages since they skew our results
+		// We only want to deal with:
+		// + bcBlockResponseMessage
+		// + bcNoBlockResponseMessage
+	} else {
+		tp.ch <- msg
+	}
+	return true
 }

-func (app *testApp) EndBlock(req abci.RequestEndBlock) abci.ResponseEndBlock {
-	return abci.ResponseEndBlock{}
-}
-
-func (app *testApp) DeliverTx(tx []byte) abci.ResponseDeliverTx {
-	return abci.ResponseDeliverTx{Tags: []cmn.KVPair{}}
-}
-
-func (app *testApp) CheckTx(tx []byte) abci.ResponseCheckTx {
-	return abci.ResponseCheckTx{}
-}
-
-func (app *testApp) Commit() abci.ResponseCommit {
-	return abci.ResponseCommit{}
-}
-
-func (app *testApp) Query(reqQuery abci.RequestQuery) (resQuery abci.ResponseQuery) {
-	return
-}
+func (tp *bcrTestPeer) Send(chID byte, msgBytes []byte) bool { return tp.TrySend(chID, msgBytes) }
+func (tp *bcrTestPeer) NodeInfo() p2p.NodeInfo               { return p2p.DefaultNodeInfo{} }
+func (tp *bcrTestPeer) Status() p2p.ConnectionStatus         { return p2p.ConnectionStatus{} }
+func (tp *bcrTestPeer) ID() p2p.ID                           { return tp.id }
+func (tp *bcrTestPeer) IsOutbound() bool                     { return false }
+func (tp *bcrTestPeer) IsPersistent() bool                   { return true }
+func (tp *bcrTestPeer) Get(s string) interface{}             { return s }
+func (tp *bcrTestPeer) Set(string, interface{})              {}
+func (tp *bcrTestPeer) RemoteIP() net.IP                     { return []byte{127, 0, 0, 1} }
+func (tp *bcrTestPeer) OriginalAddr() *p2p.NetAddress        { return nil }
--- a/blockchain/store_test.go
+++ b/blockchain/store_test.go
@@ -9,30 +9,13 @@ import (

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	cfg "github.com/tendermint/tendermint/config"
-	cmn "github.com/tendermint/tendermint/libs/common"
 	"github.com/tendermint/tendermint/libs/db"
-	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"
-	sm "github.com/tendermint/tendermint/state"

 	"github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
 )

-func makeStateAndBlockStore(logger log.Logger) (sm.State, *BlockStore) {
-	config := cfg.ResetTestRoot("blockchain_reactor_test")
-	// blockDB := dbm.NewDebugDB("blockDB", dbm.NewMemDB())
-	// stateDB := dbm.NewDebugDB("stateDB", dbm.NewMemDB())
-	blockDB := dbm.NewMemDB()
-	stateDB := dbm.NewMemDB()
-	state, err := sm.LoadStateFromDBOrGenesisFile(stateDB, config.GenesisFile())
-	if err != nil {
-		panic(cmn.ErrorWrap(err, "error constructing state from genesis file"))
-	}
-	return state, NewBlockStore(blockDB)
-}
-
 func TestLoadBlockStoreStateJSON(t *testing.T) {
 	db := db.NewMemDB()

@@ -82,7 +65,7 @@ func freshBlockStore() (*BlockStore, db.DB) {
 var (
 	state, _ = makeStateAndBlockStore(log.NewTMLogger(new(bytes.Buffer)))

-	block       = makeBlock(1, state, new(types.Commit))
+	block       = makeBlock(1, state)
 	partSet     = block.MakePartSet(2)
 	part1       = partSet.GetPart(0)
 	part2       = partSet.GetPart(1)
@@ -105,7 +88,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 	}

 	// save a block
-	block := makeBlock(bs.Height()+1, state, new(types.Commit))
+	block := makeBlock(bs.Height()+1, state)
 	validPartSet := block.MakePartSet(2)
 	seenCommit := &types.Commit{Precommits: []*types.Vote{{Height: 10,
 		Timestamp: tmtime.Now()}}}
@@ -348,7 +331,7 @@ func TestLoadBlockMeta(t *testing.T) {
 func TestBlockFetchAtHeight(t *testing.T) {
 	state, bs := makeStateAndBlockStore(log.NewTMLogger(new(bytes.Buffer)))
 	require.Equal(t, bs.Height(), int64(0), "initially the height should be zero")
-	block := makeBlock(bs.Height()+1, state, new(types.Commit))
+	block := makeBlock(bs.Height()+1, state)

 	partSet := block.MakePartSet(2)
 	seenCommit := &types.Commit{Precommits: []*types.Vote{{Height: 10,
--- a/cmd/tendermint/commands/root.go
+++ b/cmd/tendermint/commands/root.go
@@ -54,9 +54,6 @@ var RootCmd = &cobra.Command{
 		if err != nil {
 			return err
 		}
-		if config.LogFormat == cfg.LogFormatJSON {
-			logger = log.NewTMJSONLogger(log.NewSyncWriter(os.Stdout))
-		}
 		logger, err = tmflags.ParseLogLevel(config.LogLevel, logger, cfg.DefaultLogLevel())
 		if err != nil {
 			return err
--- a/config/config.go
+++ b/config/config.go
@@ -14,11 +14,6 @@ const (
 	FuzzModeDrop = iota
 	// FuzzModeDelay is a mode in which we randomly sleep
 	FuzzModeDelay
-
-	// LogFormatPlain is a format for colored text
-	LogFormatPlain = "plain"
-	// LogFormatJSON is a format for json output
-	LogFormatJSON = "json"
 )

 // NOTE: Most of the structs & relevant comments + the
@@ -99,9 +94,6 @@ func (cfg *Config) SetRoot(root string) *Config {
 // ValidateBasic performs basic validation (checking param bounds, etc.) and
 // returns an error if any check fails.
 func (cfg *Config) ValidateBasic() error {
-	if err := cfg.BaseConfig.ValidateBasic(); err != nil {
-		return err
-	}
 	if err := cfg.RPC.ValidateBasic(); err != nil {
 		return errors.Wrap(err, "Error in [rpc] section")
 	}
@@ -153,9 +145,6 @@ type BaseConfig struct {
 	// Output level for logging
 	LogLevel string `mapstructure:"log_level"`

-	// Output format: 'plain' (colored text) or 'json'
-	LogFormat string `mapstructure:"log_format"`
-
 	// Path to the JSON file containing the initial validator set and other meta data
 	Genesis string `mapstructure:"genesis_file"`

@@ -190,7 +179,6 @@ func DefaultBaseConfig() BaseConfig {
 		ProxyApp:          "tcp://127.0.0.1:26658",
 		ABCI:              "socket",
 		LogLevel:          DefaultPackageLogLevels(),
-		LogFormat:         LogFormatPlain,
 		ProfListenAddress: "",
 		FastSync:          true,
 		FilterPeers:       false,
@@ -233,17 +221,6 @@ func (cfg BaseConfig) DBDir() string {
 	return rootify(cfg.DBPath, cfg.RootDir)
 }

-// ValidateBasic performs basic validation (checking param bounds, etc.) and
-// returns an error if any check fails.
-func (cfg BaseConfig) ValidateBasic() error {
-	switch cfg.LogFormat {
-	case LogFormatPlain, LogFormatJSON:
-	default:
-		return errors.New("unknown log_format (must be 'plain' or 'json')")
-	}
-	return nil
-}
-
 // DefaultLogLevel returns a default log level of "error"
 func DefaultLogLevel() string {
 	return "error"
@@ -265,18 +242,6 @@ type RPCConfig struct {
 	// TCP or UNIX socket address for the RPC server to listen on
 	ListenAddress string `mapstructure:"laddr"`

-	// A list of origins a cross-domain request can be executed from.
-	// If the special '*' value is present in the list, all origins will be allowed.
-	// An origin may contain a wildcard (*) to replace 0 or more characters (i.e.: http://*.domain.com).
-	// Only one wildcard can be used per origin.
-	CORSAllowedOrigins []string `mapstructure:"cors_allowed_origins"`
-
-	// A list of methods the client is allowed to use with cross-domain requests.
-	CORSAllowedMethods []string `mapstructure:"cors_allowed_methods"`
-
-	// A list of non simple headers the client is allowed to use with cross-domain requests.
-	CORSAllowedHeaders []string `mapstructure:"cors_allowed_headers"`
-
 	// TCP or UNIX socket address for the gRPC server to listen on
 	// NOTE: This server only supports /broadcast_tx_commit
 	GRPCListenAddress string `mapstructure:"grpc_laddr"`
@@ -304,10 +269,8 @@ type RPCConfig struct {
 // DefaultRPCConfig returns a default configuration for the RPC server
 func DefaultRPCConfig() *RPCConfig {
 	return &RPCConfig{
-		ListenAddress:          "tcp://0.0.0.0:26657",
-		CORSAllowedOrigins:     []string{},
-		CORSAllowedMethods:     []string{"HEAD", "GET", "POST"},
-		CORSAllowedHeaders:     []string{"Origin", "Accept", "Content-Type", "X-Requested-With", "X-Server-Time"},
+		ListenAddress: "tcp://0.0.0.0:26657",
+
 		GRPCListenAddress:      "",
 		GRPCMaxOpenConnections: 900,

@@ -337,11 +300,6 @@ func (cfg *RPCConfig) ValidateBasic() error {
 	return nil
 }

-// IsCorsEnabled returns true if cross-origin resource sharing is enabled.
-func (cfg *RPCConfig) IsCorsEnabled() bool {
-	return len(cfg.CORSAllowedOrigins) != 0
-}
-
 //-----------------------------------------------------------------------------
 // P2PConfig

@@ -539,11 +497,6 @@ func (cfg *MempoolConfig) WalDir() string {
 	return rootify(cfg.WalPath, cfg.RootDir)
 }

-// WalEnabled returns true if the WAL is enabled.
-func (cfg *MempoolConfig) WalEnabled() bool {
-	return cfg.WalPath != ""
-}
-
 // ValidateBasic performs basic validation (checking param bounds, etc.) and
 // returns an error if any check fails.
 func (cfg *MempoolConfig) ValidateBasic() error {
--- a/config/toml.go
+++ b/config/toml.go
@@ -86,9 +86,6 @@ db_dir = "{{ js .BaseConfig.DBPath }}"
 # Output level for logging, including package level options
 log_level = "{{ .BaseConfig.LogLevel }}"

-# Output format: 'plain' (colored text) or 'json'
-log_format = "{{ .BaseConfig.LogFormat }}"
-
 ##### additional base config options #####

 # Path to the JSON file containing the initial validator set and other meta data
@@ -122,17 +119,6 @@ filter_peers = {{ .BaseConfig.FilterPeers }}
 # TCP or UNIX socket address for the RPC server to listen on
 laddr = "{{ .RPC.ListenAddress }}"

-# A list of origins a cross-domain request can be executed from
-# Default value '[]' disables cors support
-# Use '["*"]' to allow any origin
-cors_allowed_origins = "{{ .RPC.CORSAllowedOrigins }}"
-
-# A list of methods the client is allowed to use with cross-domain requests
-cors_allowed_methods = "{{ .RPC.CORSAllowedMethods }}"
-
-# A list of non simple headers the client is allowed to use with cross-domain requests
-cors_allowed_headers = "{{ .RPC.CORSAllowedHeaders }}"
-
 # TCP or UNIX socket address for the gRPC server to listen on
 # NOTE: This server only supports /broadcast_tx_commit
 grpc_laddr = "{{ .RPC.GRPCListenAddress }}"
@@ -260,9 +246,6 @@ create_empty_blocks_interval = "{{ .Consensus.CreateEmptyBlocksInterval }}"
 peer_gossip_sleep_duration = "{{ .Consensus.PeerGossipSleepDuration }}"
 peer_query_maj23_sleep_duration = "{{ .Consensus.PeerQueryMaj23SleepDuration }}"

-# Block time parameters. Corresponds to the minimum time increment between consecutive blocks.
-blocktime_iota = "{{ .Consensus.BlockTimeIota }}"
-
 ##### transactions indexer configuration options #####
 [tx_index]

@@ -359,7 +342,7 @@ func ResetTestRoot(testName string) *Config {
 }

 var testGenesis = `{
-  "genesis_time": "2018-10-10T08:20:13.695936996Z",
+  "genesis_time": "2017-10-10T08:20:13.695936996Z",
  "chain_id": "tendermint_test",
  "validators": [
    {
--- a/consensus/byzantine_test.go
+++ b/consensus/byzantine_test.go
@@ -179,16 +179,16 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int, cs *Cons

 	// Create a new proposal block from state/txs from the mempool.
 	block1, blockParts1 := cs.createProposalBlock()
-	polRound, propBlockID := cs.ValidRound, types.BlockID{block1.Hash(), blockParts1.Header()}
-	proposal1 := types.NewProposal(height, round, polRound, propBlockID)
+	polRound, polBlockID := cs.Votes.POLInfo()
+	proposal1 := types.NewProposal(height, round, blockParts1.Header(), polRound, polBlockID)
 	if err := cs.privValidator.SignProposal(cs.state.ChainID, proposal1); err != nil {
 		t.Error(err)
 	}

 	// Create a new proposal block from state/txs from the mempool.
 	block2, blockParts2 := cs.createProposalBlock()
-	polRound, propBlockID = cs.ValidRound, types.BlockID{block2.Hash(), blockParts2.Header()}
-	proposal2 := types.NewProposal(height, round, polRound, propBlockID)
+	polRound, polBlockID = cs.Votes.POLInfo()
+	proposal2 := types.NewProposal(height, round, blockParts2.Header(), polRound, polBlockID)
 	if err := cs.privValidator.SignProposal(cs.state.ChainID, proposal2); err != nil {
 		t.Error(err)
 	}
@@ -263,7 +263,7 @@ func (br *ByzantineReactor) AddPeer(peer p2p.Peer) {
 	// Send our state to peer.
 	// If we're fast_syncing, broadcast a RoundStepMessage later upon SwitchToConsensus().
 	if !br.reactor.fastSync {
-		br.reactor.sendNewRoundStepMessage(peer)
+		br.reactor.sendNewRoundStepMessages(peer)
 	}
 }
 func (br *ByzantineReactor) RemovePeer(peer p2p.Peer, reason interface{}) {
--- a/consensus/common_test.go
+++ b/consensus/common_test.go
@@ -130,8 +130,8 @@ func decideProposal(cs1 *ConsensusState, vs *validatorStub, height int64, round
 	}

 	// Make proposal
-	polRound, propBlockID := cs1.ValidRound, types.BlockID{block.Hash(), blockParts.Header()}
-	proposal = types.NewProposal(height, round, polRound, propBlockID)
+	polRound, polBlockID := cs1.Votes.POLInfo()
+	proposal = types.NewProposal(height, round, blockParts.Header(), polRound, polBlockID)
 	if err := vs.SignProposal(cs1.state.ChainID, proposal); err != nil {
 		panic(err)
 	}
@@ -405,24 +405,8 @@ func ensureNewVote(voteCh <-chan interface{}, height int64, round int) {
 }

 func ensureNewRound(roundCh <-chan interface{}, height int64, round int) {
-	select {
-	case <-time.After(ensureTimeout):
-		panic("Timeout expired while waiting for NewRound event")
-	case ev := <-roundCh:
-		rs, ok := ev.(types.EventDataNewRound)
-		if !ok {
-			panic(
-				fmt.Sprintf(
-					"expected a EventDataNewRound, got %v.Wrong subscription channel?",
-					reflect.TypeOf(rs)))
-		}
-		if rs.Height != height {
-			panic(fmt.Sprintf("expected height %v, got %v", height, rs.Height))
-		}
-		if rs.Round != round {
-			panic(fmt.Sprintf("expected round %v, got %v", round, rs.Round))
-		}
-	}
+	ensureNewEvent(roundCh, height, round, ensureTimeout,
+		"Timeout expired while waiting for NewRound event")
 }

 func ensureNewTimeout(timeoutCh <-chan interface{}, height int64, round int, timeout int64) {
@@ -432,29 +416,8 @@ func ensureNewTimeout(timeoutCh <-chan interface{}, height int64, round int, tim
 }

 func ensureNewProposal(proposalCh <-chan interface{}, height int64, round int) {
-	select {
-	case <-time.After(ensureTimeout):
-		panic("Timeout expired while waiting for NewProposal event")
-	case ev := <-proposalCh:
-		rs, ok := ev.(types.EventDataCompleteProposal)
-		if !ok {
-			panic(
-				fmt.Sprintf(
-					"expected a EventDataCompleteProposal, got %v.Wrong subscription channel?",
-					reflect.TypeOf(rs)))
-		}
-		if rs.Height != height {
-			panic(fmt.Sprintf("expected height %v, got %v", height, rs.Height))
-		}
-		if rs.Round != round {
-			panic(fmt.Sprintf("expected round %v, got %v", round, rs.Round))
-		}
-	}
-}
-
-func ensureNewValidBlock(validBlockCh <-chan interface{}, height int64, round int) {
-	ensureNewEvent(validBlockCh, height, round, ensureTimeout,
-		"Timeout expired while waiting for NewValidBlock event")
+	ensureNewEvent(proposalCh, height, round, ensureTimeout,
+		"Timeout expired while waiting for NewProposal event")
 }

 func ensureNewBlock(blockCh <-chan interface{}, height int64) {
@@ -524,30 +487,6 @@ func ensureVote(voteCh <-chan interface{}, height int64, round int,
 	}
 }

-func ensureProposal(proposalCh <-chan interface{}, height int64, round int, propId types.BlockID) {
-	select {
-	case <-time.After(ensureTimeout):
-		panic("Timeout expired while waiting for NewProposal event")
-	case ev := <-proposalCh:
-		rs, ok := ev.(types.EventDataCompleteProposal)
-		if !ok {
-			panic(
-				fmt.Sprintf(
-					"expected a EventDataCompleteProposal, got %v.Wrong subscription channel?",
-					reflect.TypeOf(rs)))
-		}
-		if rs.Height != height {
-			panic(fmt.Sprintf("expected height %v, got %v", height, rs.Height))
-		}
-		if rs.Round != round {
-			panic(fmt.Sprintf("expected round %v, got %v", round, rs.Round))
-		}
-		if !rs.BlockID.Equals(propId) {
-			panic("Proposed block does not match expected block")
-		}
-	}
-}
-
 func ensurePrecommit(voteCh <-chan interface{}, height int64, round int) {
 	ensureVote(voteCh, height, round, types.PrecommitType)
 }
@@ -671,6 +610,8 @@ func randGenesisDoc(numValidators int, randPower bool, minPower int64) (*types.G
 func randGenesisState(numValidators int, randPower bool, minPower int64) (sm.State, []types.PrivValidator) {
 	genDoc, privValidators := randGenesisDoc(numValidators, randPower, minPower)
 	s0, _ := sm.MakeGenesisState(genDoc)
+	db := dbm.NewMemDB() // remove this ?
+	sm.SaveState(db, s0)
 	return s0, privValidators
 }

--- a/consensus/mempool_test.go
+++ b/consensus/mempool_test.go
@@ -10,6 +10,7 @@ import (

 	"github.com/tendermint/tendermint/abci/example/code"
 	abci "github.com/tendermint/tendermint/abci/types"
+
 	"github.com/tendermint/tendermint/types"
 )

@@ -71,19 +72,19 @@ func TestMempoolProgressInHigherRound(t *testing.T) {
 	}
 	startTestRound(cs, height, round)

-	ensureNewRound(newRoundCh, height, round) // first round at first height
-	ensureNewEventOnChannel(newBlockCh)       // first block gets committed
+	ensureNewRoundStep(newRoundCh, height, round) // first round at first height
+	ensureNewEventOnChannel(newBlockCh)           // first block gets committed

 	height = height + 1 // moving to the next height
 	round = 0

-	ensureNewRound(newRoundCh, height, round) // first round at next height
-	deliverTxsRange(cs, 0, 1)                 // we deliver txs, but dont set a proposal so we get the next round
+	ensureNewRoundStep(newRoundCh, height, round) // first round at next height
+	deliverTxsRange(cs, 0, 1)                     // we deliver txs, but dont set a proposal so we get the next round
 	ensureNewTimeout(timeoutCh, height, round, cs.config.TimeoutPropose.Nanoseconds())

-	round = round + 1                         // moving to the next round
-	ensureNewRound(newRoundCh, height, round) // wait for the next round
-	ensureNewEventOnChannel(newBlockCh)       // now we can commit the block
+	round = round + 1                             // moving to the next round
+	ensureNewRoundStep(newRoundCh, height, round) // wait for the next round
+	ensureNewEventOnChannel(newBlockCh)           // now we can commit the block
 }

 func deliverTxsRange(cs *ConsensusState, start, end int) {
--- a/consensus/reactor.go
+++ b/consensus/reactor.go
@@ -9,6 +9,7 @@ import (
 	"github.com/pkg/errors"

 	"github.com/tendermint/go-amino"
+
 	cstypes "github.com/tendermint/tendermint/consensus/types"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	tmevents "github.com/tendermint/tendermint/libs/events"
@@ -173,7 +174,7 @@ func (conR *ConsensusReactor) AddPeer(peer p2p.Peer) {
 	// Send our state to peer.
 	// If we're fast_syncing, broadcast a RoundStepMessage later upon SwitchToConsensus().
 	if !conR.FastSync() {
-		conR.sendNewRoundStepMessage(peer)
+		conR.sendNewRoundStepMessages(peer)
 	}
 }

@@ -183,11 +184,7 @@ func (conR *ConsensusReactor) RemovePeer(peer p2p.Peer, reason interface{}) {
 		return
 	}
 	// TODO
-	// ps, ok := peer.Get(PeerStateKey).(*PeerState)
-	// if !ok {
-	// 	panic(fmt.Sprintf("Peer %v has no state", peer))
-	// }
-	// ps.Disconnect()
+	//peer.Get(PeerStateKey).(*PeerState).Disconnect()
 }

 // Receive implements Reactor
@@ -208,28 +205,18 @@ func (conR *ConsensusReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)
 		conR.Switch.StopPeerForError(src, err)
 		return
 	}
-
-	if err = msg.ValidateBasic(); err != nil {
-		conR.Logger.Error("Peer sent us invalid msg", "peer", src, "msg", msg, "err", err)
-		conR.Switch.StopPeerForError(src, err)
-		return
-	}
-
 	conR.Logger.Debug("Receive", "src", src, "chId", chID, "msg", msg)

 	// Get peer states
-	ps, ok := src.Get(types.PeerStateKey).(*PeerState)
-	if !ok {
-		panic(fmt.Sprintf("Peer %v has no state", src))
-	}
+	ps := src.Get(types.PeerStateKey).(*PeerState)

 	switch chID {
 	case StateChannel:
 		switch msg := msg.(type) {
 		case *NewRoundStepMessage:
 			ps.ApplyNewRoundStepMessage(msg)
-		case *NewValidBlockMessage:
-			ps.ApplyNewValidBlockMessage(msg)
+		case *CommitStepMessage:
+			ps.ApplyCommitStepMessage(msg)
 		case *HasVoteMessage:
 			ps.ApplyHasVoteMessage(msg)
 		case *VoteSetMaj23Message:
@@ -255,7 +242,8 @@ func (conR *ConsensusReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)
 			case types.PrecommitType:
 				ourVotes = votes.Precommits(msg.Round).BitArrayByBlockID(msg.BlockID)
 			default:
-				panic("Bad VoteSetBitsMessage field Type. Forgot to add a check in ValidateBasic?")
+				conR.Logger.Error("Bad VoteSetBitsMessage field Type")
+				return
 			}
 			src.TrySend(VoteSetBitsChannel, cdc.MustMarshalBinaryBare(&VoteSetBitsMessage{
 				Height:  msg.Height,
@@ -264,6 +252,11 @@ func (conR *ConsensusReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)
 				BlockID: msg.BlockID,
 				Votes:   ourVotes,
 			}))
+		case *ProposalHeartbeatMessage:
+			hb := msg.Heartbeat
+			conR.Logger.Debug("Received proposal heartbeat message",
+				"height", hb.Height, "round", hb.Round, "sequence", hb.Sequence,
+				"valIdx", hb.ValidatorIndex, "valAddr", hb.ValidatorAddress)
 		default:
 			conR.Logger.Error(fmt.Sprintf("Unknown message type %v", reflect.TypeOf(msg)))
 		}
@@ -295,9 +288,9 @@ func (conR *ConsensusReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)
 		switch msg := msg.(type) {
 		case *VoteMessage:
 			cs := conR.conS
-			cs.mtx.RLock()
+			cs.mtx.Lock()
 			height, valSize, lastCommitSize := cs.Height, cs.Validators.Size(), cs.LastCommit.Size()
-			cs.mtx.RUnlock()
+			cs.mtx.Unlock()
 			ps.EnsureVoteBitArrays(height, valSize)
 			ps.EnsureVoteBitArrays(height-1, lastCommitSize)
 			ps.SetHasVote(msg.Vote)
@@ -329,7 +322,8 @@ func (conR *ConsensusReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)
 				case types.PrecommitType:
 					ourVotes = votes.Precommits(msg.Round).BitArrayByBlockID(msg.BlockID)
 				default:
-					panic("Bad VoteSetBitsMessage field Type. Forgot to add a check in ValidateBasic?")
+					conR.Logger.Error("Bad VoteSetBitsMessage field Type")
+					return
 				}
 				ps.ApplyVoteSetBitsMessage(msg, ourVotes)
 			} else {
@@ -364,19 +358,14 @@ func (conR *ConsensusReactor) FastSync() bool {

 //--------------------------------------

-// subscribeToBroadcastEvents subscribes for new round steps and votes
-// using internal pubsub defined on state to broadcast
+// subscribeToBroadcastEvents subscribes for new round steps, votes and
+// proposal heartbeats using internal pubsub defined on state to broadcast
 // them to peers upon receiving.
 func (conR *ConsensusReactor) subscribeToBroadcastEvents() {
 	const subscriber = "consensus-reactor"
 	conR.conS.evsw.AddListenerForEvent(subscriber, types.EventNewRoundStep,
 		func(data tmevents.EventData) {
-			conR.broadcastNewRoundStepMessage(data.(*cstypes.RoundState))
-		})
-
-	conR.conS.evsw.AddListenerForEvent(subscriber, types.EventValidBlock,
-		func(data tmevents.EventData) {
-			conR.broadcastNewValidBlockMessage(data.(*cstypes.RoundState))
+			conR.broadcastNewRoundStepMessages(data.(*cstypes.RoundState))
 		})

 	conR.conS.evsw.AddListenerForEvent(subscriber, types.EventVote,
@@ -384,6 +373,10 @@ func (conR *ConsensusReactor) subscribeToBroadcastEvents() {
 			conR.broadcastHasVoteMessage(data.(*types.Vote))
 		})

+	conR.conS.evsw.AddListenerForEvent(subscriber, types.EventProposalHeartbeat,
+		func(data tmevents.EventData) {
+			conR.broadcastProposalHeartbeatMessage(data.(*types.Heartbeat))
+		})
 }

 func (conR *ConsensusReactor) unsubscribeFromBroadcastEvents() {
@@ -391,20 +384,21 @@ func (conR *ConsensusReactor) unsubscribeFromBroadcastEvents() {
 	conR.conS.evsw.RemoveListener(subscriber)
 }

-func (conR *ConsensusReactor) broadcastNewRoundStepMessage(rs *cstypes.RoundState) {
-	nrsMsg := makeRoundStepMessage(rs)
-	conR.Switch.Broadcast(StateChannel, cdc.MustMarshalBinaryBare(nrsMsg))
+func (conR *ConsensusReactor) broadcastProposalHeartbeatMessage(hb *types.Heartbeat) {
+	conR.Logger.Debug("Broadcasting proposal heartbeat message",
+		"height", hb.Height, "round", hb.Round, "sequence", hb.Sequence)
+	msg := &ProposalHeartbeatMessage{hb}
+	conR.Switch.Broadcast(StateChannel, cdc.MustMarshalBinaryBare(msg))
 }

-func (conR *ConsensusReactor) broadcastNewValidBlockMessage(rs *cstypes.RoundState) {
-	csMsg := &NewValidBlockMessage{
-		Height:           rs.Height,
-		Round:            rs.Round,
-		BlockPartsHeader: rs.ProposalBlockParts.Header(),
-		BlockParts:       rs.ProposalBlockParts.BitArray(),
-		IsCommit:         rs.Step == cstypes.RoundStepCommit,
+func (conR *ConsensusReactor) broadcastNewRoundStepMessages(rs *cstypes.RoundState) {
+	nrsMsg, csMsg := makeRoundStepMessages(rs)
+	if nrsMsg != nil {
+		conR.Switch.Broadcast(StateChannel, cdc.MustMarshalBinaryBare(nrsMsg))
+	}
+	if csMsg != nil {
+		conR.Switch.Broadcast(StateChannel, cdc.MustMarshalBinaryBare(csMsg))
 	}
-	conR.Switch.Broadcast(StateChannel, cdc.MustMarshalBinaryBare(csMsg))
 }

 // Broadcasts HasVoteMessage to peers that care.
@@ -419,10 +413,7 @@ func (conR *ConsensusReactor) broadcastHasVoteMessage(vote *types.Vote) {
 	/*
 		// TODO: Make this broadcast more selective.
 		for _, peer := range conR.Switch.Peers().List() {
-			ps, ok := peer.Get(PeerStateKey).(*PeerState)
-			if !ok {
-				panic(fmt.Sprintf("Peer %v has no state", peer))
-			}
+			ps := peer.Get(PeerStateKey).(*PeerState)
 			prs := ps.GetRoundState()
 			if prs.Height == vote.Height {
 				// TODO: Also filter on round?
@@ -436,7 +427,7 @@ func (conR *ConsensusReactor) broadcastHasVoteMessage(vote *types.Vote) {
 	*/
 }

-func makeRoundStepMessage(rs *cstypes.RoundState) (nrsMsg *NewRoundStepMessage) {
+func makeRoundStepMessages(rs *cstypes.RoundState) (nrsMsg *NewRoundStepMessage, csMsg *CommitStepMessage) {
 	nrsMsg = &NewRoundStepMessage{
 		Height: rs.Height,
 		Round:  rs.Round,
@@ -444,13 +435,25 @@ func makeRoundStepMessage(rs *cstypes.RoundState) (nrsMsg *NewRoundStepMessage)
 		SecondsSinceStartTime: int(time.Since(rs.StartTime).Seconds()),
 		LastCommitRound:       rs.LastCommit.Round(),
 	}
+	if rs.Step == cstypes.RoundStepCommit {
+		csMsg = &CommitStepMessage{
+			Height:           rs.Height,
+			BlockPartsHeader: rs.ProposalBlockParts.Header(),
+			BlockParts:       rs.ProposalBlockParts.BitArray(),
+		}
+	}
 	return
 }

-func (conR *ConsensusReactor) sendNewRoundStepMessage(peer p2p.Peer) {
+func (conR *ConsensusReactor) sendNewRoundStepMessages(peer p2p.Peer) {
 	rs := conR.conS.GetRoundState()
-	nrsMsg := makeRoundStepMessage(rs)
-	peer.Send(StateChannel, cdc.MustMarshalBinaryBare(nrsMsg))
+	nrsMsg, csMsg := makeRoundStepMessages(rs)
+	if nrsMsg != nil {
+		peer.Send(StateChannel, cdc.MustMarshalBinaryBare(nrsMsg))
+	}
+	if csMsg != nil {
+		peer.Send(StateChannel, cdc.MustMarshalBinaryBare(csMsg))
+	}
 }

 func (conR *ConsensusReactor) gossipDataRoutine(peer p2p.Peer, ps *PeerState) {
@@ -521,7 +524,6 @@ OUTER_LOOP:
 				msg := &ProposalMessage{Proposal: rs.Proposal}
 				logger.Debug("Sending proposal", "height", prs.Height, "round", prs.Round)
 				if peer.Send(DataChannel, cdc.MustMarshalBinaryBare(msg)) {
-					// NOTE[ZM]: A peer might have received different proposal msg so this Proposal msg will be rejected!
 					ps.SetHasProposal(rs.Proposal)
 				}
 			}
@@ -820,10 +822,7 @@ func (conR *ConsensusReactor) peerStatsRoutine() {
 				continue
 			}
 			// Get peer state
-			ps, ok := peer.Get(types.PeerStateKey).(*PeerState)
-			if !ok {
-				panic(fmt.Sprintf("Peer %v has no state", peer))
-			}
+			ps := peer.Get(types.PeerStateKey).(*PeerState)
 			switch msg.Msg.(type) {
 			case *VoteMessage:
 				if numVotes := ps.RecordVote(); numVotes%votesToContributeToBecomeGoodPeer == 0 {
@@ -856,10 +855,7 @@ func (conR *ConsensusReactor) StringIndented(indent string) string {
 	s := "ConsensusReactor{\n"
 	s += indent + "  " + conR.conS.StringIndented(indent+"  ") + "\n"
 	for _, peer := range conR.Switch.Peers().List() {
-		ps, ok := peer.Get(types.PeerStateKey).(*PeerState)
-		if !ok {
-			panic(fmt.Sprintf("Peer %v has no state", peer))
-		}
+		ps := peer.Get(types.PeerStateKey).(*PeerState)
 		s += indent + "  " + ps.StringIndented(indent+"  ") + "\n"
 	}
 	s += indent + "}"
@@ -968,20 +964,13 @@ func (ps *PeerState) SetHasProposal(proposal *types.Proposal) {
 	if ps.PRS.Height != proposal.Height || ps.PRS.Round != proposal.Round {
 		return
 	}
-
 	if ps.PRS.Proposal {
 		return
 	}

 	ps.PRS.Proposal = true
-
-	// ps.PRS.ProposalBlockParts is set due to NewValidBlockMessage
-	if ps.PRS.ProposalBlockParts != nil {
-		return
-	}
-
-	ps.PRS.ProposalBlockPartsHeader = proposal.BlockID.PartsHeader
-	ps.PRS.ProposalBlockParts = cmn.NewBitArray(proposal.BlockID.PartsHeader.Total)
+	ps.PRS.ProposalBlockPartsHeader = proposal.BlockPartsHeader
+	ps.PRS.ProposalBlockParts = cmn.NewBitArray(proposal.BlockPartsHeader.Total)
 	ps.PRS.ProposalPOLRound = proposal.POLRound
 	ps.PRS.ProposalPOL = nil // Nil until ProposalPOLMessage received.
 }
@@ -1017,11 +1006,7 @@ func (ps *PeerState) PickSendVote(votes types.VoteSetReader) bool {
 	if vote, ok := ps.PickVoteToSend(votes); ok {
 		msg := &VoteMessage{vote}
 		ps.logger.Debug("Sending vote message", "ps", ps, "vote", vote)
-		if ps.peer.Send(VoteChannel, cdc.MustMarshalBinaryBare(msg)) {
-			ps.SetHasVote(vote)
-			return true
-		}
-		return false
+		return ps.peer.Send(VoteChannel, cdc.MustMarshalBinaryBare(msg))
 	}
 	return false
 }
@@ -1050,6 +1035,7 @@ func (ps *PeerState) PickVoteToSend(votes types.VoteSetReader) (vote *types.Vote
 		return nil, false // Not something worth sending
 	}
 	if index, ok := votes.BitArray().Sub(psVotes).PickRandom(); ok {
+		ps.setHasVote(height, round, type_, index)
 		return votes.GetByIndex(index), true
 	}
 	return nil, false
@@ -1225,6 +1211,7 @@ func (ps *PeerState) ApplyNewRoundStepMessage(msg *NewRoundStepMessage) {
 	// Just remember these values.
 	psHeight := ps.PRS.Height
 	psRound := ps.PRS.Round
+	//psStep := ps.PRS.Step
 	psCatchupCommitRound := ps.PRS.CatchupCommitRound
 	psCatchupCommit := ps.PRS.CatchupCommit

@@ -1265,8 +1252,8 @@ func (ps *PeerState) ApplyNewRoundStepMessage(msg *NewRoundStepMessage) {
 	}
 }

-// ApplyNewValidBlockMessage updates the peer state for the new valid block.
-func (ps *PeerState) ApplyNewValidBlockMessage(msg *NewValidBlockMessage) {
+// ApplyCommitStepMessage updates the peer state for the new commit.
+func (ps *PeerState) ApplyCommitStepMessage(msg *CommitStepMessage) {
 	ps.mtx.Lock()
 	defer ps.mtx.Unlock()

@@ -1274,10 +1261,6 @@ func (ps *PeerState) ApplyNewValidBlockMessage(msg *NewValidBlockMessage) {
 		return
 	}

-	if ps.PRS.Round != msg.Round && !msg.IsCommit {
-		return
-	}
-
 	ps.PRS.ProposalBlockPartsHeader = msg.BlockPartsHeader
 	ps.PRS.ProposalBlockParts = msg.BlockParts
 }
@@ -1356,14 +1339,12 @@ func (ps *PeerState) StringIndented(indent string) string {
 // Messages

 // ConsensusMessage is a message that can be sent and received on the ConsensusReactor
-type ConsensusMessage interface {
-	ValidateBasic() error
-}
+type ConsensusMessage interface{}

 func RegisterConsensusMessages(cdc *amino.Codec) {
 	cdc.RegisterInterface((*ConsensusMessage)(nil), nil)
 	cdc.RegisterConcrete(&NewRoundStepMessage{}, "tendermint/NewRoundStepMessage", nil)
-	cdc.RegisterConcrete(&NewValidBlockMessage{}, "tendermint/NewValidBlockMessage", nil)
+	cdc.RegisterConcrete(&CommitStepMessage{}, "tendermint/CommitStep", nil)
 	cdc.RegisterConcrete(&ProposalMessage{}, "tendermint/Proposal", nil)
 	cdc.RegisterConcrete(&ProposalPOLMessage{}, "tendermint/ProposalPOL", nil)
 	cdc.RegisterConcrete(&BlockPartMessage{}, "tendermint/BlockPart", nil)
@@ -1371,6 +1352,7 @@ func RegisterConsensusMessages(cdc *amino.Codec) {
 	cdc.RegisterConcrete(&HasVoteMessage{}, "tendermint/HasVote", nil)
 	cdc.RegisterConcrete(&VoteSetMaj23Message{}, "tendermint/VoteSetMaj23", nil)
 	cdc.RegisterConcrete(&VoteSetBitsMessage{}, "tendermint/VoteSetBits", nil)
+	cdc.RegisterConcrete(&ProposalHeartbeatMessage{}, "tendermint/ProposalHeartbeat", nil)
 }

 func decodeMsg(bz []byte) (msg ConsensusMessage, err error) {
@@ -1393,27 +1375,6 @@ type NewRoundStepMessage struct {
 	LastCommitRound       int
 }

-// ValidateBasic performs basic validation.
-func (m *NewRoundStepMessage) ValidateBasic() error {
-	if m.Height < 0 {
-		return errors.New("Negative Height")
-	}
-	if m.Round < 0 {
-		return errors.New("Negative Round")
-	}
-	if !m.Step.IsValid() {
-		return errors.New("Invalid Step")
-	}
-
-	// NOTE: SecondsSinceStartTime may be negative
-
-	if (m.Height == 1 && m.LastCommitRound != -1) ||
-		(m.Height > 1 && m.LastCommitRound < -1) { // TODO: #2737 LastCommitRound should always be >= 0 for heights > 1
-		return errors.New("Invalid LastCommitRound (for 1st block: -1, for others: >= 0)")
-	}
-	return nil
-}
-
 // String returns a string representation.
 func (m *NewRoundStepMessage) String() string {
 	return fmt.Sprintf("[NewRoundStep H:%v R:%v S:%v LCR:%v]",
@@ -1422,40 +1383,16 @@ func (m *NewRoundStepMessage) String() string {

 //-------------------------------------

-// NewValidBlockMessage is sent when a validator observes a valid block B in some round r,
-//i.e., there is a Proposal for block B and 2/3+ prevotes for the block B in the round r.
-// In case the block is also committed, then IsCommit flag is set to true.
-type NewValidBlockMessage struct {
+// CommitStepMessage is sent when a block is committed.
+type CommitStepMessage struct {
 	Height           int64
-	Round            int
 	BlockPartsHeader types.PartSetHeader
 	BlockParts       *cmn.BitArray
-	IsCommit         bool
-}
-
-// ValidateBasic performs basic validation.
-func (m *NewValidBlockMessage) ValidateBasic() error {
-	if m.Height < 0 {
-		return errors.New("Negative Height")
-	}
-	if m.Round < 0 {
-		return errors.New("Negative Round")
-	}
-	if err := m.BlockPartsHeader.ValidateBasic(); err != nil {
-		return fmt.Errorf("Wrong BlockPartsHeader: %v", err)
-	}
-	if m.BlockParts.Size() != m.BlockPartsHeader.Total {
-		return fmt.Errorf("BlockParts bit array size %d not equal to BlockPartsHeader.Total %d",
-			m.BlockParts.Size(),
-			m.BlockPartsHeader.Total)
-	}
-	return nil
 }

 // String returns a string representation.
-func (m *NewValidBlockMessage) String() string {
-	return fmt.Sprintf("[ValidBlockMessage H:%v R:%v BP:%v BA:%v IsCommit:%v]",
-		m.Height, m.Round, m.BlockPartsHeader, m.BlockParts, m.IsCommit)
+func (m *CommitStepMessage) String() string {
+	return fmt.Sprintf("[CommitStep H:%v BP:%v BA:%v]", m.Height, m.BlockPartsHeader, m.BlockParts)
 }

 //-------------------------------------
@@ -1465,11 +1402,6 @@ type ProposalMessage struct {
 	Proposal *types.Proposal
 }

-// ValidateBasic performs basic validation.
-func (m *ProposalMessage) ValidateBasic() error {
-	return m.Proposal.ValidateBasic()
-}
-
 // String returns a string representation.
 func (m *ProposalMessage) String() string {
 	return fmt.Sprintf("[Proposal %v]", m.Proposal)
@@ -1484,20 +1416,6 @@ type ProposalPOLMessage struct {
 	ProposalPOL      *cmn.BitArray
 }

-// ValidateBasic performs basic validation.
-func (m *ProposalPOLMessage) ValidateBasic() error {
-	if m.Height < 0 {
-		return errors.New("Negative Height")
-	}
-	if m.ProposalPOLRound < 0 {
-		return errors.New("Negative ProposalPOLRound")
-	}
-	if m.ProposalPOL.Size() == 0 {
-		return errors.New("Empty ProposalPOL bit array")
-	}
-	return nil
-}
-
 // String returns a string representation.
 func (m *ProposalPOLMessage) String() string {
 	return fmt.Sprintf("[ProposalPOL H:%v POLR:%v POL:%v]", m.Height, m.ProposalPOLRound, m.ProposalPOL)
@@ -1512,20 +1430,6 @@ type BlockPartMessage struct {
 	Part   *types.Part
 }

-// ValidateBasic performs basic validation.
-func (m *BlockPartMessage) ValidateBasic() error {
-	if m.Height < 0 {
-		return errors.New("Negative Height")
-	}
-	if m.Round < 0 {
-		return errors.New("Negative Round")
-	}
-	if err := m.Part.ValidateBasic(); err != nil {
-		return fmt.Errorf("Wrong Part: %v", err)
-	}
-	return nil
-}
-
 // String returns a string representation.
 func (m *BlockPartMessage) String() string {
 	return fmt.Sprintf("[BlockPart H:%v R:%v P:%v]", m.Height, m.Round, m.Part)
@@ -1538,11 +1442,6 @@ type VoteMessage struct {
 	Vote *types.Vote
 }

-// ValidateBasic performs basic validation.
-func (m *VoteMessage) ValidateBasic() error {
-	return m.Vote.ValidateBasic()
-}
-
 // String returns a string representation.
 func (m *VoteMessage) String() string {
 	return fmt.Sprintf("[Vote %v]", m.Vote)
@@ -1558,23 +1457,6 @@ type HasVoteMessage struct {
 	Index  int
 }

-// ValidateBasic performs basic validation.
-func (m *HasVoteMessage) ValidateBasic() error {
-	if m.Height < 0 {
-		return errors.New("Negative Height")
-	}
-	if m.Round < 0 {
-		return errors.New("Negative Round")
-	}
-	if !types.IsVoteTypeValid(m.Type) {
-		return errors.New("Invalid Type")
-	}
-	if m.Index < 0 {
-		return errors.New("Negative Index")
-	}
-	return nil
-}
-
 // String returns a string representation.
 func (m *HasVoteMessage) String() string {
 	return fmt.Sprintf("[HasVote VI:%v V:{%v/%02d/%v}]", m.Index, m.Height, m.Round, m.Type)
@@ -1590,23 +1472,6 @@ type VoteSetMaj23Message struct {
 	BlockID types.BlockID
 }

-// ValidateBasic performs basic validation.
-func (m *VoteSetMaj23Message) ValidateBasic() error {
-	if m.Height < 0 {
-		return errors.New("Negative Height")
-	}
-	if m.Round < 0 {
-		return errors.New("Negative Round")
-	}
-	if !types.IsVoteTypeValid(m.Type) {
-		return errors.New("Invalid Type")
-	}
-	if err := m.BlockID.ValidateBasic(); err != nil {
-		return fmt.Errorf("Wrong BlockID: %v", err)
-	}
-	return nil
-}
-
 // String returns a string representation.
 func (m *VoteSetMaj23Message) String() string {
 	return fmt.Sprintf("[VSM23 %v/%02d/%v %v]", m.Height, m.Round, m.Type, m.BlockID)
@@ -1623,27 +1488,19 @@ type VoteSetBitsMessage struct {
 	Votes   *cmn.BitArray
 }

-// ValidateBasic performs basic validation.
-func (m *VoteSetBitsMessage) ValidateBasic() error {
-	if m.Height < 0 {
-		return errors.New("Negative Height")
-	}
-	if m.Round < 0 {
-		return errors.New("Negative Round")
-	}
-	if !types.IsVoteTypeValid(m.Type) {
-		return errors.New("Invalid Type")
-	}
-	if err := m.BlockID.ValidateBasic(); err != nil {
-		return fmt.Errorf("Wrong BlockID: %v", err)
-	}
-	// NOTE: Votes.Size() can be zero if the node does not have any
-	return nil
-}
-
 // String returns a string representation.
 func (m *VoteSetBitsMessage) String() string {
 	return fmt.Sprintf("[VSB %v/%02d/%v %v %v]", m.Height, m.Round, m.Type, m.BlockID, m.Votes)
 }

 //-------------------------------------
+
+// ProposalHeartbeatMessage is sent to signal that a node is alive and waiting for transactions for a proposal.
+type ProposalHeartbeatMessage struct {
+	Heartbeat *types.Heartbeat
+}
+
+// String returns a string representation.
+func (m *ProposalHeartbeatMessage) String() string {
+	return fmt.Sprintf("[HEARTBEAT %v]", m.Heartbeat)
+}
--- a/consensus/reactor_test.go
+++ b/consensus/reactor_test.go
@@ -213,8 +213,8 @@ func (m *mockEvidencePool) Update(block *types.Block, state sm.State) {

 //------------------------------------

-// Ensure a testnet makes blocks when there are txs
-func TestReactorCreatesBlockWhenEmptyBlocksFalse(t *testing.T) {
+// Ensure a testnet sends proposal heartbeats and makes blocks when there are txs
+func TestReactorProposalHeartbeats(t *testing.T) {
 	N := 4
 	css := randConsensusNet(N, "consensus_reactor_test", newMockTickerFunc(true), newCounter,
 		func(c *cfg.Config) {
@@ -222,6 +222,17 @@ func TestReactorCreatesBlockWhenEmptyBlocksFalse(t *testing.T) {
 		})
 	reactors, eventChans, eventBuses := startConsensusNet(t, css, N)
 	defer stopConsensusNet(log.TestingLogger(), reactors, eventBuses)
+	heartbeatChans := make([]chan interface{}, N)
+	var err error
+	for i := 0; i < N; i++ {
+		heartbeatChans[i] = make(chan interface{}, 1)
+		err = eventBuses[i].Subscribe(context.Background(), testSubscriber, types.EventQueryProposalHeartbeat, heartbeatChans[i])
+		require.NoError(t, err)
+	}
+	// wait till everyone sends a proposal heartbeat
+	timeoutWaitGroup(t, N, func(j int) {
+		<-heartbeatChans[j]
+	}, css)

 	// send a tx
 	if err := css[3].mempool.CheckTx([]byte{1, 2, 3}, nil); err != nil {
--- a/consensus/replay.go
+++ b/consensus/replay.go
@@ -73,7 +73,7 @@ func (cs *ConsensusState) readReplayMessage(msg *TimedWALMessage, newStepCh chan
 		case *ProposalMessage:
 			p := msg.Proposal
 			cs.Logger.Info("Replay: Proposal", "height", p.Height, "round", p.Round, "header",
-				p.BlockID.PartsHeader, "pol", p.POLRound, "peer", peerID)
+				p.BlockPartsHeader, "pol", p.POLRound, "peer", peerID)
 		case *BlockPartMessage:
 			cs.Logger.Info("Replay: BlockPart", "height", msg.Height, "round", msg.Round, "peer", peerID)
 		case *VoteMessage:
@@ -264,24 +264,15 @@ func (h *Handshaker) Handshake(proxyApp proxy.AppConns) error {

 // Replay all blocks since appBlockHeight and ensure the result matches the current state.
 // Returns the final AppHash or an error.
-func (h *Handshaker) ReplayBlocks(
-	state sm.State,
-	appHash []byte,
-	appBlockHeight int64,
-	proxyApp proxy.AppConns,
-) ([]byte, error) {
+func (h *Handshaker) ReplayBlocks(state sm.State, appHash []byte, appBlockHeight int64, proxyApp proxy.AppConns) ([]byte, error) {
+
 	storeBlockHeight := h.store.Height()
 	stateBlockHeight := state.LastBlockHeight
 	h.logger.Info("ABCI Replay Blocks", "appHeight", appBlockHeight, "storeHeight", storeBlockHeight, "stateHeight", stateBlockHeight)

 	// If appBlockHeight == 0 it means that we are at genesis and hence should send InitChain.
 	if appBlockHeight == 0 {
-		validators := make([]*types.Validator, len(h.genDoc.Validators))
-		for i, val := range h.genDoc.Validators {
-			validators[i] = types.NewValidator(val.PubKey, val.Power)
-		}
-		validatorSet := types.NewValidatorSet(validators)
-		nextVals := types.TM2PB.ValidatorUpdates(validatorSet)
+		nextVals := types.TM2PB.ValidatorUpdates(state.NextValidators) // state.Validators would work too.
 		csParams := types.TM2PB.ConsensusParams(h.genDoc.ConsensusParams)
 		req := abci.RequestInitChain{
 			Time:            h.genDoc.GenesisTime,
--- a/consensus/replay_file.go
+++ b/consensus/replay_file.go
@@ -58,18 +58,7 @@ func (cs *ConsensusState) ReplayFile(file string, console bool) error {
 	if err != nil {
 		return errors.Errorf("failed to subscribe %s to %v", subscriber, types.EventQueryNewRoundStep)
 	}
-	defer func() {
-		// drain newStepCh to make sure we don't block
-	LOOP:
-		for {
-			select {
-			case <-newStepCh:
-			default:
-				break LOOP
-			}
-		}
-		cs.eventBus.Unsubscribe(ctx, subscriber, types.EventQueryNewRoundStep)
-	}()
+	defer cs.eventBus.Unsubscribe(ctx, subscriber, types.EventQueryNewRoundStep)

 	// just open the file for reading, no need to use wal
 	fp, err := os.OpenFile(file, os.O_RDONLY, 0600)
@@ -232,18 +221,7 @@ func (pb *playback) replayConsoleLoop() int {
 			if err != nil {
 				cmn.Exit(fmt.Sprintf("failed to subscribe %s to %v", subscriber, types.EventQueryNewRoundStep))
 			}
-			defer func() {
-				// drain newStepCh to make sure we don't block
-			LOOP:
-				for {
-					select {
-					case <-newStepCh:
-					default:
-						break LOOP
-					}
-				}
-				pb.cs.eventBus.Unsubscribe(ctx, subscriber, types.EventQueryNewRoundStep)
-			}()
+			defer pb.cs.eventBus.Unsubscribe(ctx, subscriber, types.EventQueryNewRoundStep)

 			if len(tokens) == 1 {
 				if err := pb.replayReset(1, newStepCh); err != nil {
--- a/consensus/replay_test.go
+++ b/consensus/replay_test.go
@@ -17,7 +17,7 @@ import (

 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/crypto"
+	crypto "github.com/tendermint/tendermint/crypto"
 	auto "github.com/tendermint/tendermint/libs/autofile"
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/version"
@@ -315,21 +315,28 @@ func testHandshakeReplay(t *testing.T, nBlocks int, mode uint) {
 	config := ResetConfig("proxy_test_")

 	walBody, err := WALWithNBlocks(NUM_BLOCKS)
-	require.NoError(t, err)
+	if err != nil {
+		t.Fatal(err)
+	}
 	walFile := tempWALWithData(walBody)
 	config.Consensus.SetWalFile(walFile)

 	privVal := privval.LoadFilePV(config.PrivValidatorFile())

 	wal, err := NewWAL(walFile)
-	require.NoError(t, err)
+	if err != nil {
+		t.Fatal(err)
+	}
 	wal.SetLogger(log.TestingLogger())
-	err = wal.Start()
-	require.NoError(t, err)
+	if err := wal.Start(); err != nil {
+		t.Fatal(err)
+	}
 	defer wal.Stop()

 	chain, commits, err := makeBlockchainFromWAL(wal)
-	require.NoError(t, err)
+	if err != nil {
+		t.Fatalf(err.Error())
+	}

 	stateDB, state, store := stateAndStore(config, privVal.GetPubKey(), kvstore.ProtocolVersion)
 	store.chain = chain
@@ -568,7 +575,7 @@ func readPieceFromWAL(msg *TimedWALMessage) interface{} {
 	case msgInfo:
 		switch msg := m.Msg.(type) {
 		case *ProposalMessage:
-			return &msg.Proposal.BlockID.PartsHeader
+			return &msg.Proposal.BlockPartsHeader
 		case *BlockPartMessage:
 			return msg.Part
 		case *VoteMessage:
--- a/consensus/state.go
+++ b/consensus/state.go
@@ -9,8 +9,8 @@ import (
 	"sync"
 	"time"

+	fail "github.com/ebuchman/fail-test"
 	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/libs/fail"
 	"github.com/tendermint/tendermint/libs/log"
 	tmtime "github.com/tendermint/tendermint/types/time"

@@ -22,6 +22,13 @@ import (
 	"github.com/tendermint/tendermint/types"
 )

+//-----------------------------------------------------------------------------
+// Config
+
+const (
+	proposalHeartbeatIntervalSeconds = 2
+)
+
 //-----------------------------------------------------------------------------
 // Errors

@@ -111,7 +118,7 @@ type ConsensusState struct {
 	done chan struct{}

 	// synchronous pubsub between consensus state and reactor.
-	// state only emits EventNewRoundStep and EventVote
+	// state only emits EventNewRoundStep, EventVote and EventProposalHeartbeat
 	evsw tmevents.EventSwitch

 	// for reporting metrics
@@ -200,16 +207,18 @@ func (cs *ConsensusState) GetState() sm.State {
 // GetLastHeight returns the last height committed.
 // If there were no blocks, returns 0.
 func (cs *ConsensusState) GetLastHeight() int64 {
-	cs.mtx.RLock()
-	defer cs.mtx.RUnlock()
+	cs.mtx.Lock()
+	defer cs.mtx.Unlock()
+
 	return cs.RoundState.Height - 1
 }

 // GetRoundState returns a shallow copy of the internal consensus state.
 func (cs *ConsensusState) GetRoundState() *cstypes.RoundState {
 	cs.mtx.RLock()
+	defer cs.mtx.RUnlock()
+
 	rs := cs.RoundState // copy
-	cs.mtx.RUnlock()
 	return &rs
 }

@@ -217,6 +226,7 @@ func (cs *ConsensusState) GetRoundState() *cstypes.RoundState {
 func (cs *ConsensusState) GetRoundStateJSON() ([]byte, error) {
 	cs.mtx.RLock()
 	defer cs.mtx.RUnlock()
+
 	return cdc.MarshalJSON(cs.RoundState)
 }

@@ -224,6 +234,7 @@ func (cs *ConsensusState) GetRoundStateJSON() ([]byte, error) {
 func (cs *ConsensusState) GetRoundStateSimpleJSON() ([]byte, error) {
 	cs.mtx.RLock()
 	defer cs.mtx.RUnlock()
+
 	return cdc.MarshalJSON(cs.RoundState.RoundStateSimple())
 }

@@ -237,15 +248,15 @@ func (cs *ConsensusState) GetValidators() (int64, []*types.Validator) {
 // SetPrivValidator sets the private validator account for signing votes.
 func (cs *ConsensusState) SetPrivValidator(priv types.PrivValidator) {
 	cs.mtx.Lock()
+	defer cs.mtx.Unlock()
 	cs.privValidator = priv
-	cs.mtx.Unlock()
 }

 // SetTimeoutTicker sets the local timer. It may be useful to overwrite for testing.
 func (cs *ConsensusState) SetTimeoutTicker(timeoutTicker TimeoutTicker) {
 	cs.mtx.Lock()
+	defer cs.mtx.Unlock()
 	cs.timeoutTicker = timeoutTicker
-	cs.mtx.Unlock()
 }

 // LoadCommit loads the commit for a given height.
@@ -317,11 +328,10 @@ func (cs *ConsensusState) startRoutines(maxSteps int) {
 	go cs.receiveRoutine(maxSteps)
 }

-// OnStop implements cmn.Service.
+// OnStop implements cmn.Service. It stops all routines and waits for the WAL to finish.
 func (cs *ConsensusState) OnStop() {
 	cs.evsw.Stop()
 	cs.timeoutTicker.Stop()
-	// WAL is stopped in receiveRoutine.
 }

 // Wait waits for the the main routine to return.
@@ -745,7 +755,7 @@ func (cs *ConsensusState) enterNewRound(height int64, round int) {
 	validators := cs.Validators
 	if cs.Round < round {
 		validators = validators.Copy()
-		validators.IncrementProposerPriority(round - cs.Round)
+		validators.IncrementAccum(round - cs.Round)
 	}

 	// Setup new round
@@ -766,7 +776,7 @@ func (cs *ConsensusState) enterNewRound(height int64, round int) {
 	cs.Votes.SetRound(round + 1) // also track next round (round+1) to allow round-skipping
 	cs.triggeredTimeoutPrecommit = false

-	cs.eventBus.PublishEventNewRound(cs.NewRoundEvent())
+	cs.eventBus.PublishEventNewRound(cs.RoundStateEvent())
 	cs.metrics.Rounds.Set(float64(round))

 	// Wait for txs to be available in the mempool
@@ -778,6 +788,7 @@ func (cs *ConsensusState) enterNewRound(height int64, round int) {
 			cs.scheduleTimeout(cs.config.CreateEmptyBlocksInterval, height, round,
 				cstypes.RoundStepNewRound)
 		}
+		go cs.proposalHeartbeat(height, round)
 	} else {
 		cs.enterPropose(height, round)
 	}
@@ -794,6 +805,32 @@ func (cs *ConsensusState) needProofBlock(height int64) bool {
 	return !bytes.Equal(cs.state.AppHash, lastBlockMeta.Header.AppHash)
 }

+func (cs *ConsensusState) proposalHeartbeat(height int64, round int) {
+	counter := 0
+	addr := cs.privValidator.GetAddress()
+	valIndex, _ := cs.Validators.GetByAddress(addr)
+	chainID := cs.state.ChainID
+	for {
+		rs := cs.GetRoundState()
+		// if we've already moved on, no need to send more heartbeats
+		if rs.Step > cstypes.RoundStepNewRound || rs.Round > round || rs.Height > height {
+			return
+		}
+		heartbeat := &types.Heartbeat{
+			Height:           rs.Height,
+			Round:            rs.Round,
+			Sequence:         counter,
+			ValidatorAddress: addr,
+			ValidatorIndex:   valIndex,
+		}
+		cs.privValidator.SignHeartbeat(chainID, heartbeat)
+		cs.eventBus.PublishEventProposalHeartbeat(types.EventDataProposalHeartbeat{heartbeat})
+		cs.evsw.FireEvent(types.EventProposalHeartbeat, heartbeat)
+		counter++
+		time.Sleep(proposalHeartbeatIntervalSeconds * time.Second)
+	}
+}
+
 // Enter (CreateEmptyBlocks): from enterNewRound(height,round)
 // Enter (CreateEmptyBlocks, CreateEmptyBlocksInterval > 0 ): after enterNewRound(height,round), after timeout of CreateEmptyBlocksInterval
 // Enter (!CreateEmptyBlocks) : after enterNewRound(height,round), once txs are in the mempool
@@ -864,9 +901,15 @@ func (cs *ConsensusState) defaultDecideProposal(height int64, round int) {
 	}

 	// Make proposal
-	propBlockId := types.BlockID{block.Hash(), blockParts.Header()}
-	proposal := types.NewProposal(height, round, cs.ValidRound, propBlockId)
+	polRound, polBlockID := cs.Votes.POLInfo()
+	proposal := types.NewProposal(height, round, blockParts.Header(), polRound, polBlockID)
 	if err := cs.privValidator.SignProposal(cs.state.ChainID, proposal); err == nil {
+		// Set fields
+		/*  fields set by setProposal and addBlockPart
+		cs.Proposal = proposal
+		cs.ProposalBlock = block
+		cs.ProposalBlockParts = blockParts
+		*/

 		// send proposal and block parts on internal msg queue
 		cs.sendInternalMessage(msgInfo{&ProposalMessage{proposal}, ""})
@@ -951,6 +994,14 @@ func (cs *ConsensusState) enterPrevote(height int64, round int) {
 		cs.newStep()
 	}()

+	// fire event for how we got here
+	if cs.isProposalComplete() {
+		cs.eventBus.PublishEventCompleteProposal(cs.RoundStateEvent())
+	} else {
+		// we received +2/3 prevotes for a future round
+		// TODO: catchup event?
+	}
+
 	cs.Logger.Info(fmt.Sprintf("enterPrevote(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))

 	// Sign and broadcast vote as necessary
@@ -1189,8 +1240,6 @@ func (cs *ConsensusState) enterCommit(height int64, commitRound int) {
 			// Set up ProposalBlockParts and keep waiting.
 			cs.ProposalBlock = nil
 			cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartsHeader)
-			cs.eventBus.PublishEventValidBlock(cs.RoundStateEvent())
-			cs.evsw.FireEvent(types.EventValidBlock, &cs.RoundState)
 		} else {
 			// We just need to keep waiting.
 		}
@@ -1371,9 +1420,14 @@ func (cs *ConsensusState) defaultSetProposal(proposal *types.Proposal) error {
 		return nil
 	}

-	// Verify POLRound, which must be -1 or in range [0, proposal.Round).
-	if proposal.POLRound < -1 ||
-		(proposal.POLRound >= 0 && proposal.POLRound >= proposal.Round) {
+	// We don't care about the proposal if we're already in cstypes.RoundStepCommit.
+	if cstypes.RoundStepCommit <= cs.Step {
+		return nil
+	}
+
+	// Verify POLRound, which must be -1 or between 0 and proposal.Round exclusive.
+	if proposal.POLRound != -1 &&
+		(proposal.POLRound < 0 || proposal.Round <= proposal.POLRound) {
 		return ErrInvalidProposalPOLRound
 	}

@@ -1383,12 +1437,7 @@ func (cs *ConsensusState) defaultSetProposal(proposal *types.Proposal) error {
 	}

 	cs.Proposal = proposal
-	// We don't update cs.ProposalBlockParts if it is already set.
-	// This happens if we're already in cstypes.RoundStepCommit or if there is a valid block in the current round.
-	// TODO: We can check if Proposal is for a different block as this is a sign of misbehavior!
-	if cs.ProposalBlockParts == nil {
-		cs.ProposalBlockParts = types.NewPartSetFromHeader(proposal.BlockID.PartsHeader)
-	}
+	cs.ProposalBlockParts = types.NewPartSetFromHeader(proposal.BlockPartsHeader)
 	cs.Logger.Info("Received proposal", "proposal", proposal)
 	return nil
 }
@@ -1429,7 +1478,6 @@ func (cs *ConsensusState) addProposalBlockPart(msg *BlockPartMessage, peerID p2p
 		}
 		// NOTE: it's possible to receive complete proposal blocks for future rounds without having the proposal
 		cs.Logger.Info("Received complete proposal block", "height", cs.ProposalBlock.Height, "hash", cs.ProposalBlock.Hash())
-		cs.eventBus.PublishEventCompleteProposal(cs.CompleteProposalEvent())

 		// Update Valid* if we can.
 		prevotes := cs.Votes.Prevotes(cs.Round)
@@ -1568,26 +1616,16 @@ func (cs *ConsensusState) addVote(vote *types.Vote, peerID p2p.ID) (added bool,

 			// Update Valid* if we can.
 			// NOTE: our proposal block may be nil or not what received a polka..
-			if len(blockID.Hash) != 0 && (cs.ValidRound < vote.Round) && (vote.Round == cs.Round) {
+			// TODO: we may want to still update the ValidBlock and obtain it via gossipping
+			if len(blockID.Hash) != 0 &&
+				(cs.ValidRound < vote.Round) &&
+				(vote.Round <= cs.Round) &&
+				cs.ProposalBlock.HashesTo(blockID.Hash) {

-				if cs.ProposalBlock.HashesTo(blockID.Hash) {
-					cs.Logger.Info(
-						"Updating ValidBlock because of POL.", "validRound", cs.ValidRound, "POLRound", vote.Round)
-					cs.ValidRound = vote.Round
-					cs.ValidBlock = cs.ProposalBlock
-					cs.ValidBlockParts = cs.ProposalBlockParts
-				} else {
-					cs.Logger.Info(
-						"Valid block we don't know about. Set ProposalBlock=nil",
-						"proposal", cs.ProposalBlock.Hash(), "blockId", blockID.Hash)
-					// We're getting the wrong block.
-					cs.ProposalBlock = nil
-				}
-				if !cs.ProposalBlockParts.HasHeader(blockID.PartsHeader) {
-					cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartsHeader)
-				}
-				cs.evsw.FireEvent(types.EventValidBlock, &cs.RoundState)
-				cs.eventBus.PublishEventValidBlock(cs.RoundStateEvent())
+				cs.Logger.Info("Updating ValidBlock because of POL.", "validRound", cs.ValidRound, "POLRound", vote.Round)
+				cs.ValidRound = vote.Round
+				cs.ValidBlock = cs.ProposalBlock
+				cs.ValidBlockParts = cs.ProposalBlockParts
 			}
 		}

@@ -1596,8 +1634,7 @@ func (cs *ConsensusState) addVote(vote *types.Vote, peerID p2p.ID) (added bool,
 			// Round-skip if there is any 2/3+ of votes ahead of us
 			cs.enterNewRound(height, vote.Round)
 		} else if cs.Round == vote.Round && cstypes.RoundStepPrevote <= cs.Step { // current round
-			blockID, ok := prevotes.TwoThirdsMajority()
-			if ok && (cs.isProposalComplete() || len(blockID.Hash) == 0) {
+			if prevotes.HasTwoThirdsMajority() {
 				cs.enterPrecommit(height, vote.Round)
 			} else if prevotes.HasTwoThirdsAny() {
 				cs.enterPrevoteWait(height, vote.Round)
--- a/consensus/state_test.go
+++ b/consensus/state_test.go
@@ -197,8 +197,7 @@ func TestStateBadProposal(t *testing.T) {
 	stateHash[0] = byte((stateHash[0] + 1) % 255)
 	propBlock.AppHash = stateHash
 	propBlockParts := propBlock.MakePartSet(partSize)
-	blockID := types.BlockID{propBlock.Hash(), propBlockParts.Header()}
-	proposal := types.NewProposal(vs2.Height, round, -1, blockID)
+	proposal := types.NewProposal(vs2.Height, round, propBlockParts.Header(), -1, types.BlockID{})
 	if err := vs2.SignProposal(config.ChainID(), proposal); err != nil {
 		t.Fatal("failed to sign bad proposal", err)
 	}
@@ -212,7 +211,7 @@ func TestStateBadProposal(t *testing.T) {
 	startTestRound(cs1, height, round)

 	// wait for proposal
-	ensureProposal(proposalCh, height, round, blockID)
+	ensureNewProposal(proposalCh, height, round)

 	// wait for prevote
 	ensurePrevote(voteCh, height, round)
@@ -812,7 +811,6 @@ func TestStateLockPOLSafety2(t *testing.T) {
 	_, propBlock0 := decideProposal(cs1, vss[0], height, round)
 	propBlockHash0 := propBlock0.Hash()
 	propBlockParts0 := propBlock0.MakePartSet(partSize)
-	propBlockID0 := types.BlockID{propBlockHash0, propBlockParts0.Header()}

 	// the others sign a polka but we don't see it
 	prevotes := signVotes(types.PrevoteType, propBlockHash0, propBlockParts0.Header(), vs2, vs3, vs4)
@@ -821,6 +819,7 @@ func TestStateLockPOLSafety2(t *testing.T) {
 	prop1, propBlock1 := decideProposal(cs1, vs2, vs2.Height, vs2.Round+1)
 	propBlockHash1 := propBlock1.Hash()
 	propBlockParts1 := propBlock1.MakePartSet(partSize)
+	propBlockID1 := types.BlockID{propBlockHash1, propBlockParts1.Header()}

 	incrementRound(vs2, vs3, vs4)

@@ -855,7 +854,7 @@ func TestStateLockPOLSafety2(t *testing.T) {

 	round = round + 1 // moving to the next round
 	// in round 2 we see the polkad block from round 0
-	newProp := types.NewProposal(height, round, 0, propBlockID0)
+	newProp := types.NewProposal(height, round, propBlockParts0.Header(), 0, propBlockID1)
 	if err := vs3.SignProposal(config.ChainID(), newProp); err != nil {
 		t.Fatal(err)
 	}
@@ -910,7 +909,7 @@ func TestProposeValidBlock(t *testing.T) {
 	ensurePrevote(voteCh, height, round)
 	validatePrevote(t, cs1, round, vss[0], propBlockHash)

-	// the others sign a polka
+	// the others sign a polka but we don't see it
 	signAddVotes(cs1, types.PrevoteType, propBlockHash, propBlock.MakePartSet(partSize).Header(), vs2, vs3, vs4)

 	ensurePrecommit(voteCh, height, round)
@@ -965,119 +964,6 @@ func TestProposeValidBlock(t *testing.T) {
 	rs = cs1.GetRoundState()
 	assert.True(t, bytes.Equal(rs.ProposalBlock.Hash(), propBlockHash))
 	assert.True(t, bytes.Equal(rs.ProposalBlock.Hash(), rs.ValidBlock.Hash()))
-	assert.True(t, rs.Proposal.POLRound == rs.ValidRound)
-	assert.True(t, bytes.Equal(rs.Proposal.BlockID.Hash, rs.ValidBlock.Hash()))
-}
-
-// What we want:
-// P0 miss to lock B but set valid block to B after receiving delayed prevote.
-func TestSetValidBlockOnDelayedPrevote(t *testing.T) {
-	cs1, vss := randConsensusState(4)
-	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
-	height, round := cs1.Height, cs1.Round
-
-	partSize := types.BlockPartSizeBytes
-
-	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
-	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
-	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock)
-	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
-
-	// start round and wait for propose and prevote
-	startTestRound(cs1, cs1.Height, round)
-	ensureNewRound(newRoundCh, height, round)
-
-	ensureNewProposal(proposalCh, height, round)
-	rs := cs1.GetRoundState()
-	propBlock := rs.ProposalBlock
-	propBlockHash := propBlock.Hash()
-	propBlockParts := propBlock.MakePartSet(partSize)
-
-	ensurePrevote(voteCh, height, round)
-	validatePrevote(t, cs1, round, vss[0], propBlockHash)
-
-	// vs2 send prevote for propBlock
-	signAddVotes(cs1, types.PrevoteType, propBlockHash, propBlockParts.Header(), vs2)
-
-	// vs3 send prevote nil
-	signAddVotes(cs1, types.PrevoteType, nil, types.PartSetHeader{}, vs3)
-
-	ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.TimeoutPrevote.Nanoseconds())
-
-	ensurePrecommit(voteCh, height, round)
-	// we should have precommitted
-	validatePrecommit(t, cs1, round, -1, vss[0], nil, nil)
-
-	rs = cs1.GetRoundState()
-
-	assert.True(t, rs.ValidBlock == nil)
-	assert.True(t, rs.ValidBlockParts == nil)
-	assert.True(t, rs.ValidRound == -1)
-
-	// vs2 send (delayed) prevote for propBlock
-	signAddVotes(cs1, types.PrevoteType, propBlockHash, propBlockParts.Header(), vs4)
-
-	ensureNewValidBlock(validBlockCh, height, round)
-
-	rs = cs1.GetRoundState()
-
-	assert.True(t, bytes.Equal(rs.ValidBlock.Hash(), propBlockHash))
-	assert.True(t, rs.ValidBlockParts.Header().Equals(propBlockParts.Header()))
-	assert.True(t, rs.ValidRound == round)
-}
-
-// What we want:
-// P0 miss to lock B as Proposal Block is missing, but set valid block to B after
-// receiving delayed Block Proposal.
-func TestSetValidBlockOnDelayedProposal(t *testing.T) {
-	cs1, vss := randConsensusState(4)
-	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
-	height, round := cs1.Height, cs1.Round
-
-	partSize := types.BlockPartSizeBytes
-
-	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
-	timeoutProposeCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose)
-	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock)
-	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
-	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
-
-	round = round + 1 // move to round in which P0 is not proposer
-	incrementRound(vs2, vs3, vs4)
-
-	startTestRound(cs1, cs1.Height, round)
-	ensureNewRound(newRoundCh, height, round)
-
-	ensureNewTimeout(timeoutProposeCh, height, round, cs1.config.TimeoutPropose.Nanoseconds())
-
-	ensurePrevote(voteCh, height, round)
-	validatePrevote(t, cs1, round, vss[0], nil)
-
-	prop, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round+1)
-	propBlockHash := propBlock.Hash()
-	propBlockParts := propBlock.MakePartSet(partSize)
-
-	// vs2, vs3 and vs4 send prevote for propBlock
-	signAddVotes(cs1, types.PrevoteType, propBlockHash, propBlockParts.Header(), vs2, vs3, vs4)
-	ensureNewValidBlock(validBlockCh, height, round)
-
-	ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.TimeoutPrevote.Nanoseconds())
-
-	ensurePrecommit(voteCh, height, round)
-	validatePrecommit(t, cs1, round, -1, vss[0], nil, nil)
-
-	if err := cs1.SetProposalAndBlock(prop, propBlock, propBlockParts, "some peer"); err != nil {
-		t.Fatal(err)
-	}
-
-	ensureNewProposal(proposalCh, height, round)
-	rs := cs1.GetRoundState()
-
-	assert.True(t, bytes.Equal(rs.ValidBlock.Hash(), propBlockHash))
-	assert.True(t, rs.ValidBlockParts.Header().Equals(propBlockParts.Header()))
-	assert.True(t, rs.ValidRound == round)
 }

 // 4 vals, 3 Nil Precommits at P0
@@ -1192,80 +1078,6 @@ func TestWaitTimeoutProposeOnNilPolkaForTheCurrentRound(t *testing.T) {
 	validatePrevote(t, cs1, round, vss[0], nil)
 }

-// What we want:
-// P0 emit NewValidBlock event upon receiving 2/3+ Precommit for B but hasn't received block B yet
-func TestEmitNewValidBlockEventOnCommitWithoutBlock(t *testing.T) {
-	cs1, vss := randConsensusState(4)
-	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
-	height, round := cs1.Height, 1
-
-	incrementRound(vs2, vs3, vs4)
-
-	partSize := types.BlockPartSizeBytes
-
-	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock)
-
-	_, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round)
-	propBlockHash := propBlock.Hash()
-	propBlockParts := propBlock.MakePartSet(partSize)
-
-	// start round in which PO is not proposer
-	startTestRound(cs1, height, round)
-	ensureNewRound(newRoundCh, height, round)
-
-	// vs2, vs3 and vs4 send precommit for propBlock
-	signAddVotes(cs1, types.PrecommitType, propBlockHash, propBlockParts.Header(), vs2, vs3, vs4)
-	ensureNewValidBlock(validBlockCh, height, round)
-
-	rs := cs1.GetRoundState()
-	assert.True(t, rs.Step == cstypes.RoundStepCommit)
-	assert.True(t, rs.ProposalBlock == nil)
-	assert.True(t, rs.ProposalBlockParts.Header().Equals(propBlockParts.Header()))
-
-}
-
-// What we want:
-// P0 receives 2/3+ Precommit for B for round 0, while being in round 1. It emits NewValidBlock event.
-// After receiving block, it executes block and moves to the next height.
-func TestCommitFromPreviousRound(t *testing.T) {
-	cs1, vss := randConsensusState(4)
-	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
-	height, round := cs1.Height, 1
-
-	partSize := types.BlockPartSizeBytes
-
-	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock)
-	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
-
-	prop, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round)
-	propBlockHash := propBlock.Hash()
-	propBlockParts := propBlock.MakePartSet(partSize)
-
-	// start round in which PO is not proposer
-	startTestRound(cs1, height, round)
-	ensureNewRound(newRoundCh, height, round)
-
-	// vs2, vs3 and vs4 send precommit for propBlock for the previous round
-	signAddVotes(cs1, types.PrecommitType, propBlockHash, propBlockParts.Header(), vs2, vs3, vs4)
-
-	ensureNewValidBlock(validBlockCh, height, round)
-
-	rs := cs1.GetRoundState()
-	assert.True(t, rs.Step == cstypes.RoundStepCommit)
-	assert.True(t, rs.CommitRound == vs2.Round)
-	assert.True(t, rs.ProposalBlock == nil)
-	assert.True(t, rs.ProposalBlockParts.Header().Equals(propBlockParts.Header()))
-
-	if err := cs1.SetProposalAndBlock(prop, propBlock, propBlockParts, "some peer"); err != nil {
-		t.Fatal(err)
-	}
-
-	ensureNewProposal(proposalCh, height, round)
-	ensureNewRound(newRoundCh, height+1, 0)
-}
-
 //------------------------------------------------------------------------------------------
 // SlashingSuite
 // TODO: Slashing
--- a/consensus/types/peer_round_state.go
+++ b/consensus/types/peer_round_state.go
@@ -55,31 +55,3 @@ func (prs PeerRoundState) StringIndented(indent string) string {
 		indent, prs.CatchupCommit, prs.CatchupCommitRound,
 		indent)
 }
-
-//-----------------------------------------------------------
-// These methods are for Protobuf Compatibility
-
-// Size returns the size of the amino encoding, in bytes.
-func (ps *PeerRoundState) Size() int {
-	bs, _ := ps.Marshal()
-	return len(bs)
-}
-
-// Marshal returns the amino encoding.
-func (ps *PeerRoundState) Marshal() ([]byte, error) {
-	return cdc.MarshalBinaryBare(ps)
-}
-
-// MarshalTo calls Marshal and copies to the given buffer.
-func (ps *PeerRoundState) MarshalTo(data []byte) (int, error) {
-	bs, err := ps.Marshal()
-	if err != nil {
-		return -1, err
-	}
-	return copy(data, bs), nil
-}
-
-// Unmarshal deserializes from amino encoded form.
-func (ps *PeerRoundState) Unmarshal(bs []byte) error {
-	return cdc.UnmarshalBinaryBare(bs, ps)
-}
--- a/consensus/types/round_state.go
+++ b/consensus/types/round_state.go
@@ -26,15 +26,8 @@ const (
 	RoundStepPrecommitWait = RoundStepType(0x07) // Did receive any +2/3 precommits, start timeout
 	RoundStepCommit        = RoundStepType(0x08) // Entered commit state machine
 	// NOTE: RoundStepNewHeight acts as RoundStepCommitWait.
-
-	// NOTE: Update IsValid method if you change this!
 )

-// IsValid returns true if the step is valid, false if unknown/undefined.
-func (rs RoundStepType) IsValid() bool {
-	return uint8(rs) >= 0x01 && uint8(rs) <= 0x08
-}
-
 // String returns a string
 func (rs RoundStepType) String() string {
 	switch rs {
@@ -112,50 +105,18 @@ func (rs *RoundState) RoundStateSimple() RoundStateSimple {
 	}
 }

-// NewRoundEvent returns the RoundState with proposer information as an event.
-func (rs *RoundState) NewRoundEvent() types.EventDataNewRound {
-	addr := rs.Validators.GetProposer().Address
-	idx, _ := rs.Validators.GetByAddress(addr)
-
-	return types.EventDataNewRound{
-		Height: rs.Height,
-		Round:  rs.Round,
-		Step:   rs.Step.String(),
-		Proposer: types.ValidatorInfo{
-			Address: addr,
-			Index:   idx,
-		},
-	}
-}
-
-// CompleteProposalEvent returns information about a proposed block as an event.
-func (rs *RoundState) CompleteProposalEvent() types.EventDataCompleteProposal {
-	// We must construct BlockID from ProposalBlock and ProposalBlockParts
-	// cs.Proposal is not guaranteed to be set when this function is called
-	blockId := types.BlockID{
-		Hash:        rs.ProposalBlock.Hash(),
-		PartsHeader: rs.ProposalBlockParts.Header(),
-	}
-
-	return types.EventDataCompleteProposal{
-		Height:  rs.Height,
-		Round:   rs.Round,
-		Step:    rs.Step.String(),
-		BlockID: blockId,
-	}
-}
-
 // RoundStateEvent returns the H/R/S of the RoundState as an event.
 func (rs *RoundState) RoundStateEvent() types.EventDataRoundState {
 	// copy the RoundState.
 	// TODO: if we want to avoid this, we may need synchronous events after all
 	rsCopy := *rs
-	return types.EventDataRoundState{
+	edrs := types.EventDataRoundState{
 		Height:     rs.Height,
 		Round:      rs.Round,
 		Step:       rs.Step.String(),
 		RoundState: &rsCopy,
 	}
+	return edrs
 }

 // String returns a string
@@ -201,31 +162,3 @@ func (rs *RoundState) StringShort() string {
 	return fmt.Sprintf(`RoundState{H:%v R:%v S:%v ST:%v}`,
 		rs.Height, rs.Round, rs.Step, rs.StartTime)
 }
-
-//-----------------------------------------------------------
-// These methods are for Protobuf Compatibility
-
-// Size returns the size of the amino encoding, in bytes.
-func (rs *RoundStateSimple) Size() int {
-	bs, _ := rs.Marshal()
-	return len(bs)
-}
-
-// Marshal returns the amino encoding.
-func (rs *RoundStateSimple) Marshal() ([]byte, error) {
-	return cdc.MarshalBinaryBare(rs)
-}
-
-// MarshalTo calls Marshal and copies to the given buffer.
-func (rs *RoundStateSimple) MarshalTo(data []byte) (int, error) {
-	bs, err := rs.Marshal()
-	if err != nil {
-		return -1, err
-	}
-	return copy(data, bs), nil
-}
-
-// Unmarshal deserializes from amino encoded form.
-func (rs *RoundStateSimple) Unmarshal(bs []byte) error {
-	return cdc.UnmarshalBinaryBare(bs, rs)
-}
--- a/consensus/types/round_state_test.go
+++ b/consensus/types/round_state_test.go
@@ -63,8 +63,11 @@ func BenchmarkRoundStateDeepCopy(b *testing.B) {
 	// Random Proposal
 	proposal := &types.Proposal{
 		Timestamp: tmtime.Now(),
-		BlockID:   blockID,
-		Signature: sig,
+		BlockPartsHeader: types.PartSetHeader{
+			Hash: cmn.RandBytes(20),
+		},
+		POLBlockID: blockID,
+		Signature:  sig,
 	}
 	// Random HeightVoteSet
 	// TODO: hvs :=
--- a/consensus/wal.go
+++ b/consensus/wal.go
@@ -13,7 +13,6 @@ import (
 	amino "github.com/tendermint/go-amino"
 	auto "github.com/tendermint/tendermint/libs/autofile"
 	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
 )
@@ -96,11 +95,6 @@ func (wal *baseWAL) Group() *auto.Group {
 	return wal.group
 }

-func (wal *baseWAL) SetLogger(l log.Logger) {
-	wal.BaseService.Logger = l
-	wal.group.SetLogger(l)
-}
-
 func (wal *baseWAL) OnStart() error {
 	size, err := wal.group.Head.Size()
 	if err != nil {
--- a/consensus/wal_test.go
+++ b/consensus/wal_test.go
@@ -7,13 +7,13 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+
 	// "sync"
 	"testing"
 	"time"

 	"github.com/tendermint/tendermint/consensus/types"
 	"github.com/tendermint/tendermint/libs/autofile"
-	"github.com/tendermint/tendermint/libs/log"
 	tmtypes "github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"

@@ -23,27 +23,29 @@ import (

 func TestWALTruncate(t *testing.T) {
 	walDir, err := ioutil.TempDir("", "wal")
-	require.NoError(t, err)
+	if err != nil {
+		panic(fmt.Errorf("failed to create temp WAL file: %v", err))
+	}
 	defer os.RemoveAll(walDir)

 	walFile := filepath.Join(walDir, "wal")

 	//this magic number 4K can truncate the content when RotateFile. defaultHeadSizeLimit(10M) is hard to simulate.
 	//this magic number 1 * time.Millisecond make RotateFile check frequently. defaultGroupCheckDuration(5s) is hard to simulate.
-	wal, err := NewWAL(walFile,
-		autofile.GroupHeadSizeLimit(4096),
-		autofile.GroupCheckDuration(1*time.Millisecond),
-	)
-	require.NoError(t, err)
-	wal.SetLogger(log.TestingLogger())
-	err = wal.Start()
-	require.NoError(t, err)
+	wal, err := NewWAL(walFile, autofile.GroupHeadSizeLimit(4096), autofile.GroupCheckDuration(1*time.Millisecond))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	wal.Start()
 	defer wal.Stop()

 	//60 block's size nearly 70K, greater than group's headBuf size(4096 * 10), when headBuf is full, truncate content will Flush to the file.
 	//at this time, RotateFile is called, truncate content exist in each file.
 	err = WALGenerateNBlocks(wal.Group(), 60)
-	require.NoError(t, err)
+	if err != nil {
+		t.Fatal(err)
+	}

 	time.Sleep(1 * time.Millisecond) //wait groupCheckDuration, make sure RotateFile run

@@ -97,8 +99,9 @@ func TestWALSearchForEndHeight(t *testing.T) {
 	walFile := tempWALWithData(walBody)

 	wal, err := NewWAL(walFile)
-	require.NoError(t, err)
-	wal.SetLogger(log.TestingLogger())
+	if err != nil {
+		t.Fatal(err)
+	}

 	h := int64(3)
 	gr, found, err := wal.SearchForEndHeight(h, &WALSearchOptions{})
--- a/crypto/crypto.go
+++ b/crypto/crypto.go
@@ -1,31 +1,9 @@
 package crypto

 import (
-	"github.com/tendermint/tendermint/crypto/tmhash"
 	cmn "github.com/tendermint/tendermint/libs/common"
 )

-const (
-	// AddressSize is the size of a pubkey address.
-	AddressSize = tmhash.TruncatedSize
-)
-
-// An address is a []byte, but hex-encoded even in JSON.
-// []byte leaves us the option to change the address length.
-// Use an alias so Unmarshal methods (with ptr receivers) are available too.
-type Address = cmn.HexBytes
-
-func AddressHash(bz []byte) Address {
-	return Address(tmhash.SumTruncated(bz))
-}
-
-type PubKey interface {
-	Address() Address
-	Bytes() []byte
-	VerifyBytes(msg []byte, sig []byte) bool
-	Equals(PubKey) bool
-}
-
 type PrivKey interface {
 	Bytes() []byte
 	Sign(msg []byte) ([]byte, error)
@@ -33,6 +11,18 @@ type PrivKey interface {
 	Equals(PrivKey) bool
 }

+// An address is a []byte, but hex-encoded even in JSON.
+// []byte leaves us the option to change the address length.
+// Use an alias so Unmarshal methods (with ptr receivers) are available too.
+type Address = cmn.HexBytes
+
+type PubKey interface {
+	Address() Address
+	Bytes() []byte
+	VerifyBytes(msg []byte, sig []byte) bool
+	Equals(PubKey) bool
+}
+
 type Symmetric interface {
 	Keygen() []byte
 	Encrypt(plaintext []byte, secret []byte) (ciphertext []byte)
--- a/crypto/ed25519/ed25519.go
+++ b/crypto/ed25519/ed25519.go
@@ -136,7 +136,7 @@ type PubKeyEd25519 [PubKeyEd25519Size]byte

 // Address is the SHA256-20 of the raw pubkey bytes.
 func (pubKey PubKeyEd25519) Address() crypto.Address {
-	return crypto.Address(tmhash.SumTruncated(pubKey[:]))
+	return crypto.Address(tmhash.Sum(pubKey[:]))
 }

 // Bytes marshals the PubKey using amino encoding.
--- a/crypto/merkle/proof.go
+++ b/crypto/merkle/proof.go
@@ -43,14 +43,10 @@ func (poz ProofOperators) Verify(root []byte, keypath string, args [][]byte) (er
 	for i, op := range poz {
 		key := op.GetKey()
 		if len(key) != 0 {
-			if len(keys) == 0 {
-				return cmn.NewError("Key path has insufficient # of parts: expected no more keys but got %+v", string(key))
+			if !bytes.Equal(keys[0], key) {
+				return cmn.NewError("Key mismatch on operation #%d: expected %+v but %+v", i, []byte(keys[0]), []byte(key))
 			}
-			lastKey := keys[len(keys)-1]
-			if !bytes.Equal(lastKey, key) {
-				return cmn.NewError("Key mismatch on operation #%d: expected %+v but got %+v", i, string(lastKey), string(key))
-			}
-			keys = keys[:len(keys)-1]
+			keys = keys[1:]
 		}
 		args, err = op.Run(args)
 		if err != nil {
@@ -58,7 +54,7 @@ func (poz ProofOperators) Verify(root []byte, keypath string, args [][]byte) (er
 		}
 	}
 	if !bytes.Equal(root, args[0]) {
-		return cmn.NewError("Calculated root hash is invalid: expected %+v but got %+v", root, args[0])
+		return cmn.NewError("Calculated root hash is invalid: expected %+v but %+v", root, args[0])
 	}
 	if len(keys) != 0 {
 		return cmn.NewError("Keypath not consumed all")
--- a/crypto/merkle/proof_test.go
+++ b/crypto/merkle/proof_test.go
@@ -1,140 +0,0 @@
-package merkle
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/tendermint/go-amino"
-	cmn "github.com/tendermint/tendermint/libs/common"
-)
-
-const ProofOpDomino = "test:domino"
-
-// Expects given input, produces given output.
-// Like the game dominos.
-type DominoOp struct {
-	key    string // unexported, may be empty
-	Input  string
-	Output string
-}
-
-func NewDominoOp(key, input, output string) DominoOp {
-	return DominoOp{
-		key:    key,
-		Input:  input,
-		Output: output,
-	}
-}
-
-func DominoOpDecoder(pop ProofOp) (ProofOperator, error) {
-	if pop.Type != ProofOpDomino {
-		panic("unexpected proof op type")
-	}
-	var op DominoOp // a bit strange as we'll discard this, but it works.
-	err := amino.UnmarshalBinaryLengthPrefixed(pop.Data, &op)
-	if err != nil {
-		return nil, cmn.ErrorWrap(err, "decoding ProofOp.Data into SimpleValueOp")
-	}
-	return NewDominoOp(string(pop.Key), op.Input, op.Output), nil
-}
-
-func (dop DominoOp) ProofOp() ProofOp {
-	bz := amino.MustMarshalBinaryLengthPrefixed(dop)
-	return ProofOp{
-		Type: ProofOpDomino,
-		Key:  []byte(dop.key),
-		Data: bz,
-	}
-}
-
-func (dop DominoOp) Run(input [][]byte) (output [][]byte, err error) {
-	if len(input) != 1 {
-		return nil, cmn.NewError("Expected input of length 1")
-	}
-	if string(input[0]) != dop.Input {
-		return nil, cmn.NewError("Expected input %v, got %v",
-			dop.Input, string(input[0]))
-	}
-	return [][]byte{[]byte(dop.Output)}, nil
-}
-
-func (dop DominoOp) GetKey() []byte {
-	return []byte(dop.key)
-}
-
-//----------------------------------------
-
-func TestProofOperators(t *testing.T) {
-	var err error
-
-	// ProofRuntime setup
-	// TODO test this somehow.
-	// prt := NewProofRuntime()
-	// prt.RegisterOpDecoder(ProofOpDomino, DominoOpDecoder)
-
-	// ProofOperators setup
-	op1 := NewDominoOp("KEY1", "INPUT1", "INPUT2")
-	op2 := NewDominoOp("KEY2", "INPUT2", "INPUT3")
-	op3 := NewDominoOp("", "INPUT3", "INPUT4")
-	op4 := NewDominoOp("KEY4", "INPUT4", "OUTPUT4")
-
-	// Good
-	popz := ProofOperators([]ProofOperator{op1, op2, op3, op4})
-	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.Nil(t, err)
-	err = popz.VerifyValue(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", bz("INPUT1"))
-	assert.Nil(t, err)
-
-	// BAD INPUT
-	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1_WRONG")})
-	assert.NotNil(t, err)
-	err = popz.VerifyValue(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", bz("INPUT1_WRONG"))
-	assert.NotNil(t, err)
-
-	// BAD KEY 1
-	err = popz.Verify(bz("OUTPUT4"), "/KEY3/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.NotNil(t, err)
-
-	// BAD KEY 2
-	err = popz.Verify(bz("OUTPUT4"), "KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.NotNil(t, err)
-
-	// BAD KEY 3
-	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1/", [][]byte{bz("INPUT1")})
-	assert.NotNil(t, err)
-
-	// BAD KEY 4
-	err = popz.Verify(bz("OUTPUT4"), "//KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.NotNil(t, err)
-
-	// BAD KEY 5
-	err = popz.Verify(bz("OUTPUT4"), "/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.NotNil(t, err)
-
-	// BAD OUTPUT 1
-	err = popz.Verify(bz("OUTPUT4_WRONG"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.NotNil(t, err)
-
-	// BAD OUTPUT 2
-	err = popz.Verify(bz(""), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.NotNil(t, err)
-
-	// BAD POPZ 1
-	popz = []ProofOperator{op1, op2, op4}
-	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.NotNil(t, err)
-
-	// BAD POPZ 2
-	popz = []ProofOperator{op4, op3, op2, op1}
-	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.NotNil(t, err)
-
-	// BAD POPZ 3
-	popz = []ProofOperator{}
-	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.NotNil(t, err)
-}
-
-func bz(s string) []byte {
-	return []byte(s)
-}
--- a/crypto/merkle/simple_map_test.go
+++ b/crypto/merkle/simple_map_test.go
@@ -13,14 +13,14 @@ func TestSimpleMap(t *testing.T) {
 		values []string // each string gets converted to []byte in test
 		want   string
 	}{
-		{[]string{"key1"}, []string{"value1"}, "321d150de16dceb51c72981b432b115045383259b1a550adf8dc80f927508967"},
-		{[]string{"key1"}, []string{"value2"}, "2a9e4baf321eac99f6eecc3406603c14bc5e85bb7b80483cbfc75b3382d24a2f"},
+		{[]string{"key1"}, []string{"value1"}, "fa9bc106ffd932d919bee935ceb6cf2b3dd72d8f"},
+		{[]string{"key1"}, []string{"value2"}, "e00e7dcfe54e9fafef5111e813a587f01ba9c3e8"},
 		// swap order with 2 keys
-		{[]string{"key1", "key2"}, []string{"value1", "value2"}, "c4d8913ab543ba26aa970646d4c99a150fd641298e3367cf68ca45fb45a49881"},
-		{[]string{"key2", "key1"}, []string{"value2", "value1"}, "c4d8913ab543ba26aa970646d4c99a150fd641298e3367cf68ca45fb45a49881"},
+		{[]string{"key1", "key2"}, []string{"value1", "value2"}, "eff12d1c703a1022ab509287c0f196130123d786"},
+		{[]string{"key2", "key1"}, []string{"value2", "value1"}, "eff12d1c703a1022ab509287c0f196130123d786"},
 		// swap order with 3 keys
-		{[]string{"key1", "key2", "key3"}, []string{"value1", "value2", "value3"}, "b23cef00eda5af4548a213a43793f2752d8d9013b3f2b64bc0523a4791196268"},
-		{[]string{"key1", "key3", "key2"}, []string{"value1", "value3", "value2"}, "b23cef00eda5af4548a213a43793f2752d8d9013b3f2b64bc0523a4791196268"},
+		{[]string{"key1", "key2", "key3"}, []string{"value1", "value2", "value3"}, "b2c62a277c08dbd2ad73ca53cd1d6bfdf5830d26"},
+		{[]string{"key1", "key3", "key2"}, []string{"value1", "value3", "value2"}, "b2c62a277c08dbd2ad73ca53cd1d6bfdf5830d26"},
 	}
 	for i, tc := range tests {
 		db := newSimpleMap()
--- a/crypto/tmhash/hash.go
+++ b/crypto/tmhash/hash.go
@@ -6,27 +6,10 @@ import (
 )

 const (
-	Size      = sha256.Size
+	Size      = 20
 	BlockSize = sha256.BlockSize
 )

-// New returns a new hash.Hash.
-func New() hash.Hash {
-	return sha256.New()
-}
-
-// Sum returns the SHA256 of the bz.
-func Sum(bz []byte) []byte {
-	h := sha256.Sum256(bz)
-	return h[:]
-}
-
-//-------------------------------------------------------------
-
-const (
-	TruncatedSize = 20
-)
-
 type sha256trunc struct {
 	sha256 hash.Hash
 }
@@ -36,7 +19,7 @@ func (h sha256trunc) Write(p []byte) (n int, err error) {
 }
 func (h sha256trunc) Sum(b []byte) []byte {
 	shasum := h.sha256.Sum(b)
-	return shasum[:TruncatedSize]
+	return shasum[:Size]
 }

 func (h sha256trunc) Reset() {
@@ -44,22 +27,22 @@ func (h sha256trunc) Reset() {
 }

 func (h sha256trunc) Size() int {
-	return TruncatedSize
+	return Size
 }

 func (h sha256trunc) BlockSize() int {
 	return h.sha256.BlockSize()
 }

-// NewTruncated returns a new hash.Hash.
-func NewTruncated() hash.Hash {
+// New returns a new hash.Hash.
+func New() hash.Hash {
 	return sha256trunc{
 		sha256: sha256.New(),
 	}
 }

-// SumTruncated returns the first 20 bytes of SHA256 of the bz.
-func SumTruncated(bz []byte) []byte {
+// Sum returns the first 20 bytes of SHA256 of the bz.
+func Sum(bz []byte) []byte {
 	hash := sha256.Sum256(bz)
-	return hash[:TruncatedSize]
+	return hash[:Size]
 }
--- a/crypto/tmhash/hash_test.go
+++ b/crypto/tmhash/hash_test.go
@@ -14,29 +14,10 @@ func TestHash(t *testing.T) {
 	hasher.Write(testVector)
 	bz := hasher.Sum(nil)

-	bz2 := tmhash.Sum(testVector)
-
 	hasher = sha256.New()
 	hasher.Write(testVector)
-	bz3 := hasher.Sum(nil)
+	bz2 := hasher.Sum(nil)
+	bz2 = bz2[:20]

 	assert.Equal(t, bz, bz2)
-	assert.Equal(t, bz, bz3)
-}
-
-func TestHashTruncated(t *testing.T) {
-	testVector := []byte("abc")
-	hasher := tmhash.NewTruncated()
-	hasher.Write(testVector)
-	bz := hasher.Sum(nil)
-
-	bz2 := tmhash.SumTruncated(testVector)
-
-	hasher = sha256.New()
-	hasher.Write(testVector)
-	bz3 := hasher.Sum(nil)
-	bz3 = bz3[:tmhash.TruncatedSize]
-
-	assert.Equal(t, bz, bz2)
-	assert.Equal(t, bz, bz3)
 }
--- a/docs/README.md
+++ b/docs/README.md
@@ -21,7 +21,7 @@ For more details on using Tendermint, see the respective documentation for

 ## Contribute

-To contribute to the documentation, see [this file](https://github.com/tendermint/tendermint/blob/master/docs/DOCS_README.md) for details of the build process and
+To contribute to the documentation, see [this file](./DOCS_README.md) for details of the build process and
 considerations when making changes.

 ## Version
--- a/docs/app-dev/abci-cli.md
+++ b/docs/app-dev/abci-cli.md
@@ -11,10 +11,13 @@ Make sure you [have Go installed](https://golang.org/doc/install).
 Next, install the `abci-cli` tool and example applications:

 ```
-mkdir -p $GOPATH/src/github.com/tendermint
-cd $GOPATH/src/github.com/tendermint
-git clone https://github.com/tendermint/tendermint.git
-cd tendermint
+go get github.com/tendermint/tendermint
+```
+
+to get vendored dependencies:
+
+```
+cd $GOPATH/src/github.com/tendermint/tendermint
 make get_tools
 make get_vendor_deps
 make install_abci
--- a/docs/app-dev/app-development.md
+++ b/docs/app-dev/app-development.md
@@ -47,6 +47,90 @@ The mempool and consensus logic act as clients, and each maintains an
 open ABCI connection with the application, which hosts an ABCI server.
 Shown are the request and response types sent on each connection.

+## Message Protocol
+
+The message protocol consists of pairs of requests and responses. Some
+messages have no fields, while others may include byte-arrays, strings,
+or integers. See the `message Request` and `message Response`
+definitions in [the protobuf definition
+file](https://github.com/tendermint/tendermint/blob/develop/abci/types/types.proto),
+and the [protobuf
+documentation](https://developers.google.com/protocol-buffers/docs/overview)
+for more details.
+
+For each request, a server should respond with the corresponding
+response, where order of requests is preserved in the order of
+responses.
+
+## Server
+
+To use ABCI in your programming language of choice, there must be a ABCI
+server in that language. Tendermint supports two kinds of implementation
+of the server:
+
+- Asynchronous, raw socket server (Tendermint Socket Protocol, also
+  known as TSP or Teaspoon)
+- GRPC
+
+Both can be tested using the `abci-cli` by setting the `--abci` flag
+appropriately (ie. to `socket` or `grpc`).
+
+See examples, in various stages of maintenance, in
+[Go](https://github.com/tendermint/tendermint/tree/develop/abci/server),
+[JavaScript](https://github.com/tendermint/js-abci),
+[Python](https://github.com/tendermint/tendermint/tree/develop/abci/example/python3/abci),
+[C++](https://github.com/mdyring/cpp-tmsp), and
+[Java](https://github.com/jTendermint/jabci).
+
+### GRPC
+
+If GRPC is available in your language, this is the easiest approach,
+though it will have significant performance overhead.
+
+To get started with GRPC, copy in the [protobuf
+file](https://github.com/tendermint/tendermint/blob/develop/abci/types/types.proto)
+and compile it using the GRPC plugin for your language. For instance,
+for golang, the command is `protoc --go_out=plugins=grpc:. types.proto`.
+See the [grpc documentation for more details](http://www.grpc.io/docs/).
+`protoc` will autogenerate all the necessary code for ABCI client and
+server in your language, including whatever interface your application
+must satisfy to be used by the ABCI server for handling requests.
+
+### TSP
+
+If GRPC is not available in your language, or you require higher
+performance, or otherwise enjoy programming, you may implement your own
+ABCI server using the Tendermint Socket Protocol, known affectionately
+as Teaspoon. The first step is still to auto-generate the relevant data
+types and codec in your language using `protoc`. Messages coming over
+the socket are proto3 encoded, but additionally length-prefixed to
+facilitate use as a streaming protocol. proto3 doesn't have an
+official length-prefix standard, so we use our own. The first byte in
+the prefix represents the length of the Big Endian encoded length. The
+remaining bytes in the prefix are the Big Endian encoded length.
+
+For example, if the proto3 encoded ABCI message is 0xDEADBEEF (4
+bytes), the length-prefixed message is 0x0104DEADBEEF. If the proto3
+encoded ABCI message is 65535 bytes long, the length-prefixed message
+would be like 0x02FFFF....
+
+Note this prefixing does not apply for grpc.
+
+An ABCI server must also be able to support multiple connections, as
+Tendermint uses three connections.
+
+## Client
+
+There are currently two use-cases for an ABCI client. One is a testing
+tool, as in the `abci-cli`, which allows ABCI requests to be sent via
+command line. The other is a consensus engine, such as Tendermint Core,
+which makes requests to the application every time a new transaction is
+received or a block is committed.
+
+It is unlikely that you will need to implement a client. For details of
+our client, see
+[here](https://github.com/tendermint/tendermint/tree/develop/abci/client).
+
 Most of the examples below are from [kvstore
 application](https://github.com/tendermint/tendermint/blob/develop/abci/example/kvstore/kvstore.go),
 which is a part of the abci repo. [persistent_kvstore
--- a/docs/app-dev/ecosystem.json
+++ b/docs/app-dev/ecosystem.json
@@ -175,5 +175,35 @@
      "language": "Javascript",
      "author": "Dennis McKinnon"
    }
+  ],
+  "deploymentTools": [
+    {
+      "name": "mintnet-kubernetes",
+      "url": "https://github.com/tendermint/tools",
+      "technology": "Docker and Kubernetes",
+      "author": "Tendermint",
+      "description": "Deploy a Tendermint test network using Google's kubernetes"
+    },
+    {
+      "name": "terraforce",
+      "url": "https://github.com/tendermint/tools",
+      "technology": "Terraform",
+      "author": "Tendermint",
+      "description": "Terraform + our custom terraforce tool; deploy a production Tendermint network with load balancing over multiple AWS availability zones"
+    },
+    {
+      "name": "ansible-tendermint",
+      "url": "https://github.com/tendermint/tools",
+      "technology": "Ansible",
+      "author": "Tendermint",
+      "description": "Ansible playbooks + Tendermint"
+    },
+    {
+      "name": "brooklyn-tendermint",
+      "url": "https://github.com/cloudsoft/brooklyn-tendermint",
+      "technology": "Clocker for Apache Brooklyn ",
+      "author": "Cloudsoft",
+      "description": "Deploy a tendermint test network in docker containers "
+    }
  ]
 }
--- a/docs/app-dev/ecosystem.md
+++ b/docs/app-dev/ecosystem.md
@@ -9,3 +9,13 @@ We thank the community for their contributions thus far and welcome the
 addition of new projects. A pull request can be submitted to [this
 file](https://github.com/tendermint/tendermint/blob/master/docs/app-dev/ecosystem.json)
 to include your project.
+
+## Other Tools
+
+See [deploy testnets](./deploy-testnets) for information about all
+the tools built by Tendermint. We have Kubernetes, Ansible, and
+Terraform integrations.
+
+For upgrading from older to newer versions of tendermint and to migrate
+your chain data, see [tm-migrator](https://github.com/hxzqlh/tm-tools)
+written by @hxzqlh.
--- a/docs/app-dev/getting-started.md
+++ b/docs/app-dev/getting-started.md
@@ -252,12 +252,14 @@ we'll run a Javascript version of the `counter`. To run it, you'll need
 to [install node](https://nodejs.org/en/download/).

 You'll also need to fetch the relevant repository, from
-[here](https://github.com/tendermint/js-abci), then install it:
+[here](https://github.com/tendermint/js-abci) then install it. As go
+devs, we keep all our code under the `$GOPATH`, so run:

 ```
-git clone https://github.com/tendermint/js-abci.git
-cd js-abci
-npm install abci
+go get github.com/tendermint/js-abci &> /dev/null
+cd $GOPATH/src/github.com/tendermint/js-abci/example
+npm install
+cd ..
 ```

 Kill the previous `counter` and `tendermint` processes. Now run the app:
@@ -274,16 +276,13 @@ tendermint node
 ```

 Once again, you should see blocks streaming by - but now, our
-application is written in Javascript! Try sending some transactions, and
+application is written in javascript! Try sending some transactions, and
 like before - the results should be the same:

 ```
-# ok
-curl localhost:26657/broadcast_tx_commit?tx=0x00
-# invalid nonce
-curl localhost:26657/broadcast_tx_commit?tx=0x05
-# ok
-curl localhost:26657/broadcast_tx_commit?tx=0x01
+curl localhost:26657/broadcast_tx_commit?tx=0x00 # ok
+curl localhost:26657/broadcast_tx_commit?tx=0x05 # invalid nonce
+curl localhost:26657/broadcast_tx_commit?tx=0x01 # ok
 ```

 Neat, eh?
--- a/docs/app-dev/subscribing-to-events-via-websocket.md
+++ b/docs/app-dev/subscribing-to-events-via-websocket.md
@@ -54,7 +54,7 @@ Response:
                    "value": "ww0z4WaZ0Xg+YI10w43wTWbBmM3dpVza4mmSQYsd0ck="
                  },
                  "voting_power": "10",
-                  "proposer_priority": "0"
+                  "accum": "0"
                }
              ]
            }
--- a/docs/architecture/adr-001-logging.md
+++ b/docs/architecture/adr-001-logging.md
@@ -52,13 +52,13 @@ On top of this interface, we will need to implement a stdout logger, which will
 Many people say that they like the current output, so let's stick with it.

 ```
-NOTE[2017-04-25|14:45:08] ABCI Replay Blocks                       module=consensus appHeight=0 storeHeight=0 stateHeight=0
+NOTE[04-25|14:45:08] ABCI Replay Blocks                       module=consensus appHeight=0 storeHeight=0 stateHeight=0
 ```

 Couple of minor changes:

 ```
-I[2017-04-25|14:45:08.322] ABCI Replay Blocks            module=consensus appHeight=0 storeHeight=0 stateHeight=0
+I[04-25|14:45:08.322] ABCI Replay Blocks            module=consensus appHeight=0 storeHeight=0 stateHeight=0
 ```

 Notice the level is encoded using only one char plus milliseconds.
@@ -155,14 +155,14 @@ Important keyvals should go first. Example:

 ```
 correct
-I[2017-04-25|14:45:08.322] ABCI Replay Blocks                       module=consensus instance=1 appHeight=0 storeHeight=0 stateHeight=0
+I[04-25|14:45:08.322] ABCI Replay Blocks                       module=consensus instance=1 appHeight=0 storeHeight=0 stateHeight=0
 ```

 not

 ```
 wrong
-I[2017-04-25|14:45:08.322] ABCI Replay Blocks                       module=consensus appHeight=0 storeHeight=0 stateHeight=0 instance=1
+I[04-25|14:45:08.322] ABCI Replay Blocks                       module=consensus appHeight=0 storeHeight=0 stateHeight=0 instance=1
 ```

 for that in most cases you'll need to add `instance` field to a logger upon creating, not when u log a particular message:
--- a/docs/architecture/adr-008-priv-validator.md
+++ b/docs/architecture/adr-008-priv-validator.md
@@ -5,17 +5,14 @@ implementations:

 - FilePV uses an unencrypted private key in a "priv_validator.json" file - no
  configuration required (just `tendermint init`).
- TCPVal and IPCVal use TCP and Unix sockets respectively to send signing requests
-  to another process - the user is responsible for starting that process themselves.
+- SocketPV uses a socket to send signing requests to another process - user is
+  responsible for starting that process themselves.

-Both TCPVal and IPCVal addresses can be provided via flags at the command line
-or in the configuration file; TCPVal addresses must be of the form
-`tcp://<ip_address>:<port>` and IPCVal addresses `unix:///path/to/file.sock` -
-doing so will cause Tendermint to ignore any private validator files.
-
-TCPVal will listen on the given address for incoming connections from an external
-private validator process. It will halt any operation until at least one external
-process successfully connected.
+The SocketPV address can be provided via flags at the command line - doing so
+will cause Tendermint to ignore any "priv_validator.json" file and to listen on
+the given address for incoming connections from an external priv_validator
+process. It will halt any operation until at least one external process
+succesfully connected.

 The external priv_validator process will dial the address to connect to
 Tendermint, and then Tendermint will send requests on the ensuing connection to
@@ -24,9 +21,6 @@ but the Tendermint process makes all requests. In a later stage we're going to
 support multiple validators for fault tolerance. To prevent double signing they
 need to be synced, which is deferred to an external solution (see #1185).

-Conversely, IPCVal will make an outbound connection to an existing socket opened
-by the external validator process.
-
 In addition, Tendermint will provide implementations that can be run in that
 external process. These include:

--- a/docs/architecture/adr-033-pubsub.md
+++ b/docs/architecture/adr-033-pubsub.md
@@ -1,122 +0,0 @@
-# ADR 033: pubsub 2.0
-
-Author: Anton Kaliaev (@melekes)
-
-## Changelog
-
-02-10-2018: Initial draft
-
-## Context
-
-Since the initial version of the pubsub, there's been a number of issues
-raised: #951, #1879, #1880. Some of them are high-level issues questioning the
-core design choices made. Others are minor and mostly about the interface of
-`Subscribe()` / `Publish()` functions.
-
-### Sync vs Async
-
-Now, when publishing a message to subscribers, we can do it in a goroutine:
-
-_using channels for data transmission_
-```go
-for each subscriber {
-    out := subscriber.outc
-    go func() {
-        out <- msg
-    }
-}
-```
-
-_by invoking callback functions_
-```go
-for each subscriber {
-    go subscriber.callbackFn()
-}
-```
-
-This gives us greater performance and allows us to avoid "slow client problem"
-(when other subscribers have to wait for a slow subscriber). A pool of
-goroutines can be used to avoid uncontrolled memory growth.
-
-In certain cases, this is what you want. But in our case, because we need
-strict ordering of events (if event A was published before B, the guaranteed
-delivery order will be A -> B), we can't use goroutines.
-
-There is also a question whenever we should have a non-blocking send:
-
-```go
-for each subscriber {
-    out := subscriber.outc
-    select {
-        case out <- msg:
-        default:
-            log("subscriber %v buffer is full, skipping...")
-    }
-}
-```
-
-This fixes the "slow client problem", but there is no way for a slow client to
-know if it had missed a message. On the other hand, if we're going to stick
-with blocking send, **devs must always ensure subscriber's handling code does not
-block**. As you can see, there is an implicit choice between ordering guarantees
-and using goroutines.
-
-The interim option is to run goroutines pool for a single message, wait for all
-goroutines to finish. This will solve "slow client problem", but we'd still
-have to wait `max(goroutine_X_time)` before we can publish the next message.
-My opinion: not worth doing.
-
-### Channels vs Callbacks
-
-Yet another question is whether we should use channels for message transmission or
-call subscriber-defined callback functions. Callback functions give subscribers
-more flexibility - you can use mutexes in there, channels, spawn goroutines,
-anything you really want. But they also carry local scope, which can result in
-memory leaks and/or memory usage increase.
-
-Go channels are de-facto standard for carrying data between goroutines.
-
-**Question: Is it worth switching to callback functions?**
-
-### Why `Subscribe()` accepts an `out` channel?
-
-Because in our tests, we create buffered channels (cap: 1). Alternatively, we
-can make capacity an argument.
-
-## Decision
-
-Change Subscribe() function to return out channel:
-
-```go
-// outCap can be used to set capacity of out channel (unbuffered by default).
-Subscribe(ctx context.Context, clientID string, query Query, outCap... int) (out <-chan interface{}, err error) {
-```
-
-It's more idiomatic since we're closing it during Unsubscribe/UnsubscribeAll calls.
-
-Also, we should make tags available to subscribers:
-
-```go
-type MsgAndTags struct {
-    Msg interface{}
-    Tags TagMap
-}
-
-// outCap can be used to set capacity of out channel (unbuffered by default).
-Subscribe(ctx context.Context, clientID string, query Query, outCap... int) (out <-chan MsgAndTags, err error) {
-```
-
-## Status
-
-In review
-
-## Consequences
-
-### Positive
-
- more idiomatic interface
- subscribers know what tags msg was published with
-
-### Negative
-
-### Neutral
--- a/docs/architecture/adr-034-priv-validator-file-structure.md
+++ b/docs/architecture/adr-034-priv-validator-file-structure.md
@@ -1,72 +0,0 @@
-# ADR 034: PrivValidator file structure
-
-## Changelog
-
-03-11-2018: Initial Draft
-
-## Context
-
-For now, the PrivValidator file `priv_validator.json` contains mutable and immutable parts. 
-Even in an insecure mode which does not encrypt private key on disk, it is reasonable to separate 
-the mutable part and immutable part.
-
-References:
-[#1181](https://github.com/tendermint/tendermint/issues/1181)
-[#2657](https://github.com/tendermint/tendermint/issues/2657)
-[#2313](https://github.com/tendermint/tendermint/issues/2313)
-
-## Proposed Solution
-
-We can split mutable and immutable parts with two structs:
-```go
-// FilePVKey stores the immutable part of PrivValidator
-type FilePVKey struct {
-	Address types.Address  `json:"address"`
-	PubKey  crypto.PubKey  `json:"pub_key"`
-	PrivKey crypto.PrivKey `json:"priv_key"`
-
-	filePath string
-}
-
-// FilePVState stores the mutable part of PrivValidator
-type FilePVLastSignState struct {
-	Height    int64        `json:"height"`
-	Round     int          `json:"round"`
-	Step      int8         `json:"step"`
-	Signature []byte       `json:"signature,omitempty"`
-	SignBytes cmn.HexBytes `json:"signbytes,omitempty"`
-
-	filePath string
-	mtx      sync.Mutex
-}
-```
-
-Then we can combine `FilePVKey` with `FilePVLastSignState` and will get the original `FilePV`.
-
-```go
-type FilePV struct {
-	Key           FilePVKey
-	LastSignState FilePVLastSignState
-}
-```
-
-As discussed, `FilePV` should be located in `config`, and `FilePVLastSignState` should be stored in `data`. The 
-store path of each file should be specified in `config.yml`.
-
-What we need to do next is changing the methods of `FilePV`.
-
-## Status
-
-Draft.
-
-## Consequences
-
-### Positive
-
- separate the mutable and immutable of PrivValidator
-
-### Negative
-
- need to add more config for file path
-
-### Neutral
--- a/docs/architecture/adr-035-documentation.md
+++ b/docs/architecture/adr-035-documentation.md
@@ -1,40 +0,0 @@
-# ADR 035: Documentation
-
-Author: @zramsay (Zach Ramsay)
-
-## Changelog
-
-###  November 2nd 2018
-
- initial write-up
-
-## Context
-
-The Tendermint documentation has undergone several changes until settling on the current model. Originally, the documentation was hosted on the website and had to be updated asynchronously from the code. Along with the other repositories requiring documentation, the whole stack moved to using Read The Docs to automatically generate, publish, and host the documentation. This, however, was insufficient; the RTD site had advertisement, it wasn't easily accessible to devs, didn't collect metrics, was another set of external links, etc.
-
-## Decision
-
-For two reasons, the decision was made to use VuePress:
-
-1) ability to get metrics (implemented on both Tendermint and SDK)
-2) host the documentation on the website as a `/docs` endpoint.
-
-This is done while maintaining synchrony between the docs and code, i.e., the website is built whenever the docs are updated.
-
-## Status
-
-The two points above have been implemented; the `config.js` has a Google Analytics identifier and the documentation workflow has been up and running largely without problems for several months. Details about the documentation build & workflow can be found [here](../DOCS_README.md)
-
-## Consequences
-
-Because of the organizational seperation between Tendermint & Cosmos, there is a challenge of "what goes where" for certain aspects of documentation.
-
-### Positive
-
-This architecture is largely positive relative to prior docs arrangements.
-
-### Negative
-
-A significant portion of the docs automation / build process is in private repos with limited access/visibility to devs. However, these tasks are handled by the SRE team.
-
-### Neutral
--- a/docs/architecture/adr-template.md
+++ b/docs/architecture/adr-template.md
@@ -1,36 +1,15 @@
-# ADR {ADR-NUMBER}: {TITLE}
-
-## Changelog
-* {date}: {changelog}
+# ADR 000: Template for an ADR

 ## Context

-> This section contains all the context one needs to understand the current state, and why there is a problem. It should be as succinct as possible and introduce the high level idea behind the solution. 
 ## Decision

-> This section explains all of the details of the proposed solution, including implementation details.
-It should also describe affects / corollary items that may need to be changed as a part of this.
-If the proposed change will be large, please also indicate a way to do the change to maximize ease of review.
-(e.g. the optimal split of things to do between separate PR's)
-
 ## Status

-> A decision may be "proposed" if it hasn't been agreed upon yet, or "accepted" once it is agreed upon. If a later ADR changes or reverses a decision, it may be marked as "deprecated" or "superseded" with a reference to its replacement.
-
-{Deprecated|Proposed|Accepted}
-
 ## Consequences

-> This section describes the consequences, after applying the decision. All consequences should be summarized here, not just the "positive" ones.
-
 ### Positive

 ### Negative

 ### Neutral
-
-## References
-
-> Are there any relevant PR comments, issues that led up to this, or articles referrenced for why we made the given design choice? If so link them here!
-
-* {reference link}
--- a/docs/introduction/install.md
+++ b/docs/introduction/install.md
@@ -79,9 +79,11 @@ make install

 Install [LevelDB](https://github.com/google/leveldb) (minimum version is 1.7).

+Build Tendermint with C libraries: `make build_c`.
+
 ### Ubuntu

-Install LevelDB with snappy (optionally):
+Install LevelDB with snappy:

 ```
 sudo apt-get update
@@ -93,9 +95,9 @@ wget https://github.com/google/leveldb/archive/v1.20.tar.gz && \
  tar -zxvf v1.20.tar.gz && \
  cd leveldb-1.20/ && \
  make && \
-  sudo cp -r out-static/lib* out-shared/lib* /usr/local/lib/ && \
+  cp -r out-static/lib* out-shared/lib* /usr/local/lib/ && \
  cd include/ && \
-  sudo cp -r leveldb /usr/local/include/ && \
+  cp -r leveldb /usr/local/include/ && \
  sudo ldconfig && \
  rm -f v1.20.tar.gz
 ```
@@ -107,16 +109,8 @@ Set database backend to cleveldb:
 db_backend = "cleveldb"
 ```

-To install Tendermint, run
+To build Tendermint, run

 ```
-CGO_LDFLAGS="-lsnappy" make install_c
+CGO_LDFLAGS="-lsnappy" go build -ldflags "-X github.com/tendermint/tendermint/version.GitCommit=`git rev-parse --short=8 HEAD`" -tags "tendermint gcc" -o build/tendermint ./cmd/tendermint/
 ```
-
-or run
-
-```
-CGO_LDFLAGS="-lsnappy" make build_c
-```
-
-to put the binary in `./build`.
--- a/docs/introduction/quick-start.md
+++ b/docs/introduction/quick-start.md
@@ -40,11 +40,7 @@ These files are found in `$HOME/.tendermint`:
 ```
 $ ls $HOME/.tendermint

-config  data
-
-$ ls $HOME/.tendermint/config/
-
-config.toml  genesis.json  node_key.json  priv_validator.json
+config.toml  data  genesis.json  priv_validator.json
 ```

 For a single, local node, no further configuration is required.
@@ -114,18 +110,7 @@ source ~/.profile

 This will install `go` and other dependencies, get the Tendermint source code, then compile the `tendermint` binary.

-Next, use the `tendermint testnet` command to create four directories of config files (found in `./mytestnet`) and copy each directory to the relevant machine in the cloud, so that each machine has `$HOME/mytestnet/node[0-3]` directory.
-
-Before you can start the network, you'll need peers identifiers (IPs are not enough and can change). We'll refer to them as ID1, ID2, ID3, ID4.
-
-```
-tendermint show_node_id --home ./mytestnet/node0
-tendermint show_node_id --home ./mytestnet/node1
-tendermint show_node_id --home ./mytestnet/node2
-tendermint show_node_id --home ./mytestnet/node3
-```
-
-Finally, from each machine, run:
+Next, use the `tendermint testnet` command to create four directories of config files (found in `./mytestnet`) and copy each directory to the relevant machine in the cloud, so that each machine has `$HOME/mytestnet/node[0-3]` directory. Then from each machine, run:

 ```
 tendermint node --home ./mytestnet/node0 --proxy_app=kvstore --p2p.persistent_peers="ID1@IP1:26656,ID2@IP2:26656,ID3@IP3:26656,ID4@IP4:26656"
@@ -136,6 +121,6 @@ tendermint node --home ./mytestnet/node3 --proxy_app=kvstore --p2p.persistent_pe

 Note that after the third node is started, blocks will start to stream in
 because >2/3 of validators (defined in the `genesis.json`) have come online.
-Persistent peers can also be specified in the `config.toml`. See [here](../tendermint-core/configuration.md) for more information about configuration options.
+Seeds can also be specified in the `config.toml`. See [here](../tendermint-core/configuration.md) for more information about configuration options.

 Transactions can then be sent as covered in the single, local node example above.
--- a/docs/spec/abci/abci.md
+++ b/docs/spec/abci/abci.md
@@ -45,9 +45,7 @@ include a `Tags` field in their `Response*`. Each tag is key-value pair denoting
 something about what happened during the methods execution.

 Tags can be used to index transactions and blocks according to what happened
-during their execution. Note that the set of tags returned for a block from
-`BeginBlock` and `EndBlock` are merged. In case both methods return the same
-tag, only the value defined in `EndBlock` is used.
+during their execution.

 Keys and values in tags must be UTF-8 encoded strings (e.g.
 "account.owner": "Bob", "balance": "100.0",
@@ -443,12 +441,11 @@ Commit are included in the header of the next block.
 ###  ConsensusParams

 - **Fields**:
-  - `BlockSize (BlockSizeParams)`: Parameters limiting the size of a block.
-  - `Evidence (EvidenceParams)`: Parameters limiting the validity of
+  - `BlockSize (BlockSize)`: Parameters limiting the size of a block.
+  - `EvidenceParams (EvidenceParams)`: Parameters limiting the validity of
    evidence of byzantine behaviour.
-  - `Validator (ValidatorParams)`: Parameters limitng the types of pubkeys validators can use.

-### BlockSizeParams
+### BlockSize

 - **Fields**:
  - `MaxBytes (int64)`: Max size of a block, in bytes.
@@ -466,12 +463,6 @@ Commit are included in the header of the next block.
          similar mechanism for handling Nothing-At-Stake attacks.
        - NOTE: this should change to time (instead of blocks)!

-### ValidatorParams
-
- **Fields**:
-  - `PubKeyTypes ([]string)`: List of accepted pubkey types. Uses same
-    naming as `PubKey.Type`.
-
 ### Proof

 - **Fields**:
--- a/docs/spec/abci/client-server.md
+++ b/docs/spec/abci/client-server.md
@@ -3,8 +3,12 @@
 This section is for those looking to implement their own ABCI Server, perhaps in
 a new programming language.

-You are expected to have read [ABCI Methods and Types](./abci.md) and [ABCI
-Applications](./apps.md).
+You are expected to have read [ABCI Methods and Types](abci.md) and [ABCI
+Applications](apps.md).
+
+See additional details in the [ABCI
+readme](https://github.com/tendermint/tendermint/blob/develop/abci/README.md)(TODO: deduplicate
+those details).

 ## Message Protocol

@@ -20,16 +24,17 @@ For each request, a server should respond with the corresponding
 response, where the order of requests is preserved in the order of
 responses.

-## Server Implementations
+## Server

 To use ABCI in your programming language of choice, there must be a ABCI
-server in that language. Tendermint supports three implementations of the ABCI, written in Go:
+server in that language. Tendermint supports two kinds of implementation
+of the server:

- In-process (Golang only)
- ABCI-socket
+- Asynchronous, raw socket server (Tendermint Socket Protocol, also
+  known as TSP or Teaspoon)
 - GRPC

-The latter two can be tested using the `abci-cli` by setting the `--abci` flag
+Both can be tested using the `abci-cli` by setting the `--abci` flag
 appropriately (ie. to `socket` or `grpc`).

 See examples, in various stages of maintenance, in
@@ -39,12 +44,6 @@ See examples, in various stages of maintenance, in
 [C++](https://github.com/mdyring/cpp-tmsp), and
 [Java](https://github.com/jTendermint/jabci).

-### In Process
-
-The simplest implementation uses function calls within Golang.
-This means ABCI applications written in Golang can be compiled with TendermintCore and run as a single binary.
-
-
 ### GRPC

 If GRPC is available in your language, this is the easiest approach,
@@ -59,18 +58,15 @@ See the [grpc documentation for more details](http://www.grpc.io/docs/).
 server in your language, including whatever interface your application
 must satisfy to be used by the ABCI server for handling requests.

-Note the length-prefixing used in the socket implementation (TSP) does not apply for GRPC.
-
 ### TSP

-Tendermint Socket Protocol is an asynchronous, raw socket server which provides ordered message passing over unix or tcp.
-Messages are serialized using Protobuf3 and length-prefixed with a [signed Varint](https://developers.google.com/protocol-buffers/docs/encoding?csw=1#signed-integers)
-
 If GRPC is not available in your language, or you require higher
 performance, or otherwise enjoy programming, you may implement your own
-ABCI server using the Tendermint Socket Protocol. The first step is still to auto-generate the relevant data
-types and codec in your language using `protoc`. In addition to being proto3 encoded, messages coming over
-the socket are length-prefixed to facilitate use as a streaming protocol. proto3 doesn't have an
+ABCI server using the Tendermint Socket Protocol, known affectionately
+as Teaspoon. The first step is still to auto-generate the relevant data
+types and codec in your language using `protoc`. Messages coming over
+the socket are proto3 encoded, but additionally length-prefixed to
+facilitate use as a streaming protocol. proto3 doesn't have an
 official length-prefix standard, so we use our own. The first byte in
 the prefix represents the length of the Big Endian encoded length. The
 remaining bytes in the prefix are the Big Endian encoded length.
@@ -80,14 +76,12 @@ bytes), the length-prefixed message is 0x0104DEADBEEF. If the proto3
 encoded ABCI message is 65535 bytes long, the length-prefixed message
 would be like 0x02FFFF....

-The benefit of using this `varint` encoding over the old version (where integers were encoded as `<len of len><big endian len>` is that
-it is the standard way to encode integers in Protobuf. It is also generally shorter.
-
-As noted above, this prefixing does not apply for GRPC.
+Note this prefixing does not apply for grpc.

 An ABCI server must also be able to support multiple connections, as
 Tendermint uses three connections.

+
 ### Async vs Sync

 The main ABCI server (ie. non-GRPC) provides ordered asynchronous messages.
--- a/docs/spec/blockchain/blockchain.md
+++ b/docs/spec/blockchain/blockchain.md
@@ -146,14 +146,14 @@ The vote includes information about the validator signing it.

 ```go
 type Vote struct {
-	Type             SignedMsgType  // byte
-	Height           int64
-	Round            int
-	Timestamp        time.Time
-	BlockID          BlockID
-	ValidatorAddress Address
-	ValidatorIndex   int
-	Signature        []byte
+    ValidatorAddress    []byte
+    ValidatorIndex      int
+    Height              int64
+    Round               int
+    Timestamp           Time
+    Type                int8
+    BlockID             BlockID
+    Signature           []byte
 }
 ```

@@ -344,7 +344,7 @@ next validator sets Merkle root.
 ### ConsensusParamsHash

 ```go
-block.ConsensusParamsHash == TMHASH(amino(state.ConsensusParams))
+block.ConsensusParamsHash == tmhash(amino(state.ConsensusParams))
 ```

 Hash of the amino-encoded consensus parameters.
--- a/docs/spec/blockchain/encoding.md
+++ b/docs/spec/blockchain/encoding.md
@@ -59,14 +59,22 @@ You can simply use below table and concatenate Prefix || Length (of raw bytes) |
 | PubKeySecp256k1    | tendermint/PubKeySecp256k1    | 0xEB5AE987 | 0x21     |       |
 | PrivKeyEd25519     | tendermint/PrivKeyEd25519     | 0xA3288910 | 0x40     |       |
 | PrivKeySecp256k1   | tendermint/PrivKeySecp256k1   | 0xE1B0F79B | 0x20     |       |
-| PubKeyMultisigThreshold | tendermint/PubKeyMultisigThreshold | 0x22C1F7E2 | variable |  |
+| SignatureEd25519   | tendermint/SignatureEd25519   | 0x2031EA53 | 0x40     |       |
+| SignatureSecp256k1 | tendermint/SignatureSecp256k1 | 0x7FC4A495 | variable |

-### Example
+|

-For example, the 33-byte (or 0x21-byte in hex) Secp256k1 pubkey
+### Examples
+
+1. For example, the 33-byte (or 0x21-byte in hex) Secp256k1 pubkey
   `020BD40F225A57ED383B440CF073BC5539D0341F5767D2BF2D78406D00475A2EE9`
   would be encoded as
-   `EB5AE98721020BD40F225A57ED383B440CF073BC5539D0341F5767D2BF2D78406D00475A2EE9`
+   `EB5AE98221020BD40F225A57ED383B440CF073BC5539D0341F5767D2BF2D78406D00475A2EE9`
+
+2. For example, the variable size Secp256k1 signature (in this particular example 70 or 0x46 bytes)
+   `304402201CD4B8C764D2FD8AF23ECFE6666CA8A53886D47754D951295D2D311E1FEA33BF02201E0F906BB1CF2C30EAACFFB032A7129358AFF96B9F79B06ACFFB18AC90C2ADD7`
+   would be encoded as
+   `16E1FEEA46304402201CD4B8C764D2FD8AF23ECFE6666CA8A53886D47754D951295D2D311E1FEA33BF02201E0F906BB1CF2C30EAACFFB032A7129358AFF96B9F79B06ACFFB18AC90C2ADD7`

 ### Addresses

@@ -168,12 +176,13 @@ greater, for example:
 h0  h1          h3  h4             h0  h1  h2  h3  h4  h5
 ```

-Tendermint always uses the `TMHASH` hash function, which is equivalent to
-SHA256:
+Tendermint always uses the `TMHASH` hash function, which is the first 20-bytes
+of the SHA256:

 ```
 func TMHASH(bz []byte) []byte {
-    return SHA256(bz)
+    shasum := SHA256(bz)
+    return shasum[:20]
 }
 ```

--- a/docs/spec/blockchain/state.md
+++ b/docs/spec/blockchain/state.md
@@ -56,8 +56,8 @@ type Validator struct {
 }
 ```

-When hashing the Validator struct, the address is not included,
-because it is redundant with the pubkey.
+When hashing the Validator struct, the pubkey is not hashed,
+because the address is already the hash of the pubkey.

 The `state.Validators`, `state.LastValidators`, and `state.NextValidators`, must always by sorted by validator address,
 so that there is a canonical order for computing the SimpleMerkleRoot.
@@ -79,29 +79,31 @@ func TotalVotingPower(vals []Validators) int64{
 ConsensusParams define various limits for blockchain data structures.
 Like validator sets, they are set during genesis and can be updated by the application through ABCI.

-```go
+```
 type ConsensusParams struct {
 	BlockSize
-	Evidence
-	Validator
+	TxSize
+	BlockGossip
+	EvidenceParams
 }

 type BlockSize struct {
-	MaxBytes        int64
+	MaxBytes        int
 	MaxGas          int64
 }

-type Evidence struct {
+type TxSize struct {
+	MaxBytes int
+	MaxGas   int64
+}
+
+type BlockGossip struct {
+	BlockPartSizeBytes int
+}
+
+type EvidenceParams struct {
 	MaxAge int64
 }
-
-type Validator struct {
-	PubKeyTypes []string
-}
-
-type ValidatorParams struct {
-	PubKeyTypes []string
-}
 ```

 #### BlockSize
@@ -113,15 +115,20 @@ otherwise.
 Blocks should additionally be limited by the amount of "gas" consumed by the
 transactions in the block, though this is not yet implemented.

-#### Evidence
+#### TxSize
+
+These parameters are not yet enforced and may disappear. See [issue
+#2347](https://github.com/tendermint/tendermint/issues/2347).
+
+#### BlockGossip
+
+When gossipping blocks in the consensus, they are first split into parts. The
+size of each part is `ConsensusParams.BlockGossip.BlockPartSizeBytes`.
+
+#### EvidenceParams

 For evidence in a block to be valid, it must satisfy:

 ```
-block.Header.Height - evidence.Height < ConsensusParams.Evidence.MaxAge
+block.Header.Height - evidence.Height < ConsensusParams.EvidenceParams.MaxAge
 ```
-
-#### Validator
-
-Validators from genesis file and `ResponseEndBlock` must have pubkeys of type ∈
-`ConsensusParams.Validator.PubKeyTypes`.
--- a/docs/spec/reactors/block_sync/reactor.md
+++ b/docs/spec/reactors/block_sync/reactor.md
@@ -65,24 +65,24 @@ type Requester {
  mtx          Mutex
  block        Block
  height       int64
-   peerID       p2p.ID
-  redoChannel  chan p2p.ID //redo may send multi-time; peerId is used to identify repeat
+  peerID       p2p.ID
+  redoChannel  chan struct{}
 }
 ```

-Pool is a core data structure that stores last executed block (`height`), assignment of requests to peers (`requesters`), current height for each peer and number of pending requests for each peer (`peers`), maximum peer height, etc.
+Pool is core data structure that stores last executed block (`height`), assignment of requests to peers (`requesters`), current height for each peer and number of pending requests for each peer (`peers`), maximum peer height, etc.

 ```go
 type Pool {
-  mtx                Mutex
-  requesters         map[int64]*Requester
-  height             int64
-  peers              map[p2p.ID]*Peer
-  maxPeerHeight      int64
-  numPending         int32
-  store              BlockStore
-  requestsChannel    chan<- BlockRequest
-  errorsChannel      chan<- peerError
+  mtx Mutex
+  requesters       map[int64]*Requester
+  height           int64
+  peers            map[p2p.ID]*Peer
+  maxPeerHeight    int64
+  numPending       int32
+  store            BlockStore
+  requestsChannel  chan<- BlockRequest
+  errorsChannel    chan<- peerError
 }
 ```

@@ -90,11 +90,11 @@ Peer data structure stores for each peer current `height` and number of pending

 ```go
 type Peer struct {
-  id           p2p.ID
-  height       int64
-  numPending   int32
-  timeout      *time.Timer
-  didTimeout   bool
+  id         p2p.ID
+  height     int64
+  numPending int32
+  timeout    *time.Timer
+  didTimeout bool
 }
 ```

@@ -169,11 +169,11 @@ Requester task is responsible for fetching a single block at position `height`.

 ```go
 fetchBlock(height, pool):
-  while true do {
+  while true do
    peerID = nil
    block = nil
    peer = pickAvailablePeer(height)
-    peerID = peer.id
+    peerId = peer.id

    enqueue BlockRequest(height, peerID) to pool.requestsChannel
    redo = false
@@ -181,15 +181,12 @@ fetchBlock(height, pool):
      select {
        upon receiving Quit message do
          return
-        upon receiving redo message with id on redoChannel do
-          if peerID == id {
-            mtx.Lock()
-            pool.numPending++
-            redo = true
-            mtx.UnLock()	
-          }
+        upon receiving message on redoChannel do
+          mtx.Lock()
+          pool.numPending++
+          redo = true
+          mtx.UnLock()
      }
-    }

 pickAvailablePeer(height):
  selectedPeer = nil
@@ -247,7 +244,7 @@ createRequesters(pool):
 main(pool):
  create trySyncTicker with interval trySyncIntervalMS
  create statusUpdateTicker with interval statusUpdateIntervalSeconds
-  create switchToConsensusTicker with interval switchToConsensusIntervalSeconds
+  create switchToConsensusTicker with interbal switchToConsensusIntervalSeconds

  while true do
    select {
--- a/docs/spec/reactors/consensus/consensus-reactor.md
+++ b/docs/spec/reactors/consensus/consensus-reactor.md
@@ -129,16 +129,13 @@ handleMessage(msg):
        Reset prs.CatchupCommitRound and prs.CatchupCommit
 ```

-### NewValidBlockMessage handler
+### CommitStepMessage handler

 ```
 handleMessage(msg):
-    if prs.Height != msg.Height then return
-    
-    if prs.Round != msg.Round && !msg.IsCommit then return
-    
-    prs.ProposalBlockPartsHeader = msg.BlockPartsHeader
-    prs.ProposalBlockParts = msg.BlockParts
+    if prs.Height == msg.Height then
+        prs.ProposalBlockPartsHeader = msg.BlockPartsHeader
+        prs.ProposalBlockParts = msg.BlockParts
 ```

 ### HasVoteMessage handler
@@ -164,8 +161,8 @@ handleMessage(msg):
 handleMessage(msg):
    if prs.Height != msg.Height || prs.Round != msg.Round || prs.Proposal then return
    prs.Proposal = true
-    if prs.ProposalBlockParts == empty set then // otherwise it is set in NewValidBlockMessage handler
-      prs.ProposalBlockPartsHeader = msg.BlockPartsHeader
+    prs.ProposalBlockPartsHeader = msg.BlockPartsHeader
+    prs.ProposalBlockParts = empty set
    prs.ProposalPOLRound = msg.POLRound
    prs.ProposalPOL = nil
    Send msg through internal peerMsgQueue to ConsensusState service
@@ -338,11 +335,12 @@ BlockID has seen +2/3 votes. This routine is based on the local RoundState (`rs`

 ## Broadcast routine

-The Broadcast routine subscribes to an internal event bus to receive new round steps and votes messages, and broadcasts messages to peers upon receiving those 
-events.
+The Broadcast routine subscribes to an internal event bus to receive new round steps, votes messages and proposal
+heartbeat messages, and broadcasts messages to peers upon receiving those events.
 It broadcasts `NewRoundStepMessage` or `CommitStepMessage` upon new round state event. Note that
 broadcasting these messages does not depend on the PeerRoundState; it is sent on the StateChannel.
 Upon receiving VoteMessage it broadcasts `HasVoteMessage` message to its peers on the StateChannel.
+`ProposalHeartbeatMessage` is sent the same way on the StateChannel.

 ## Channels

--- a/docs/spec/reactors/consensus/consensus.md
+++ b/docs/spec/reactors/consensus/consensus.md
@@ -26,7 +26,7 @@ only to a subset of processes called peers. By the gossiping protocol, a validat
 all needed information (`ProposalMessage`, `VoteMessage` and `BlockPartMessage`) so they can
 reach agreement on some block, and also obtain the content of the chosen block (block parts). As
 part of the gossiping protocol, processes also send auxiliary messages that inform peers about the
-executed steps of the core consensus algorithm (`NewRoundStepMessage` and `NewValidBlockMessage`), and
+executed steps of the core consensus algorithm (`NewRoundStepMessage` and `CommitStepMessage`), and
 also messages that inform peers what votes the process has seen (`HasVoteMessage`,
 `VoteSetMaj23Message` and `VoteSetBitsMessage`). These messages are then used in the gossiping
 protocol to determine what messages a process should send to its peers.
@@ -47,21 +47,25 @@ type ProposalMessage struct {
 ### Proposal

 Proposal contains height and round for which this proposal is made, BlockID as a unique identifier
-of proposed block, timestamp, and POLRound (a so-called Proof-of-Lock (POL) round) that is needed for
-termination of the consensus. If POLRound >= 0, then BlockID corresponds to the block that 
-is locked in POLRound. The message is signed by the validator private key.
+of proposed block, timestamp, and two fields (POLRound and POLBlockID) that are needed for
+termination of the consensus. The message is signed by the validator private key.

 ```go
 type Proposal struct {
    Height           int64
    Round            int
-    POLRound         int
-    BlockID          BlockID
    Timestamp        Time
+    BlockID          BlockID
+    POLRound         int
+    POLBlockID       BlockID
    Signature        Signature
 }
 ```

+NOTE: In the current version of the Tendermint, the consensus value in proposal is represented with
+PartSetHeader, and with BlockID in vote message. It should be aligned as suggested in this spec as
+BlockID contains PartSetHeader.
+
 ## VoteMessage

 VoteMessage is sent to vote for some block (or to inform others that a process does not vote in the
@@ -89,6 +93,33 @@ type BlockPartMessage struct {
 }
 ```

+## ProposalHeartbeatMessage
+
+ProposalHeartbeatMessage is sent to signal that a node is alive and waiting for transactions
+to be able to create a next block proposal.
+
+```go
+type ProposalHeartbeatMessage struct {
+    Heartbeat Heartbeat
+}
+```
+
+### Heartbeat
+
+Heartbeat contains validator information (address and index),
+height, round and sequence number. It is signed by the private key of the validator.
+
+```go
+type Heartbeat struct {
+    ValidatorAddress []byte
+    ValidatorIndex   int
+    Height           int64
+    Round            int
+    Sequence         int
+    Signature        Signature
+}
+```
+
 ## NewRoundStepMessage

 NewRoundStepMessage is sent for every step transition during the core consensus algorithm execution.
@@ -105,26 +136,23 @@ type NewRoundStepMessage struct {
 }
 ```

-## NewValidBlockMessage
+## CommitStepMessage

-NewValidBlockMessage is sent when a validator observes a valid block B in some round r, 
-i.e., there is a Proposal for block B and 2/3+ prevotes for the block B in the round r.
-It contains height and round in which valid block is observed, block parts header that describes 
-the valid block and is used to obtain all
+CommitStepMessage is sent when an agreement on some block is reached. It contains height for which
+agreement is reached, block parts header that describes the decided block and is used to obtain all
 block parts, and a bit array of the block parts a process currently has, so its peers can know what
 parts it is missing so they can send them.
-In case the block is also committed, then IsCommit flag is set to true.

 ```go
-type NewValidBlockMessage struct {
+type CommitStepMessage struct {
    Height           int64
-    Round            int    
-    BlockPartsHeader PartSetHeader
+    BlockID          BlockID
    BlockParts       BitArray
-    IsCommit         bool
 }
 ```

+TODO: We use BlockID instead of BlockPartsHeader (in current implementation) for symmetry.
+
 ## ProposalPOLMessage

 ProposalPOLMessage is sent when a previous block is re-proposed.
--- a/docs/tendermint-core/configuration.md
+++ b/docs/tendermint-core/configuration.md
@@ -39,9 +39,6 @@ db_dir = "data"
 # Output level for logging
 log_level = "state:info,*:error"

-# Output format: 'plain' (colored text) or 'json'
-log_format = "plain"
-
 ##### additional base config options #####

 # The ID of the chain to join (should be signed with every transaction and vote)
@@ -71,17 +68,6 @@ filter_peers = false
 # TCP or UNIX socket address for the RPC server to listen on
 laddr = "tcp://0.0.0.0:26657"

-# A list of origins a cross-domain request can be executed from
-# Default value '[]' disables cors support
-# Use '["*"]' to allow any origin
-cors_allowed_origins = "[]"
-
-# A list of methods the client is allowed to use with cross-domain requests
-cors_allowed_methods = "[HEAD GET POST]"
-
-# A list of non simple headers the client is allowed to use with cross-domain requests
-cors_allowed_headers = "[Origin Accept Content-Type X-Requested-With X-Server-Time]"
-
 # TCP or UNIX socket address for the gRPC server to listen on
 # NOTE: This server only supports /broadcast_tx_commit
 grpc_laddr = ""
@@ -203,9 +189,6 @@ create_empty_blocks_interval = "0s"
 peer_gossip_sleep_duration = "100ms"
 peer_query_maj23_sleep_duration = "2000ms"

-# Block time parameters. Corresponds to the minimum time increment between consecutive blocks.
-blocktime_iota = "1000ms"
-
 ##### transactions indexer configuration options #####
 [tx_index]

--- a/docs/tendermint-core/using-tendermint.md
+++ b/docs/tendermint-core/using-tendermint.md
@@ -60,34 +60,42 @@ definition](https://github.com/tendermint/tendermint/blob/master/types/genesis.g

 ```
 {
-  "genesis_time": "2018-11-13T18:11:50.277637Z",
-  "chain_id": "test-chain-s4ui7D",
-  "consensus_params": {
-    "block_size": {
-      "max_bytes": "22020096",
-      "max_gas": "-1"
-    },
-    "evidence": {
-      "max_age": "100000"
-    },
-    "validator": {
-      "pub_key_types": [
-        "ed25519"
-      ]
-    }
-  },
+  "genesis_time": "2018-07-09T22:43:06.255718641Z",
+  "chain_id": "chain-IAkWsK",
  "validators": [
    {
-      "address": "39C04A480B54AB258A45355A5E48ADDED9956C65",
      "pub_key": {
        "type": "tendermint/PubKeyEd25519",
-        "value": "DMEMMj1+thrkUCGocbvvKzXeaAtRslvX9MWtB+smuIA="
+        "value": "oX8HhKsErMluxI0QWNSR8djQMSupDvHdAYrHwP7n73k="
      },
-      "power": "10",
-      "name": ""
+      "power": "1",
+      "name": "node0"
+    },
+    {
+      "pub_key": {
+        "type": "tendermint/PubKeyEd25519",
+        "value": "UZNSJA9zmeFQj36Rs296lY+WFQ4Rt6s7snPpuKypl5I="
+      },
+      "power": "1",
+      "name": "node1"
+    },
+    {
+      "pub_key": {
+        "type": "tendermint/PubKeyEd25519",
+        "value": "i9GrM6/MHB4zjCelMZBUYHNXYIzl4n0RkDCVmmLhS/o="
+      },
+      "power": "1",
+      "name": "node2"
+    },
+    {
+      "pub_key": {
+        "type": "tendermint/PubKeyEd25519",
+        "value": "0qq7954l87trEqbQV9c7d1gurnjTGMxreXc848ZZ5aw="
+      },
+      "power": "1",
+      "name": "node3"
    }
-  ],
-  "app_hash": ""
+  ]
 }
 ```

@@ -519,16 +527,18 @@ developers guide](../app-dev/app-development.md) for more details.

 ### Local Network

-To run a network locally, say on a single machine, you must change the `_laddr`
-fields in the `config.toml` (or using the flags) so that the listening
-addresses of the various sockets don't conflict. Additionally, you must set
-`addr_book_strict=false` in the `config.toml`, otherwise Tendermint's p2p
-library will deny making connections to peers with the same IP address.
+To run a network locally, say on a single machine, you must change the
+`_laddr` fields in the `config.toml` (or using the flags) so that the
+listening addresses of the various sockets don't conflict. Additionally,
+you must set `addr_book_strict=false` in the `config.toml`, otherwise
+Tendermint's p2p library will deny making connections to peers with the
+same IP address.

 ### Upgrading

-See the
-[UPGRADING.md](https://github.com/tendermint/tendermint/blob/master/UPGRADING.md)
-guide. You may need to reset your chain between major breaking releases.
-Although, we expect Tendermint to have fewer breaking releases in the future
-(especially after 1.0 release).
+The Tendermint development cycle currently includes a lot of breaking changes.
+Upgrading from an old version to a new version usually means throwing
+away the chain data. Try out the
+[tm-migrate](https://github.com/hxzqlh/tm-tools) tool written by
+[@hxzqlh](https://github.com/hxzqlh) if you are keen to preserve the
+state of your chain when upgrading to newer versions.
--- a/evidence/pool.go
+++ b/evidence/pool.go
@@ -127,7 +127,7 @@ func (evpool *EvidencePool) MarkEvidenceAsCommitted(height int64, evidence []typ
 	}

 	// remove committed evidence from the clist
-	maxAge := evpool.State().ConsensusParams.Evidence.MaxAge
+	maxAge := evpool.State().ConsensusParams.EvidenceParams.MaxAge
 	evpool.removeEvidence(height, maxAge, blockEvidenceMap)

 }
--- a/evidence/pool_test.go
+++ b/evidence/pool_test.go
@@ -35,10 +35,10 @@ func initializeValidatorState(valAddr []byte, height int64) dbm.DB {
 		LastBlockHeight:             0,
 		LastBlockTime:               tmtime.Now(),
 		Validators:                  valSet,
-		NextValidators:              valSet.CopyIncrementProposerPriority(1),
+		NextValidators:              valSet.CopyIncrementAccum(1),
 		LastHeightValidatorsChanged: 1,
 		ConsensusParams: types.ConsensusParams{
-			Evidence: types.EvidenceParams{
+			EvidenceParams: types.EvidenceParams{
 				MaxAge: 1000000,
 			},
 		},
--- a/evidence/reactor.go
+++ b/evidence/reactor.go
@@ -74,13 +74,6 @@ func (evR *EvidenceReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
 		evR.Switch.StopPeerForError(src, err)
 		return
 	}
-
-	if err = msg.ValidateBasic(); err != nil {
-		evR.Logger.Error("Peer sent us invalid msg", "peer", src, "msg", msg, "err", err)
-		evR.Switch.StopPeerForError(src, err)
-		return
-	}
-
 	evR.Logger.Debug("Receive", "src", src, "chId", chID, "msg", msg)

 	switch msg := msg.(type) {
@@ -160,21 +153,18 @@ func (evR *EvidenceReactor) broadcastEvidenceRoutine(peer p2p.Peer) {
 // Returns the message to send the peer, or nil if the evidence is invalid for the peer.
 // If message is nil, return true if we should sleep and try again.
 func (evR EvidenceReactor) checkSendEvidenceMessage(peer p2p.Peer, ev types.Evidence) (msg EvidenceMessage, retry bool) {
+
 	// make sure the peer is up to date
 	evHeight := ev.Height()
 	peerState, ok := peer.Get(types.PeerStateKey).(PeerState)
 	if !ok {
-		// Peer does not have a state yet. We set it in the consensus reactor, but
-		// when we add peer in Switch, the order we call reactors#AddPeer is
-		// different every time due to us using a map. Sometimes other reactors
-		// will be initialized before the consensus reactor. We should wait a few
-		// milliseconds and retry.
+		evR.Logger.Info("Found peer without PeerState", "peer", peer)
 		return nil, true
 	}

 	// NOTE: We only send evidence to peers where
 	// peerHeight - maxAge < evidenceHeight < peerHeight
-	maxAge := evR.evpool.State().ConsensusParams.Evidence.MaxAge
+	maxAge := evR.evpool.State().ConsensusParams.EvidenceParams.MaxAge
 	peerHeight := peerState.GetHeight()
 	if peerHeight < evHeight {
 		// peer is behind. sleep while he catches up
@@ -201,9 +191,7 @@ type PeerState interface {
 // Messages

 // EvidenceMessage is a message sent or received by the EvidenceReactor.
-type EvidenceMessage interface {
-	ValidateBasic() error
-}
+type EvidenceMessage interface{}

 func RegisterEvidenceMessages(cdc *amino.Codec) {
 	cdc.RegisterInterface((*EvidenceMessage)(nil), nil)
@@ -221,21 +209,11 @@ func decodeMsg(bz []byte) (msg EvidenceMessage, err error) {

 //-------------------------------------

-// EvidenceListMessage contains a list of evidence.
+// EvidenceMessage contains a list of evidence.
 type EvidenceListMessage struct {
 	Evidence []types.Evidence
 }

-// ValidateBasic performs basic validation.
-func (m *EvidenceListMessage) ValidateBasic() error {
-	for i, ev := range m.Evidence {
-		if err := ev.ValidateBasic(); err != nil {
-			return fmt.Errorf("Invalid evidence (#%d): %v", i, err)
-		}
-	}
-	return nil
-}
-
 // String returns a string representation of the EvidenceListMessage.
 func (m *EvidenceListMessage) String() string {
 	return fmt.Sprintf("[EvidenceListMessage %v]", m.Evidence)
--- a/evidence/reactor_test.go
+++ b/evidence/reactor_test.go
@@ -10,7 +10,6 @@ import (
 	"github.com/stretchr/testify/assert"

 	cfg "github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/crypto/secp256k1"
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/p2p"
@@ -165,16 +164,6 @@ func TestReactorSelectiveBroadcast(t *testing.T) {

 	// make reactors from statedb
 	reactors := makeAndConnectEvidenceReactors(config, []dbm.DB{stateDB1, stateDB2})
-
-	// set the peer height on each reactor
-	for _, r := range reactors {
-		for _, peer := range r.Switch.Peers().List() {
-			ps := peerState{height1}
-			peer.Set(types.PeerStateKey, ps)
-		}
-	}
-
-	// update the first reactor peer's height to be very small
 	peer := reactors[0].Switch.Peers().List()[0]
 	ps := peerState{height2}
 	peer.Set(types.PeerStateKey, ps)
@@ -189,30 +178,3 @@ func TestReactorSelectiveBroadcast(t *testing.T) {
 	peers := reactors[1].Switch.Peers().List()
 	assert.Equal(t, 1, len(peers))
 }
-func TestEvidenceListMessageValidationBasic(t *testing.T) {
-
-	testCases := []struct {
-		testName          string
-		malleateEvListMsg func(*EvidenceListMessage)
-		expectErr         bool
-	}{
-		{"Good EvidenceListMessage", func(evList *EvidenceListMessage) {}, false},
-		{"Invalid EvidenceListMessage", func(evList *EvidenceListMessage) {
-			evList.Evidence = append(evList.Evidence,
-				&types.DuplicateVoteEvidence{PubKey: secp256k1.GenPrivKey().PubKey()})
-		}, true},
-	}
-	for _, tc := range testCases {
-		t.Run(tc.testName, func(t *testing.T) {
-			evListMsg := &EvidenceListMessage{}
-			n := 3
-			valAddr := []byte("myval")
-			evListMsg.Evidence = make([]types.Evidence, n)
-			for i := 0; i < n; i++ {
-				evListMsg.Evidence[i] = types.NewMockGoodEvidence(int64(i+1), 0, valAddr)
-			}
-			tc.malleateEvListMsg(evListMsg)
-			assert.Equal(t, tc.expectErr, evListMsg.ValidateBasic() != nil, "Validate Basic had an unexpected result")
-		})
-	}
-}
--- a/libs/autofile/autofile.go
+++ b/libs/autofile/autofile.go
@@ -8,6 +8,7 @@ import (
 	"time"

 	cmn "github.com/tendermint/tendermint/libs/common"
+	"github.com/tendermint/tendermint/libs/errors"
 )

 /* AutoFile usage
@@ -82,8 +83,6 @@ func OpenAutoFile(path string) (*AutoFile, error) {
 	return af, nil
 }

-// Close shuts down the closing goroutine, SIGHUP handler and closes the
-// AutoFile.
 func (af *AutoFile) Close() error {
 	af.closeTicker.Stop()
 	close(af.closeTickerStopc)
@@ -117,10 +116,6 @@ func (af *AutoFile) closeFile() (err error) {
 	return file.Close()
 }

-// Write writes len(b) bytes to the AutoFile. It returns the number of bytes
-// written and an error, if any. Write returns a non-nil error when n !=
-// len(b).
-// Opens AutoFile if needed.
 func (af *AutoFile) Write(b []byte) (n int, err error) {
 	af.mtx.Lock()
 	defer af.mtx.Unlock()
@@ -135,10 +130,6 @@ func (af *AutoFile) Write(b []byte) (n int, err error) {
 	return
 }

-// Sync commits the current contents of the file to stable storage. Typically,
-// this means flushing the file system's in-memory copy of recently written
-// data to disk.
-// Opens AutoFile if needed.
 func (af *AutoFile) Sync() error {
 	af.mtx.Lock()
 	defer af.mtx.Unlock()
@@ -156,33 +147,34 @@ func (af *AutoFile) openFile() error {
 	if err != nil {
 		return err
 	}
-	// fileInfo, err := file.Stat()
-	// if err != nil {
-	// 	return err
-	// }
-	// if fileInfo.Mode() != autoFilePerms {
-	// 	return errors.NewErrPermissionsChanged(file.Name(), fileInfo.Mode(), autoFilePerms)
-	// }
+	fileInfo, err := file.Stat()
+	if err != nil {
+		return err
+	}
+	if fileInfo.Mode() != autoFilePerms {
+		return errors.NewErrPermissionsChanged(file.Name(), fileInfo.Mode(), autoFilePerms)
+	}
 	af.file = file
 	return nil
 }

-// Size returns the size of the AutoFile. It returns -1 and an error if fails
-// get stats or open file.
-// Opens AutoFile if needed.
 func (af *AutoFile) Size() (int64, error) {
 	af.mtx.Lock()
 	defer af.mtx.Unlock()

 	if af.file == nil {
-		if err := af.openFile(); err != nil {
+		err := af.openFile()
+		if err != nil {
+			if err == os.ErrNotExist {
+				return 0, nil
+			}
 			return -1, err
 		}
 	}
-
 	stat, err := af.file.Stat()
 	if err != nil {
 		return -1, err
 	}
 	return stat.Size(), nil
+
 }
--- a/libs/autofile/autofile_test.go
+++ b/libs/autofile/autofile_test.go
@@ -10,6 +10,7 @@ import (
 	"github.com/stretchr/testify/require"

 	cmn "github.com/tendermint/tendermint/libs/common"
+	"github.com/tendermint/tendermint/libs/errors"
 )

 func TestSIGHUP(t *testing.T) {
@@ -57,66 +58,29 @@ func TestSIGHUP(t *testing.T) {
 	}
 }

-// // Manually modify file permissions, close, and reopen using autofile:
-// // We expect the file permissions to be changed back to the intended perms.
-// func TestOpenAutoFilePerms(t *testing.T) {
-// 	file, err := ioutil.TempFile("", "permission_test")
-// 	require.NoError(t, err)
-// 	err = file.Close()
-// 	require.NoError(t, err)
-// 	name := file.Name()
-
-// 	// open and change permissions
-// 	af, err := OpenAutoFile(name)
-// 	require.NoError(t, err)
-// 	err = af.file.Chmod(0755)
-// 	require.NoError(t, err)
-// 	err = af.Close()
-// 	require.NoError(t, err)
-
-// 	// reopen and expect an ErrPermissionsChanged as Cause
-// 	af, err = OpenAutoFile(name)
-// 	require.Error(t, err)
-// 	if e, ok := err.(*errors.ErrPermissionsChanged); ok {
-// 		t.Logf("%v", e)
-// 	} else {
-// 		t.Errorf("unexpected error %v", e)
-// 	}
-// }
-
-func TestAutoFileSize(t *testing.T) {
-	// First, create an AutoFile writing to a tempfile dir
-	f, err := ioutil.TempFile("", "sighup_test")
+// Manually modify file permissions, close, and reopen using autofile:
+// We expect the file permissions to be changed back to the intended perms.
+func TestOpenAutoFilePerms(t *testing.T) {
+	file, err := ioutil.TempFile("", "permission_test")
 	require.NoError(t, err)
-	err = f.Close()
+	err = file.Close()
 	require.NoError(t, err)
+	name := file.Name()

-	// Here is the actual AutoFile.
-	af, err := OpenAutoFile(f.Name())
+	// open and change permissions
+	af, err := OpenAutoFile(name)
 	require.NoError(t, err)
-
-	// 1. Empty file
-	size, err := af.Size()
-	require.Zero(t, size)
+	err = af.file.Chmod(0755)
 	require.NoError(t, err)
-
-	// 2. Not empty file
-	data := []byte("Maniac\n")
-	_, err = af.Write(data)
-	require.NoError(t, err)
-	size, err = af.Size()
-	require.EqualValues(t, len(data), size)
-	require.NoError(t, err)
-
-	// 3. Not existing file
 	err = af.Close()
 	require.NoError(t, err)
-	err = os.Remove(f.Name())
-	require.NoError(t, err)
-	size, err = af.Size()
-	require.EqualValues(t, 0, size, "Expected a new file to be empty")
-	require.NoError(t, err)

-	// Cleanup
-	_ = os.Remove(f.Name())
+	// reopen and expect an ErrPermissionsChanged as Cause
+	af, err = OpenAutoFile(name)
+	require.Error(t, err)
+	if e, ok := err.(*errors.ErrPermissionsChanged); ok {
+		t.Logf("%v", e)
+	} else {
+		t.Errorf("unexpected error %v", e)
+	}
 }
--- a/libs/autofile/group.go
+++ b/libs/autofile/group.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"path"
 	"path/filepath"
@@ -230,8 +231,7 @@ func (g *Group) checkHeadSizeLimit() {
 	}
 	size, err := g.Head.Size()
 	if err != nil {
-		g.Logger.Error("Group's head may grow without bound", "head", g.Head.Path, "err", err)
-		return
+		panic(err)
 	}
 	if size >= limit {
 		g.RotateFile()
@@ -253,21 +253,21 @@ func (g *Group) checkTotalSizeLimit() {
 		}
 		if index == gInfo.MaxIndex {
 			// Special degenerate case, just do nothing.
-			g.Logger.Error("Group's head may grow without bound", "head", g.Head.Path)
+			log.Println("WARNING: Group's head " + g.Head.Path + "may grow without bound")
 			return
 		}
 		pathToRemove := filePathForIndex(g.Head.Path, index, gInfo.MaxIndex)
-		fInfo, err := os.Stat(pathToRemove)
+		fileInfo, err := os.Stat(pathToRemove)
 		if err != nil {
-			g.Logger.Error("Failed to fetch info for file", "file", pathToRemove)
+			log.Println("WARNING: Failed to fetch info for file @" + pathToRemove)
 			continue
 		}
 		err = os.Remove(pathToRemove)
 		if err != nil {
-			g.Logger.Error("Failed to remove path", "path", pathToRemove)
+			log.Println(err)
 			return
 		}
-		totalSize -= fInfo.Size()
+		totalSize -= fileInfo.Size()
 	}
 }

--- a/libs/cli/flags/log_level_test.go
+++ b/libs/cli/flags/log_level_test.go
@@ -51,7 +51,7 @@ func TestParseLogLevel(t *testing.T) {

 		buf.Reset()

-		logger.With("module", "mempool").With("module", "wire").Debug("Kingpin")
+		logger.With("module", "wire").Debug("Kingpin")
 		if have := strings.TrimSpace(buf.String()); c.expectedLogLines[0] != have {
 			t.Errorf("\nwant '%s'\nhave '%s'\nlevel '%s'", c.expectedLogLines[0], have, c.lvl)
 		}
--- a/libs/common/string.go
+++ b/libs/common/string.go
@@ -61,16 +61,3 @@ func ASCIITrim(s string) string {
 	}
 	return string(r)
 }
-
-// StringSliceEqual checks if string slices a and b are equal
-func StringSliceEqual(a, b []string) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for i := 0; i < len(a); i++ {
-		if a[i] != b[i] {
-			return false
-		}
-	}
-	return true
-}
--- a/libs/common/string_test.go
+++ b/libs/common/string_test.go
@@ -3,8 +3,6 @@ package common
 import (
 	"testing"

-	"github.com/stretchr/testify/require"
-
 	"github.com/stretchr/testify/assert"
 )

@@ -37,22 +35,3 @@ func TestASCIITrim(t *testing.T) {
 	assert.Equal(t, ASCIITrim(" a "), "a")
 	assert.Panics(t, func() { ASCIITrim("\xC2\xA2") })
 }
-
-func TestStringSliceEqual(t *testing.T) {
-	tests := []struct {
-		a    []string
-		b    []string
-		want bool
-	}{
-		{[]string{"hello", "world"}, []string{"hello", "world"}, true},
-		{[]string{"test"}, []string{"test"}, true},
-		{[]string{"test1"}, []string{"test2"}, false},
-		{[]string{"hello", "world."}, []string{"hello", "world!"}, false},
-		{[]string{"only 1 word"}, []string{"two", "words!"}, false},
-		{[]string{"two", "words!"}, []string{"only 1 word"}, false},
-	}
-	for i, tt := range tests {
-		require.Equal(t, tt.want, StringSliceEqual(tt.a, tt.b),
-			"StringSliceEqual failed on test %d", i)
-	}
-}
--- a/libs/db/backend_test.go
+++ b/libs/db/backend_test.go
@@ -180,13 +180,13 @@ func testDBIterator(t *testing.T, backend DBBackendType) {
 	verifyIterator(t, db.ReverseIterator(nil, nil), []int64{9, 8, 7, 5, 4, 3, 2, 1, 0}, "reverse iterator")

 	verifyIterator(t, db.Iterator(nil, int642Bytes(0)), []int64(nil), "forward iterator to 0")
-	verifyIterator(t, db.ReverseIterator(int642Bytes(10), nil), []int64(nil), "reverse iterator from 10 (ex)")
+	verifyIterator(t, db.ReverseIterator(nil, int642Bytes(10)), []int64(nil), "reverse iterator 10")

 	verifyIterator(t, db.Iterator(int642Bytes(0), nil), []int64{0, 1, 2, 3, 4, 5, 7, 8, 9}, "forward iterator from 0")
 	verifyIterator(t, db.Iterator(int642Bytes(1), nil), []int64{1, 2, 3, 4, 5, 7, 8, 9}, "forward iterator from 1")
-	verifyIterator(t, db.ReverseIterator(nil, int642Bytes(10)), []int64{9, 8, 7, 5, 4, 3, 2, 1, 0}, "reverse iterator from 10 (ex)")
-	verifyIterator(t, db.ReverseIterator(nil, int642Bytes(9)), []int64{8, 7, 5, 4, 3, 2, 1, 0}, "reverse iterator from 9 (ex)")
-	verifyIterator(t, db.ReverseIterator(nil, int642Bytes(8)), []int64{7, 5, 4, 3, 2, 1, 0}, "reverse iterator from 8 (ex)")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(10), nil), []int64{9, 8, 7, 5, 4, 3, 2, 1, 0}, "reverse iterator from 10")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(9), nil), []int64{9, 8, 7, 5, 4, 3, 2, 1, 0}, "reverse iterator from 9")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(8), nil), []int64{8, 7, 5, 4, 3, 2, 1, 0}, "reverse iterator from 8")

 	verifyIterator(t, db.Iterator(int642Bytes(5), int642Bytes(6)), []int64{5}, "forward iterator from 5 to 6")
 	verifyIterator(t, db.Iterator(int642Bytes(5), int642Bytes(7)), []int64{5}, "forward iterator from 5 to 7")
@@ -195,20 +195,20 @@ func testDBIterator(t *testing.T, backend DBBackendType) {
 	verifyIterator(t, db.Iterator(int642Bytes(6), int642Bytes(8)), []int64{7}, "forward iterator from 6 to 8")
 	verifyIterator(t, db.Iterator(int642Bytes(7), int642Bytes(8)), []int64{7}, "forward iterator from 7 to 8")

-	verifyIterator(t, db.ReverseIterator(int642Bytes(4), int642Bytes(5)), []int64{4}, "reverse iterator from 5 (ex) to 4")
-	verifyIterator(t, db.ReverseIterator(int642Bytes(4), int642Bytes(6)), []int64{5, 4}, "reverse iterator from 6 (ex) to 4")
-	verifyIterator(t, db.ReverseIterator(int642Bytes(4), int642Bytes(7)), []int64{5, 4}, "reverse iterator from 7 (ex) to 4")
-	verifyIterator(t, db.ReverseIterator(int642Bytes(5), int642Bytes(6)), []int64{5}, "reverse iterator from 6 (ex) to 5")
-	verifyIterator(t, db.ReverseIterator(int642Bytes(5), int642Bytes(7)), []int64{5}, "reverse iterator from 7 (ex) to 5")
-	verifyIterator(t, db.ReverseIterator(int642Bytes(6), int642Bytes(7)), []int64(nil), "reverse iterator from 7 (ex) to 6")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(5), int642Bytes(4)), []int64{5}, "reverse iterator from 5 to 4")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(6), int642Bytes(4)), []int64{5}, "reverse iterator from 6 to 4")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(7), int642Bytes(4)), []int64{7, 5}, "reverse iterator from 7 to 4")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(6), int642Bytes(5)), []int64(nil), "reverse iterator from 6 to 5")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(7), int642Bytes(5)), []int64{7}, "reverse iterator from 7 to 5")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(7), int642Bytes(6)), []int64{7}, "reverse iterator from 7 to 6")

 	verifyIterator(t, db.Iterator(int642Bytes(0), int642Bytes(1)), []int64{0}, "forward iterator from 0 to 1")
-	verifyIterator(t, db.ReverseIterator(int642Bytes(8), int642Bytes(9)), []int64{8}, "reverse iterator from 9 (ex) to 8")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(9), int642Bytes(8)), []int64{9}, "reverse iterator from 9 to 8")

 	verifyIterator(t, db.Iterator(int642Bytes(2), int642Bytes(4)), []int64{2, 3}, "forward iterator from 2 to 4")
 	verifyIterator(t, db.Iterator(int642Bytes(4), int642Bytes(2)), []int64(nil), "forward iterator from 4 to 2")
-	verifyIterator(t, db.ReverseIterator(int642Bytes(2), int642Bytes(4)), []int64{3, 2}, "reverse iterator from 4 (ex) to 2")
-	verifyIterator(t, db.ReverseIterator(int642Bytes(4), int642Bytes(2)), []int64(nil), "reverse iterator from 2 (ex) to 4")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(4), int642Bytes(2)), []int64{4, 3}, "reverse iterator from 4 to 2")
+	verifyIterator(t, db.ReverseIterator(int642Bytes(2), int642Bytes(4)), []int64(nil), "reverse iterator from 2 to 4")

 }

--- a/libs/db/c_level_db.go
+++ b/libs/db/c_level_db.go
@@ -205,13 +205,13 @@ type cLevelDBIterator struct {

 func newCLevelDBIterator(source *levigo.Iterator, start, end []byte, isReverse bool) *cLevelDBIterator {
 	if isReverse {
-		if end == nil {
+		if start == nil {
 			source.SeekToLast()
 		} else {
-			source.Seek(end)
+			source.Seek(start)
 			if source.Valid() {
-				eoakey := source.Key() // end or after key
-				if bytes.Compare(end, eoakey) <= 0 {
+				soakey := source.Key() // start or after key
+				if bytes.Compare(start, soakey) < 0 {
 					source.Prev()
 				}
 			} else {
@@ -255,11 +255,10 @@ func (itr cLevelDBIterator) Valid() bool {
 	}

 	// If key is end or past it, invalid.
-	var start = itr.start
 	var end = itr.end
 	var key = itr.source.Key()
 	if itr.isReverse {
-		if start != nil && bytes.Compare(key, start) < 0 {
+		if end != nil && bytes.Compare(key, end) <= 0 {
 			itr.isInvalid = true
 			return false
 		}
--- a/libs/db/fsdb.go
+++ b/libs/db/fsdb.go
@@ -12,6 +12,7 @@ import (
 	"github.com/pkg/errors"

 	cmn "github.com/tendermint/tendermint/libs/common"
+	tmerrors "github.com/tendermint/tendermint/libs/errors"
 )

 const (
@@ -161,7 +162,7 @@ func (db *FSDB) MakeIterator(start, end []byte, isReversed bool) Iterator {

 	// We need a copy of all of the keys.
 	// Not the best, but probably not a bottleneck depending.
-	keys, err := list(db.dir, start, end)
+	keys, err := list(db.dir, start, end, isReversed)
 	if err != nil {
 		panic(errors.Wrapf(err, "Listing keys in %s", db.dir))
 	}
@@ -206,13 +207,13 @@ func write(path string, d []byte) error {
 		return err
 	}
 	defer f.Close()
-	// fInfo, err := f.Stat()
-	// if err != nil {
-	// 	return err
-	// }
-	// if fInfo.Mode() != keyPerm {
-	// 	return tmerrors.NewErrPermissionsChanged(f.Name(), keyPerm, fInfo.Mode())
-	// }
+	fInfo, err := f.Stat()
+	if err != nil {
+		return err
+	}
+	if fInfo.Mode() != keyPerm {
+		return tmerrors.NewErrPermissionsChanged(f.Name(), keyPerm, fInfo.Mode())
+	}
 	_, err = f.Write(d)
 	if err != nil {
 		return err
@@ -229,7 +230,7 @@ func remove(path string) error {

 // List keys in a directory, stripping of escape sequences and dir portions.
 // CONTRACT: returns os errors directly without wrapping.
-func list(dirPath string, start, end []byte) ([]string, error) {
+func list(dirPath string, start, end []byte, isReversed bool) ([]string, error) {
 	dir, err := os.Open(dirPath)
 	if err != nil {
 		return nil, err
@@ -247,7 +248,7 @@ func list(dirPath string, start, end []byte) ([]string, error) {
 			return nil, fmt.Errorf("Failed to unescape %s while listing", name)
 		}
 		key := unescapeKey([]byte(n))
-		if IsKeyInDomain(key, start, end) {
+		if IsKeyInDomain(key, start, end, isReversed) {
 			keys = append(keys, string(key))
 		}
 	}
--- a/libs/db/go_level_db.go
+++ b/libs/db/go_level_db.go
@@ -213,13 +213,13 @@ var _ Iterator = (*goLevelDBIterator)(nil)

 func newGoLevelDBIterator(source iterator.Iterator, start, end []byte, isReverse bool) *goLevelDBIterator {
 	if isReverse {
-		if end == nil {
+		if start == nil {
 			source.Last()
 		} else {
-			valid := source.Seek(end)
+			valid := source.Seek(start)
 			if valid {
-				eoakey := source.Key() // end or after key
-				if bytes.Compare(end, eoakey) <= 0 {
+				soakey := source.Key() // start or after key
+				if bytes.Compare(start, soakey) < 0 {
 					source.Prev()
 				}
 			} else {
@@ -265,12 +265,11 @@ func (itr *goLevelDBIterator) Valid() bool {
 	}

 	// If key is end or past it, invalid.
-	var start = itr.start
 	var end = itr.end
 	var key = itr.source.Key()

 	if itr.isReverse {
-		if start != nil && bytes.Compare(key, start) < 0 {
+		if end != nil && bytes.Compare(key, end) <= 0 {
 			itr.isInvalid = true
 			return false
 		}
--- a/libs/db/mem_db.go
+++ b/libs/db/mem_db.go
@@ -237,7 +237,7 @@ func (itr *memDBIterator) assertIsValid() {
 func (db *MemDB) getSortedKeys(start, end []byte, reverse bool) []string {
 	keys := []string{}
 	for key := range db.db {
-		inDomain := IsKeyInDomain([]byte(key), start, end)
+		inDomain := IsKeyInDomain([]byte(key), start, end, reverse)
 		if inDomain {
 			keys = append(keys, key)
 		}
--- a/libs/db/prefix_db.go
+++ b/libs/db/prefix_db.go
@@ -131,13 +131,27 @@ func (pdb *prefixDB) ReverseIterator(start, end []byte) Iterator {
 	defer pdb.mtx.Unlock()

 	var pstart, pend []byte
-	pstart = append(cp(pdb.prefix), start...)
+	if start == nil {
+		// This may cause the underlying iterator to start with
+		// an item which doesn't start with prefix.  We will skip
+		// that item later in this function. See 'skipOne'.
+		pstart = cpIncr(pdb.prefix)
+	} else {
+		pstart = append(cp(pdb.prefix), start...)
+	}
 	if end == nil {
-		pend = cpIncr(pdb.prefix)
+		// This may cause the underlying iterator to end with an
+		// item which doesn't start with prefix.  The
+		// prefixIterator will terminate iteration
+		// automatically upon detecting this.
+		pend = cpDecr(pdb.prefix)
 	} else {
 		pend = append(cp(pdb.prefix), end...)
 	}
 	ritr := pdb.db.ReverseIterator(pstart, pend)
+	if start == nil {
+		skipOne(ritr, cpIncr(pdb.prefix))
+	}
 	return newPrefixIterator(
 		pdb.prefix,
 		start,
@@ -296,6 +310,7 @@ func (itr *prefixIterator) Next() {
 	}
 	itr.source.Next()
 	if !itr.source.Valid() || !bytes.HasPrefix(itr.source.Key(), itr.prefix) {
+		itr.source.Close()
 		itr.valid = false
 		return
 	}
@@ -330,3 +345,13 @@ func stripPrefix(key []byte, prefix []byte) (stripped []byte) {
 	}
 	return key[len(prefix):]
 }
+
+// If the first iterator item is skipKey, then
+// skip it.
+func skipOne(itr Iterator, skipKey []byte) {
+	if itr.Valid() {
+		if bytes.Equal(itr.Key(), skipKey) {
+			itr.Next()
+		}
+	}
+}
--- a/libs/db/prefix_db_test.go
+++ b/libs/db/prefix_db_test.go
@@ -113,15 +113,13 @@ func TestPrefixDBReverseIterator2(t *testing.T) {
 	db := mockDBWithStuff()
 	pdb := NewPrefixDB(db, bz("key"))

-	itr := pdb.ReverseIterator(bz(""), nil)
-	checkDomain(t, itr, bz(""), nil)
+	itr := pdb.ReverseIterator(nil, bz(""))
+	checkDomain(t, itr, nil, bz(""))
 	checkItem(t, itr, bz("3"), bz("value3"))
 	checkNext(t, itr, true)
 	checkItem(t, itr, bz("2"), bz("value2"))
 	checkNext(t, itr, true)
 	checkItem(t, itr, bz("1"), bz("value1"))
-	checkNext(t, itr, true)
-	checkItem(t, itr, bz(""), bz("value"))
 	checkNext(t, itr, false)
 	checkInvalid(t, itr)
 	itr.Close()
@@ -131,8 +129,10 @@ func TestPrefixDBReverseIterator3(t *testing.T) {
 	db := mockDBWithStuff()
 	pdb := NewPrefixDB(db, bz("key"))

-	itr := pdb.ReverseIterator(nil, bz(""))
-	checkDomain(t, itr, nil, bz(""))
+	itr := pdb.ReverseIterator(bz(""), nil)
+	checkDomain(t, itr, bz(""), nil)
+	checkItem(t, itr, bz(""), bz("value"))
+	checkNext(t, itr, false)
 	checkInvalid(t, itr)
 	itr.Close()
 }
@@ -142,51 +142,6 @@ func TestPrefixDBReverseIterator4(t *testing.T) {
 	pdb := NewPrefixDB(db, bz("key"))

 	itr := pdb.ReverseIterator(bz(""), bz(""))
-	checkDomain(t, itr, bz(""), bz(""))
-	checkInvalid(t, itr)
-	itr.Close()
-}
-
-func TestPrefixDBReverseIterator5(t *testing.T) {
-	db := mockDBWithStuff()
-	pdb := NewPrefixDB(db, bz("key"))
-
-	itr := pdb.ReverseIterator(bz("1"), nil)
-	checkDomain(t, itr, bz("1"), nil)
-	checkItem(t, itr, bz("3"), bz("value3"))
-	checkNext(t, itr, true)
-	checkItem(t, itr, bz("2"), bz("value2"))
-	checkNext(t, itr, true)
-	checkItem(t, itr, bz("1"), bz("value1"))
-	checkNext(t, itr, false)
-	checkInvalid(t, itr)
-	itr.Close()
-}
-
-func TestPrefixDBReverseIterator6(t *testing.T) {
-	db := mockDBWithStuff()
-	pdb := NewPrefixDB(db, bz("key"))
-
-	itr := pdb.ReverseIterator(bz("2"), nil)
-	checkDomain(t, itr, bz("2"), nil)
-	checkItem(t, itr, bz("3"), bz("value3"))
-	checkNext(t, itr, true)
-	checkItem(t, itr, bz("2"), bz("value2"))
-	checkNext(t, itr, false)
-	checkInvalid(t, itr)
-	itr.Close()
-}
-
-func TestPrefixDBReverseIterator7(t *testing.T) {
-	db := mockDBWithStuff()
-	pdb := NewPrefixDB(db, bz("key"))
-
-	itr := pdb.ReverseIterator(nil, bz("2"))
-	checkDomain(t, itr, nil, bz("2"))
-	checkItem(t, itr, bz("1"), bz("value1"))
-	checkNext(t, itr, true)
-	checkItem(t, itr, bz(""), bz("value"))
-	checkNext(t, itr, false)
 	checkInvalid(t, itr)
 	itr.Close()
 }
--- a/libs/db/types.go
+++ b/libs/db/types.go
@@ -34,9 +34,9 @@ type DB interface {
 	Iterator(start, end []byte) Iterator

 	// Iterate over a domain of keys in descending order. End is exclusive.
-	// Start must be less than end, or the Iterator is invalid.
-	// If start is nil, iterates up to the first/least item (inclusive).
-	// If end is nil, iterates from the last/greatest item (inclusive).
+	// Start must be greater than end, or the Iterator is invalid.
+	// If start is nil, iterates from the last/greatest item (inclusive).
+	// If end is nil, iterates up to the first/least item (inclusive).
 	// CONTRACT: No writes may happen within a domain while an iterator exists over it.
 	// CONTRACT: start, end readonly []byte
 	ReverseIterator(start, end []byte) Iterator
--- a/libs/db/util.go
+++ b/libs/db/util.go
@@ -33,13 +33,46 @@ func cpIncr(bz []byte) (ret []byte) {
 	return nil
 }

-// See DB interface documentation for more information.
-func IsKeyInDomain(key, start, end []byte) bool {
-	if bytes.Compare(key, start) < 0 {
-		return false
+// Returns a slice of the same length (big endian)
+// except decremented by one.
+// Returns nil on underflow (e.g. if bz bytes are all 0x00)
+// CONTRACT: len(bz) > 0
+func cpDecr(bz []byte) (ret []byte) {
+	if len(bz) == 0 {
+		panic("cpDecr expects non-zero bz length")
 	}
-	if end != nil && bytes.Compare(end, key) <= 0 {
-		return false
+	ret = cp(bz)
+	for i := len(bz) - 1; i >= 0; i-- {
+		if ret[i] > byte(0x00) {
+			ret[i]--
+			return
+		}
+		ret[i] = byte(0xFF)
+		if i == 0 {
+			// Underflow
+			return nil
+		}
+	}
+	return nil
+}
+
+// See DB interface documentation for more information.
+func IsKeyInDomain(key, start, end []byte, isReverse bool) bool {
+	if !isReverse {
+		if bytes.Compare(key, start) < 0 {
+			return false
+		}
+		if end != nil && bytes.Compare(end, key) <= 0 {
+			return false
+		}
+		return true
+	} else {
+		if start != nil && bytes.Compare(start, key) < 0 {
+			return false
+		}
+		if end != nil && bytes.Compare(key, end) <= 0 {
+			return false
+		}
+		return true
 	}
-	return true
 }
--- a/libs/errors/errors.go
+++ b/libs/errors/errors.go
@@ -1,21 +1,26 @@
 // Package errors contains errors that are thrown across packages.
 package errors

-// // ErrPermissionsChanged occurs if the file permission have changed since the file was created.
-// type ErrPermissionsChanged struct {
-// 	name      string
-// 	got, want os.FileMode
-// }
+import (
+	"fmt"
+	"os"
+)

-// func NewErrPermissionsChanged(name string, got, want os.FileMode) *ErrPermissionsChanged {
-// 	return &ErrPermissionsChanged{name: name, got: got, want: want}
-// }
+// ErrPermissionsChanged occurs if the file permission have changed since the file was created.
+type ErrPermissionsChanged struct {
+	name      string
+	got, want os.FileMode
+}

-// func (e ErrPermissionsChanged) Error() string {
-// 	return fmt.Sprintf(
-// 		"file: [%v]\nexpected file permissions: %v, got: %v",
-// 		e.name,
-// 		e.want,
-// 		e.got,
-// 	)
-// }
+func NewErrPermissionsChanged(name string, got, want os.FileMode) *ErrPermissionsChanged {
+	return &ErrPermissionsChanged{name: name, got: got, want: want}
+}
+
+func (e ErrPermissionsChanged) Error() string {
+	return fmt.Sprintf(
+		"file: [%v]\nexpected file permissions: %v, got: %v",
+		e.name,
+		e.want,
+		e.got,
+	)
+}
--- a/libs/fail/fail.go
+++ b/libs/fail/fail.go
@@ -1,78 +0,0 @@
-package fail
-
-import (
-	"fmt"
-	"math/rand"
-	"os"
-	"strconv"
-)
-
-var callIndexToFail int
-
-func init() {
-	callIndexToFailS := os.Getenv("FAIL_TEST_INDEX")
-
-	if callIndexToFailS == "" {
-		callIndexToFail = -1
-	} else {
-		var err error
-		callIndexToFail, err = strconv.Atoi(callIndexToFailS)
-		if err != nil {
-			callIndexToFail = -1
-		}
-	}
-}
-
-// Fail when FAIL_TEST_INDEX == callIndex
-var (
-	callIndex int //indexes Fail calls
-
-	callRandIndex       int  // indexes a run of FailRand calls
-	callRandIndexToFail = -1 // the callRandIndex to fail on in FailRand
-)
-
-func Fail() {
-	if callIndexToFail < 0 {
-		return
-	}
-
-	if callIndex == callIndexToFail {
-		Exit()
-	}
-
-	callIndex += 1
-}
-
-// FailRand should be called n successive times.
-// It will fail on a random one of those calls
-// n must be greater than 0
-func FailRand(n int) {
-	if callIndexToFail < 0 {
-		return
-	}
-
-	if callRandIndexToFail < 0 {
-		// first call in the loop, pick a random index to fail at
-		callRandIndexToFail = rand.Intn(n)
-		callRandIndex = 0
-	}
-
-	if callIndex == callIndexToFail {
-		if callRandIndex == callRandIndexToFail {
-			Exit()
-		}
-	}
-
-	callRandIndex += 1
-
-	if callRandIndex == n {
-		callIndex += 1
-	}
-}
-
-func Exit() {
-	fmt.Printf("*** fail-test %d ***\n", callIndex)
-	proc, _ := os.FindProcess(os.Getpid())
-	proc.Signal(os.Interrupt)
-	//	panic(fmt.Sprintf("*** fail-test %d ***", callIndex))
-}
--- a/libs/log/filter.go
+++ b/libs/log/filter.go
@@ -11,10 +11,9 @@ const (
 )

 type filter struct {
-	next             Logger
-	allowed          level            // XOR'd levels for default case
-	initiallyAllowed level            // XOR'd levels for initial case
-	allowedKeyvals   map[keyval]level // When key-value match, use this level
+	next           Logger
+	allowed        level            // XOR'd levels for default case
+	allowedKeyvals map[keyval]level // When key-value match, use this level
 }

 type keyval struct {
@@ -34,7 +33,6 @@ func NewFilter(next Logger, options ...Option) Logger {
 	for _, option := range options {
 		option(l)
 	}
-	l.initiallyAllowed = l.allowed
 	return l
 }

@@ -78,45 +76,14 @@ func (l *filter) Error(msg string, keyvals ...interface{}) {
 //     logger = log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("module", "crypto"), log.AllowNoneWith("user", "Sam"))
 //		 logger.With("user", "Sam").With("module", "crypto").Info("Hello") # produces "I... Hello module=crypto user=Sam"
 func (l *filter) With(keyvals ...interface{}) Logger {
-	keyInAllowedKeyvals := false
-
 	for i := len(keyvals) - 2; i >= 0; i -= 2 {
 		for kv, allowed := range l.allowedKeyvals {
-			if keyvals[i] == kv.key {
-				keyInAllowedKeyvals = true
-				// Example:
-				//		logger = log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("module", "crypto"))
-				//		logger.With("module", "crypto")
-				if keyvals[i+1] == kv.value {
-					return &filter{
-						next:             l.next.With(keyvals...),
-						allowed:          allowed, // set the desired level
-						allowedKeyvals:   l.allowedKeyvals,
-						initiallyAllowed: l.initiallyAllowed,
-					}
-				}
+			if keyvals[i] == kv.key && keyvals[i+1] == kv.value {
+				return &filter{next: l.next.With(keyvals...), allowed: allowed, allowedKeyvals: l.allowedKeyvals}
 			}
 		}
 	}
-
-	// Example:
-	//		logger = log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("module", "crypto"))
-	//		logger.With("module", "main")
-	if keyInAllowedKeyvals {
-		return &filter{
-			next:             l.next.With(keyvals...),
-			allowed:          l.initiallyAllowed, // return back to initially allowed
-			allowedKeyvals:   l.allowedKeyvals,
-			initiallyAllowed: l.initiallyAllowed,
-		}
-	}
-
-	return &filter{
-		next:             l.next.With(keyvals...),
-		allowed:          l.allowed, // simply continue with the current level
-		allowedKeyvals:   l.allowedKeyvals,
-		initiallyAllowed: l.initiallyAllowed,
-	}
+	return &filter{next: l.next.With(keyvals...), allowed: l.allowed, allowedKeyvals: l.allowedKeyvals}
 }

 //--------------------------------------------------------------------------------
--- a/libs/log/tmfmt_logger.go
+++ b/libs/log/tmfmt_logger.go
@@ -84,13 +84,13 @@ func (l tmfmtLogger) Log(keyvals ...interface{}) error {
 	// Form a custom Tendermint line
 	//
 	// Example:
-	//     D[2016-05-02|11:06:44.322]   Stopping AddrBook (ignoring: already stopped)
+	//     D[05-02|11:06:44.322] Stopping AddrBook (ignoring: already stopped)
 	//
 	// Description:
 	//     D										- first character of the level, uppercase (ASCII only)
-	//     [2016-05-02|11:06:44.322]    - our time format (see https://golang.org/src/time/format.go)
+	//     [05-02|11:06:44.322] - our time format (see https://golang.org/src/time/format.go)
 	//     Stopping ...					- message
-	enc.buf.WriteString(fmt.Sprintf("%c[%s] %-44s ", lvl[0]-32, time.Now().Format("2016-01-02|15:04:05.000"), msg))
+	enc.buf.WriteString(fmt.Sprintf("%c[%s] %-44s ", lvl[0]-32, time.Now().Format("01-02|15:04:05.000"), msg))

 	if module != unknown {
 		enc.buf.WriteString("module=" + module + " ")
--- a/libs/pubsub/pubsub.go
+++ b/libs/pubsub/pubsub.go
@@ -30,15 +30,9 @@
 //
 //     s.Subscribe(ctx, sub, qry, out)
 //     defer func() {
-//         // drain out to make sure we don't block
-//     LOOP:
-//		     for {
-// 		     	   select {
-// 		     	   case <-out:
-// 		     	   default:
-// 		     	   	   break LOOP
-// 		     	   }
-// 		     }
+//         for range out {
+//             // drain out to make sure we don't block
+//         }
 //         s.UnsubscribeAll(ctx, sub)
 //     }()
 //     for msg := range out {
--- a/lite/dbprovider.go
+++ b/lite/dbprovider.go
@@ -105,8 +105,8 @@ func (dbp *DBProvider) LatestFullCommit(chainID string, minHeight, maxHeight int
 	}

 	itr := dbp.db.ReverseIterator(
-		signedHeaderKey(chainID, minHeight),
-		append(signedHeaderKey(chainID, maxHeight), byte(0x00)),
+		signedHeaderKey(chainID, maxHeight),
+		signedHeaderKey(chainID, minHeight-1),
 	)
 	defer itr.Close()

@@ -190,8 +190,8 @@ func (dbp *DBProvider) deleteAfterN(chainID string, after int) error {
 	dbp.logger.Info("DBProvider.deleteAfterN()...", "chainID", chainID, "after", after)

 	itr := dbp.db.ReverseIterator(
-		signedHeaderKey(chainID, 1),
-		append(signedHeaderKey(chainID, 1<<63-1), byte(0x00)),
+		signedHeaderKey(chainID, 1<<63-1),
+		signedHeaderKey(chainID, 0),
 	)
 	defer itr.Close()

--- a/Show More
+++ b/Show More