playing with show validator cmd and experimenting with spawning new

sessions / connections if the connection is lost
merge develop and update changelog pending
2026-01-12 07:42:48 +00:00 · 2018-12-13 12:26:11 +01:00 · 2018-12-12 14:19:15 +01:00 · 2018-12-12 13:59:40 +01:00 · 2018-12-10 11:19:02 +01:00 · 2018-12-09 13:03:06 +01:00
308 changed files with 11816 additions and 10937 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -3,20 +3,17 @@ version: 2
 defaults: &defaults
  working_directory: /go/src/github.com/tendermint/tendermint
  docker:
-    - image: circleci/golang
+    - image: circleci/golang:1.10.3
  environment:
    GOBIN: /tmp/workspace/bin

 docs_update_config: &docs_update_config
  working_directory: ~/repo
  docker:
-    - image: tendermintdev/jq_curl
+    - image: tendermint/docs_deployment
  environment:
    AWS_REGION: us-east-1

-release_management_docker: &release_management_docker
-  machine: true
-
 jobs:
  setup_dependencies:
    <<: *defaults
@@ -51,10 +48,10 @@ jobs:
          key: v3-pkg-cache
          paths:
            - /go/pkg
-      - save_cache:
-          key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
-          paths:
-            - /go/src/github.com/tendermint/tendermint
+      # - save_cache:
+      #     key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      #     paths:
+      #       - /go/src/github.com/tendermint/tendermint

  build_slate:
    <<: *defaults
@@ -63,8 +60,23 @@ jobs:
          at: /tmp/workspace
      - restore_cache:
          key: v3-pkg-cache
-      - restore_cache:
-          key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      # https://discuss.circleci.com/t/saving-cache-stopped-working-warning-skipping-this-step-disabled-in-configuration/24423/2
+      # - restore_cache:
+      #     key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      - checkout
+      - run:
+          name: tools
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_tools
+      - run:
+          name: dependencies
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_vendor_deps
+      - run: mkdir -p $GOPATH/src/github.com/tendermint
+      - run: ln -sf /home/circleci/project $GOPATH/src/github.com/tendermint/tendermint
+
      - run:
          name: slate docs
          command: |
@@ -79,14 +91,29 @@ jobs:
          at: /tmp/workspace
      - restore_cache:
          key: v3-pkg-cache
-      - restore_cache:
-          key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      # - restore_cache:
+      #     key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      - checkout
+      - run:
+          name: tools
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_tools
+            make get_dev_tools
+      - run:
+          name: dependencies
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_vendor_deps
+      - run: mkdir -p $GOPATH/src/github.com/tendermint
+      - run: ln -sf /home/circleci/project $GOPATH/src/github.com/tendermint/tendermint
+
      - run:
          name: metalinter
          command: |
            set -ex
            export PATH="$GOBIN:$PATH"
-            make lint
+            make metalinter
      - run:
          name: check_dep
          command: |
@@ -101,8 +128,22 @@ jobs:
          at: /tmp/workspace
      - restore_cache:
          key: v3-pkg-cache
-      - restore_cache:
-          key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      # - restore_cache:
+      #     key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      - checkout
+      - run:
+          name: tools
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_tools
+      - run:
+          name: dependencies
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_vendor_deps
+      - run: mkdir -p $GOPATH/src/github.com/tendermint
+      - run: ln -sf /home/circleci/project $GOPATH/src/github.com/tendermint/tendermint
+
      - run:
          name: Run abci apps tests
          command: |
@@ -118,8 +159,22 @@ jobs:
          at: /tmp/workspace
      - restore_cache:
          key: v3-pkg-cache
-      - restore_cache:
-          key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      # - restore_cache:
+      #     key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      - checkout
+      - run:
+          name: tools
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_tools
+      - run:
+          name: dependencies
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_vendor_deps
+      - run: mkdir -p $GOPATH/src/github.com/tendermint
+      - run: ln -sf /home/circleci/project $GOPATH/src/github.com/tendermint/tendermint
+
      - run:
          name: Run abci-cli tests
          command: |
@@ -133,8 +188,22 @@ jobs:
          at: /tmp/workspace
      - restore_cache:
          key: v3-pkg-cache
-      - restore_cache:
-          key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      # - restore_cache:
+      #     key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      - checkout
+      - run:
+          name: tools
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_tools
+      - run:
+          name: dependencies
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_vendor_deps
+      - run: mkdir -p $GOPATH/src/github.com/tendermint
+      - run: ln -sf /home/circleci/project $GOPATH/src/github.com/tendermint/tendermint
+
      - run: sudo apt-get update && sudo apt-get install -y --no-install-recommends bsdmainutils
      - run:
          name: Run tests
@@ -148,8 +217,22 @@ jobs:
          at: /tmp/workspace
      - restore_cache:
          key: v3-pkg-cache
-      - restore_cache:
-          key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      # - restore_cache:
+      #     key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      - checkout
+      - run:
+          name: tools
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_tools
+      - run:
+          name: dependencies
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_vendor_deps
+      - run: mkdir -p $GOPATH/src/github.com/tendermint
+      - run: ln -sf /home/circleci/project $GOPATH/src/github.com/tendermint/tendermint
+
      - run: mkdir -p /tmp/logs
      - run:
          name: Run tests
@@ -157,7 +240,7 @@ jobs:
            for pkg in $(go list github.com/tendermint/tendermint/... | circleci tests split --split-by=timings); do
              id=$(basename "$pkg")

-              go test -v -timeout 5m -race -coverprofile=/tmp/workspace/profiles/$id.out -covermode=atomic "$pkg" | tee "/tmp/logs/$id-$RANDOM.log"
+              GOCACHE=off go test -timeout 5m -race -coverprofile=/tmp/workspace/profiles/$id.out -covermode=atomic "$pkg" | tee "/tmp/logs/$id-$RANDOM.log"
            done
      - persist_to_workspace:
          root: /tmp/workspace
@@ -173,8 +256,22 @@ jobs:
          at: /tmp/workspace
      - restore_cache:
          key: v3-pkg-cache
-      - restore_cache:
-          key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      # - restore_cache:
+      #     key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      - checkout
+      - run:
+          name: tools
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_tools
+      - run:
+          name: dependencies
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_vendor_deps
+      - run: mkdir -p $GOPATH/src/github.com/tendermint
+      - run: ln -sf /home/circleci/project $GOPATH/src/github.com/tendermint/tendermint
+
      - run:
          name: Run tests
          command: bash test/persist/test_failure_indices.sh
@@ -195,7 +292,9 @@ jobs:
            name: run localnet and exit on failure
            command: |
              set -x
-              docker run --rm -v "$PWD":/go/src/github.com/tendermint/tendermint -w /go/src/github.com/tendermint/tendermint golang make build-linux
+              make get_tools
+              make get_vendor_deps
+              make build-linux
              make localnet-start &
              ./scripts/localnet-blocks-test.sh 40 5 10 localhost

@@ -218,10 +317,22 @@ jobs:
    steps:
      - attach_workspace:
          at: /tmp/workspace
-      - restore_cache:
-          key: v3-pkg-cache
-      - restore_cache:
-          key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      # - restore_cache:
+      #     key: v3-tree-{{ .Environment.CIRCLE_SHA1 }}
+      - checkout
+      - run:
+          name: tools
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_tools
+      - run:
+          name: dependencies
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_vendor_deps
+      - run: mkdir -p $GOPATH/src/github.com/tendermint
+      - run: ln -sf /home/circleci/project $GOPATH/src/github.com/tendermint/tendermint
+
      - run:
          name: gather
          command: |
@@ -242,121 +353,7 @@ jobs:
      - run:
          name: Trigger website build
          command: |
-            curl --silent \
-                 --show-error \
-                 -X POST \
-                 --header "Content-Type: application/json" \
-                 -d "{\"branch\": \"$CIRCLE_BRANCH\"}" \
-                 "https://circleci.com/api/v1.1/project/github/$CIRCLE_PROJECT_USERNAME/$WEBSITE_REPO_NAME/build?circle-token=$TENDERBOT_API_TOKEN" > response.json
-
-            RESULT=`jq -r '.status' response.json`
-            MESSAGE=`jq -r '.message' response.json`
-
-            if [[ ${RESULT} == "null" ]] || [[ ${RESULT} -ne "200" ]]; then
-                echo "CircleCI API call failed: $MESSAGE"
-                exit 1
-            else
-                echo "Website build started"
-            fi
-
-  prepare_build:
-    <<: *defaults
-    steps:
-      - checkout
-      - run:
-          name: Get next release number
-          command: |
-            export LAST_TAG="`git describe --tags --abbrev=0 --match "${CIRCLE_BRANCH}.*"`"
-            echo "Last tag: ${LAST_TAG}"
-            if [ -z "${LAST_TAG}" ]; then
-              export LAST_TAG="${CIRCLE_BRANCH}"
-              echo "Last tag not found. Possibly fresh branch or feature branch. Setting ${LAST_TAG} as tag."
-            fi
-            export NEXT_TAG="`python -u scripts/release_management/bump-semver.py --version "${LAST_TAG}"`"
-            echo "Next tag: ${NEXT_TAG}"
-            echo "export CIRCLE_TAG=\"${NEXT_TAG}\"" > release-version.source
-      - run:
-          name: Build dependencies
-          command: |
-            make get_tools get_vendor_deps
-      - persist_to_workspace:
-          root: .
-          paths:
-            - "release-version.source"
-      - save_cache:
-          key: v1-release-deps-{{ .Branch }}-{{ .Revision }}
-          paths:
-            - "vendor"
-
-  build_artifacts:
-    <<: *defaults
-    parallelism: 4
-    steps:
-      - checkout
-      - restore_cache:
-          keys:
-            - v1-release-deps-{{ .Branch }}-{{ .Revision }}
-      - attach_workspace:
-          at: /tmp/workspace
-      - run:
-          name: Build artifact
-          command: |
-            # Setting CIRCLE_TAG because we do not tag the release ourselves.
-            source /tmp/workspace/release-version.source
-            if test ${CIRCLE_NODE_INDEX:-0} == 0 ;then export GOOS=linux GOARCH=amd64   && export OUTPUT=build/tendermint_${GOOS}_${GOARCH} && make build && python -u scripts/release_management/zip-file.py ;fi
-            if test ${CIRCLE_NODE_INDEX:-0} == 1 ;then export GOOS=darwin GOARCH=amd64  && export OUTPUT=build/tendermint_${GOOS}_${GOARCH} && make build && python -u scripts/release_management/zip-file.py ;fi
-            if test ${CIRCLE_NODE_INDEX:-0} == 2 ;then export GOOS=windows GOARCH=amd64 && export OUTPUT=build/tendermint_${GOOS}_${GOARCH} && make build && python -u scripts/release_management/zip-file.py ;fi
-            if test ${CIRCLE_NODE_INDEX:-0} == 3 ;then export GOOS=linux GOARCH=arm     && export OUTPUT=build/tendermint_${GOOS}_${GOARCH} && make build && python -u scripts/release_management/zip-file.py ;fi
-      - persist_to_workspace:
-          root: build
-          paths:
-            - "*.zip"
-            - "tendermint_linux_amd64"
-
-  release_artifacts:
-    <<: *defaults
-    steps:
-      - checkout
-      - attach_workspace:
-          at: /tmp/workspace
-      - run:
-          name: Deploy to GitHub
-          command: |
-            # Setting CIRCLE_TAG because we do not tag the release ourselves.
-            source /tmp/workspace/release-version.source
-            echo "---"
-            ls -la /tmp/workspace/*.zip
-            echo "---"
-            python -u scripts/release_management/sha-files.py
-            echo "---"
-            cat /tmp/workspace/SHA256SUMS
-            echo "---"
-            export RELEASE_ID="`python -u scripts/release_management/github-draft.py`"
-            echo "Release ID: ${RELEASE_ID}"
-            #Todo: Parallelize uploads
-            export GOOS=linux GOARCH=amd64   && python -u scripts/release_management/github-upload.py --id "${RELEASE_ID}"
-            export GOOS=darwin GOARCH=amd64  && python -u scripts/release_management/github-upload.py --id "${RELEASE_ID}"
-            export GOOS=windows GOARCH=amd64 && python -u scripts/release_management/github-upload.py --id "${RELEASE_ID}"
-            export GOOS=linux GOARCH=arm     && python -u scripts/release_management/github-upload.py --id "${RELEASE_ID}"
-            python -u scripts/release_management/github-upload.py --file "/tmp/workspace/SHA256SUMS" --id "${RELEASE_ID}"
-            python -u scripts/release_management/github-publish.py --id "${RELEASE_ID}"
-
-  release_docker:
-    <<: *release_management_docker
-    steps:
-      - checkout
-      - attach_workspace:
-          at: /tmp/workspace
-      - run:
-          name: Deploy to Docker Hub
-          command: |
-            # Setting CIRCLE_TAG because we do not tag the release ourselves.
-            source /tmp/workspace/release-version.source
-            cp /tmp/workspace/tendermint_linux_amd64 DOCKER/tendermint
-            docker build --label="tendermint" --tag="tendermint/tendermint:${CIRCLE_TAG}" --tag="tendermint/tendermint:latest" "DOCKER"
-            docker login -u "${DOCKERHUB_USER}" --password-stdin <<< "${DOCKERHUB_PASS}"
-            docker push "tendermint/tendermint"
-            docker logout
+            chamber exec tendermint -- start_website_build

 workflows:
  version: 2
@@ -394,25 +391,3 @@ workflows:
      - upload_coverage:
          requires:
            - test_cover
-  release:
-    jobs:
-      - prepare_build
-      - build_artifacts:
-          requires:
-            - prepare_build
-      - release_artifacts:
-          requires:
-            - prepare_build
-            - build_artifacts
-          filters:
-            branches:
-              only:
-                - /v[0-9]+\.[0-9]+/
-      - release_docker:
-          requires:
-            - prepare_build
-            - build_artifacts
-          filters:
-            branches:
-              only:
-                - /v[0-9]+\.[0-9]+/
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -4,6 +4,4 @@
 *       @ebuchman @melekes @xla

 # Precious documentation
-/docs/README.md  @zramsay
-/docs/DOCS_README.md  @zramsay
-/docs/.vuepress/  @zramsay
+/docs/  @zramsay
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,59 +0,0 @@
-run:
-  deadline: 1m
-
-linters:
-  enable-all: true
-  disable:
-    - gocyclo
-    - golint
-    - maligned
-    - errcheck
-    - staticcheck
-    - dupl
-    - ineffassign
-    - interfacer
-    - unconvert
-    - goconst
-    - unparam
-    - nakedret
-    - lll
-    - gochecknoglobals
-    - gocritic
-    - gochecknoinits
-    - scopelint
-    - stylecheck
-
-# linters-settings:
-#   govet:
-#     check-shadowing: true
-#   golint:
-#     min-confidence: 0
-#   gocyclo:
-#     min-complexity: 10
-#   maligned:
-#     suggest-new: true
-#   dupl:
-#     threshold: 100
-#   goconst:
-#     min-len: 2
-#     min-occurrences: 2
-#   depguard:
-#     list-type: blacklist
-#     packages:
-#       # logging is allowed only by logutils.Log, logrus
-#       # is allowed to use only in logutils package
-#       - github.com/sirupsen/logrus
-#   misspell:
-#     locale: US
-#   lll:
-#     line-length: 140
-#   goimports:
-#     local-prefixes: github.com/golangci/golangci-lint
-#   gocritic:
-#     enabled-tags:
-#       - performance
-#       - style
-#       - experimental
-#     disabled-checks:
-#       - wrapperFunc
-#       - commentFormatting # https://github.com/go-critic/go-critic/issues/755
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,399 +1,5 @@
 # Changelog

-## v0.30.4
-
-*April 16th, 2019*
-
-This release fixes a regression from v0.30.3 which used the peer's SocketAddr to add the peer to the address book. 
-This swallowed the peer's self-reported port which is important in case of reconnect. 
-It brings back NetAddress() to NodeInfo and uses it instead of SocketAddr for adding peers. 
-
-### BUG FIXES:
-
- [p2p] [\#3545](https://github.com/tendermint/tendermint/issues/3545) Add back `NetAddress()` to `NodeInfo` and use it 
-instead of peer's `SocketAddr()` when adding a peer to the `PEXReactor` (potential fix for [\#3532](https://github.com/tendermint/tendermint/issues/3532))
-
-## v0.30.3
-
-*April 1st, 2019*
-
-This release includes two security sensitive fixes: it ensures generated private
-keys are valid, and it prevents certain DNS lookups that would cause the node to
-panic if the lookup failed.
-
-### BUG FIXES:
-
- [crypto/secp256k1] [\#3439](https://github.com/tendermint/tendermint/issues/3439)
-    Ensure generated private keys are valid by randomly sampling until a valid key is found.
-    Previously, it was possible (though rare!) to generate keys that exceeded the curve order.
-    Such keys would lead to invalid signatures.
- [p2p] [\#3522](https://github.com/tendermint/tendermint/issues/3522) Memoize
-  socket address in peer connections to avoid DNS lookups. Previously, failed
-  DNS lookups could cause the node to panic.
-
-### IMPROVEMENTS:
-
- [circle] [\#3497](https://github.com/tendermint/tendermint/issues/3497) Move release management to CircleCI
-
-## v0.30.2
-
-*March 10th, 2019*
-
-This release fixes a CLevelDB memory leak. It was happening because we were not
-closing the WriteBatch object after use. See [levigo's
-godoc](https://godoc.org/github.com/jmhodges/levigo#WriteBatch.Close) for the
-Close method. Special thanks goes to @Stumble who both reported an issue in
-[cosmos-sdk](https://github.com/cosmos/cosmos-sdk/issues/3842) and provided a
-fix here.
-
-### BREAKING CHANGES:
-
-* Go API
-  - [libs/db] [\#3842](https://github.com/cosmos/cosmos-sdk/issues/3842) Add Close() method to Batch interface (@Stumble)
-
-### BUG FIXES:
- [libs/db] [\#3842](https://github.com/cosmos/cosmos-sdk/issues/3842) Fix CLevelDB memory leak (@Stumble)
-
-## v0.30.1
-
-*February 20th, 2019*
-
-This release fixes a consensus halt and a DataCorruptionError after restart
-discovered in `game_of_stakes_6`. It also fixes a security issue in the p2p
-handshake by authenticating the NetAddress.ID of the peer we're dialing.
-
-### IMPROVEMENTS:
-
-* [config] [\#3291](https://github.com/tendermint/tendermint/issues/3291) Make
-  config.ResetTestRootWithChainID() create concurrency-safe test directories.
-
-### BUG FIXES:
-
-* [consensus] [\#3295](https://github.com/tendermint/tendermint/issues/3295)
-  Flush WAL on stop to prevent data corruption during graceful shutdown.
-* [consensus] [\#3302](https://github.com/tendermint/tendermint/issues/3302)
-  Fix possible halt by resetting TriggeredTimeoutPrecommit before starting next height.
-* [rpc] [\#3251](https://github.com/tendermint/tendermint/issues/3251) Fix
-  `/net_info#peers#remote_ip` format. New format spec:
-  * dotted decimal ("192.0.2.1"), if ip is an IPv4 or IP4-mapped IPv6 address
-  * IPv6 ("2001:db8::1"), if ip is a valid IPv6 address
-* [cmd] [\#3314](https://github.com/tendermint/tendermint/issues/3314) Return
-  an error on `show_validator` when the private validator file does not exist.
-* [p2p] [\#3010](https://github.com/tendermint/tendermint/issues/3010#issuecomment-464287627)
-  Authenticate a peer against its NetAddress.ID when dialing.
-
-## v0.30.0
-
-*February 8th, 2019*
-
-This release fixes yet another issue with the proposer selection algorithm.
-We hope it's the last one, but we won't be surprised if it's not.
-We plan to one day expose the selection algorithm more directly to
-the application ([\#3285](https://github.com/tendermint/tendermint/issues/3285)), and even to support randomness ([\#763](https://github.com/tendermint/tendermint/issues/763)).
-For more, see issues marked
-[proposer-selection](https://github.com/tendermint/tendermint/labels/proposer-selection).
-
-This release also includes a fix to prevent Tendermint from including the same
-piece of evidence in more than one block. This issue was reported by @chengwenxi in our
-[bug bounty program](https://hackerone.com/tendermint).
-
-### BREAKING CHANGES:
-
-* Apps
-  - [state] [\#3222](https://github.com/tendermint/tendermint/issues/3222)
-    Duplicate updates for the same validator are forbidden. Apps must ensure
-    that a given `ResponseEndBlock.ValidatorUpdates` contains only one entry per pubkey.
-
-* Go API
-  - [types] [\#3222](https://github.com/tendermint/tendermint/issues/3222)
-    Remove `Add` and `Update` methods from `ValidatorSet` in favor of new
-    `UpdateWithChangeSet`. This allows updates to be applied as a set, instead of
-    one at a time.
-
-* Block Protocol
-  - [state] [\#3286](https://github.com/tendermint/tendermint/issues/3286) Blocks that include already committed evidence are invalid.
-
-* P2P Protocol
-  - [consensus] [\#3222](https://github.com/tendermint/tendermint/issues/3222)
-    Validator updates are applied as a set, instead of one at a time, thus
-    impacting the proposer priority calculation. This ensures that the proposer
-    selection algorithm does not depend on the order of updates in
-    `ResponseEndBlock.ValidatorUpdates`.
-
-### IMPROVEMENTS:
- [crypto] [\#3279](https://github.com/tendermint/tendermint/issues/3279) Use `btcec.S256().N` directly instead of hard coding a copy.
-
-### BUG FIXES:
- [state] [\#3222](https://github.com/tendermint/tendermint/issues/3222) Fix validator set updates so they are applied as a set, rather
-  than one at a time. This makes the proposer selection algorithm independent of
-  the order of updates in `ResponseEndBlock.ValidatorUpdates`.
- [evidence] [\#3286](https://github.com/tendermint/tendermint/issues/3286) Don't add committed evidence to evidence pool.
-
-## v0.29.2
-
-*February 7th, 2019*
-
-Special thanks to external contributors on this release:
-@ackratos, @rickyyangz
-
-**Note**: This release contains security sensitive patches in the `p2p` and
-`crypto` packages:
- p2p:
-  - Partial fix for MITM attacks on the p2p connection. MITM conditions may
-    still exist. See [\#3010](https://github.com/tendermint/tendermint/issues/3010).
- crypto:
-  - Eliminate our fork of `btcd` and use the `btcd/btcec` library directly for
-    native secp256k1 signing. Note we still modify the signature encoding to
-    prevent malleability.
-  - Support the libsecp256k1 library via CGo through the `go-ethereum/crypto/secp256k1` package.
-  - Eliminate MixEntropy functions
-
-### BREAKING CHANGES:
-
-* Go API
-  - [crypto] [\#3278](https://github.com/tendermint/tendermint/issues/3278) Remove
-    MixEntropy functions
-  - [types] [\#3245](https://github.com/tendermint/tendermint/issues/3245) Commit uses `type CommitSig Vote` instead of `Vote` directly.
-    In preparation for removing redundant fields from the commit [\#1648](https://github.com/tendermint/tendermint/issues/1648)
-
-### IMPROVEMENTS:
- [consensus] [\#3246](https://github.com/tendermint/tendermint/issues/3246) Better logging and notes on recovery for corrupted WAL file
- [crypto] [\#3163](https://github.com/tendermint/tendermint/issues/3163) Use ethereum's libsecp256k1 go-wrapper for signatures when cgo is available
- [crypto] [\#3162](https://github.com/tendermint/tendermint/issues/3162) Wrap btcd instead of forking it to keep up with fixes (used if cgo is not available)
- [makefile] [\#3233](https://github.com/tendermint/tendermint/issues/3233) Use golangci-lint instead of go-metalinter
- [tools] [\#3218](https://github.com/tendermint/tendermint/issues/3218) Add go-deadlock tool to help detect deadlocks
- [tools] [\#3106](https://github.com/tendermint/tendermint/issues/3106) Add tm-signer-harness test harness for remote signers
- [tests] [\#3258](https://github.com/tendermint/tendermint/issues/3258) Fixed a bunch of non-deterministic test failures
-
-### BUG FIXES:
- [node] [\#3186](https://github.com/tendermint/tendermint/issues/3186) EventBus and indexerService should be started before first block (for replay last block on handshake) execution (@ackratos)
- [p2p] [\#3232](https://github.com/tendermint/tendermint/issues/3232) Fix infinite loop leading to addrbook deadlock for seed nodes
- [p2p] [\#3247](https://github.com/tendermint/tendermint/issues/3247) Fix panic in SeedMode when calling FlushStop and OnStop
-  concurrently
- [p2p] [\#3040](https://github.com/tendermint/tendermint/issues/3040) Fix MITM on secret connection by checking low-order points
- [privval] [\#3258](https://github.com/tendermint/tendermint/issues/3258) Fix race between sign requests and ping requests in socket that was causing messages to be corrupted
-
-## v0.29.1
-
-*January 24, 2019*
-
-Special thanks to external contributors on this release:
-@infinytum, @gauthamzz
-
-This release contains two important fixes: one for p2p layer where we sometimes
-were not closing connections and one for consensus layer where consensus with
-no empty blocks (`create_empty_blocks = false`) could halt.
-
-Friendly reminder, we have a [bug bounty
-program](https://hackerone.com/tendermint).
-
-### IMPROVEMENTS:
- [pex] [\#3037](https://github.com/tendermint/tendermint/issues/3037) Only log "Reached max attempts to dial" once
- [rpc] [\#3159](https://github.com/tendermint/tendermint/issues/3159) Expose
-  `triggered_timeout_commit` in the `/dump_consensus_state`
-
-### BUG FIXES:
- [consensus] [\#3199](https://github.com/tendermint/tendermint/issues/3199) Fix consensus halt with no empty blocks from not resetting triggeredTimeoutCommit
- [p2p] [\#2967](https://github.com/tendermint/tendermint/issues/2967) Fix file descriptor leak
-
-## v0.29.0
-
-*January 21, 2019*
-
-Special thanks to external contributors on this release:
-@bradyjoestar, @kunaldhariwal, @gauthamzz, @hrharder
-
-This release is primarily about making some breaking changes to
-the Block protocol version before Cosmos launch, and to fixing more issues
-in the proposer selection algorithm discovered on Cosmos testnets.
-
-The Block protocol changes include using a standard Merkle tree format (RFC 6962),
-fixing some inconsistencies between field orders in Vote and Proposal structs,
-and constraining the hash of the ConsensusParams to include only a few fields.
-
-The proposer selection algorithm saw significant progress,
-including a [formal proof by @cwgoes for the base-case in Idris](https://github.com/cwgoes/tm-proposer-idris)
-and a [much more detailed specification (still in progress) by
-@ancazamfir](https://github.com/tendermint/tendermint/pull/3140).
-
-Fixes to the proposer selection algorithm include normalizing the proposer
-priorities to mitigate the effects of large changes to the validator set.
-That said, we just discovered [another bug](https://github.com/tendermint/tendermint/issues/3181),
-which will be fixed in the next breaking release.
-
-While we are trying to stabilize the Block protocol to preserve compatibility
-with old chains, there may be some final changes yet to come before Cosmos
-launch as we continue to audit and test the software.
-
-Friendly reminder, we have a [bug bounty
-program](https://hackerone.com/tendermint).
-
-### BREAKING CHANGES:
-
-* CLI/RPC/Config
-
-* Apps
-  - [state] [\#3049](https://github.com/tendermint/tendermint/issues/3049) Total voting power of the validator set is upper bounded by
-    `MaxInt64 / 8`. Apps must ensure they do not return changes to the validator
-    set that cause this maximum to be exceeded.
-
-* Go API
-  - [node] [\#3082](https://github.com/tendermint/tendermint/issues/3082) MetricsProvider now requires you to pass a chain ID
-  - [types] [\#2713](https://github.com/tendermint/tendermint/issues/2713) Rename `TxProof.LeafHash` to `TxProof.Leaf`
-  - [crypto/merkle] [\#2713](https://github.com/tendermint/tendermint/issues/2713) `SimpleProof.Verify` takes a `leaf` instead of a
-    `leafHash` and performs the hashing itself
-
-* Blockchain Protocol
-  * [crypto/merkle] [\#2713](https://github.com/tendermint/tendermint/issues/2713) Merkle trees now match the RFC 6962 specification
-  * [types] [\#3078](https://github.com/tendermint/tendermint/issues/3078) Re-order Timestamp and BlockID in CanonicalVote so it's
-    consistent with CanonicalProposal (BlockID comes
-    first)
-  * [types] [\#3165](https://github.com/tendermint/tendermint/issues/3165) Hash of ConsensusParams only includes BlockSize.MaxBytes and
-    BlockSize.MaxGas
-
-* P2P Protocol
-  - [consensus] [\#3049](https://github.com/tendermint/tendermint/issues/3049) Normalize priorities to not exceed `2*TotalVotingPower` to mitigate unfair proposer selection
-    heavily preferring earlier joined validators in the case of an early bonded large validator unbonding
-
-### FEATURES:
-
-### IMPROVEMENTS:
- [rpc] [\#3065](https://github.com/tendermint/tendermint/issues/3065) Return maxPerPage (100), not defaultPerPage (30) if `per_page` is greater than the max 100.
- [instrumentation] [\#3082](https://github.com/tendermint/tendermint/issues/3082) Add `chain_id` label for all metrics
-
-### BUG FIXES:
- [crypto] [\#3164](https://github.com/tendermint/tendermint/issues/3164) Update `btcd` fork for rare signRFC6979 bug
- [lite] [\#3171](https://github.com/tendermint/tendermint/issues/3171) Fix verifying large validator set changes
- [log] [\#3125](https://github.com/tendermint/tendermint/issues/3125) Fix year format
- [mempool] [\#3168](https://github.com/tendermint/tendermint/issues/3168) Limit tx size to fit in the max reactor msg size
- [scripts] [\#3147](https://github.com/tendermint/tendermint/issues/3147) Fix json2wal for large block parts (@bradyjoestar)
-
-## v0.28.1
-
-*January 18th, 2019*
-
-Special thanks to external contributors on this release:
-@HaoyangLiu
-
-Friendly reminder, we have a [bug bounty
-program](https://hackerone.com/tendermint).
-
-### BUG FIXES:
- [consensus] Fix consensus halt from proposing blocks with too much evidence
-
-## v0.28.0
-
-*January 16th, 2019*
-
-Special thanks to external contributors on this release:
-@fmauricios, @gianfelipe93, @husio, @needkane, @srmo, @yutianwu
-
-This release is primarily about upgrades to the `privval` system -
-separating the `priv_validator.json` into distinct config and data files, and
-refactoring the socket validator to support reconnections.
-
-**Note:** Please backup your existing `priv_validator.json` before using this
-version.
-
-See [UPGRADING.md](UPGRADING.md) for more details.
-
-### BREAKING CHANGES:
-
-* CLI/RPC/Config
-  - [cli] Removed `--proxy_app=dummy` option. Use `kvstore` (`persistent_kvstore`) instead.
-  - [cli] Renamed `--proxy_app=nilapp` to `--proxy_app=noop`.
-  - [config] [\#2992](https://github.com/tendermint/tendermint/issues/2992) `allow_duplicate_ip` is now set to false
-  - [privval] [\#1181](https://github.com/tendermint/tendermint/issues/1181) Split `priv_validator.json` into immutable (`config/priv_validator_key.json`) and mutable (`data/priv_validator_state.json`) parts (@yutianwu)
-  - [privval] [\#2926](https://github.com/tendermint/tendermint/issues/2926) Split up `PubKeyMsg` into `PubKeyRequest` and `PubKeyResponse` to be consistent with other message types
-  - [privval] [\#2923](https://github.com/tendermint/tendermint/issues/2923) Listen for unix socket connections instead of dialing them
-
-* Apps
-
-* Go API
-  - [types] [\#2981](https://github.com/tendermint/tendermint/issues/2981) Remove `PrivValidator.GetAddress()`
-
-* Blockchain Protocol
-
-* P2P Protocol
-
-### FEATURES:
- [rpc] [\#3052](https://github.com/tendermint/tendermint/issues/3052) Include peer's remote IP in `/net_info`
-
-### IMPROVEMENTS:
- [consensus] [\#3086](https://github.com/tendermint/tendermint/issues/3086) Log peerID on ignored votes (@srmo)
- [docs] [\#3061](https://github.com/tendermint/tendermint/issues/3061) Added specification for signing consensus msgs at
-  ./docs/spec/consensus/signing.md
- [privval] [\#2948](https://github.com/tendermint/tendermint/issues/2948) Memoize pubkey so it's only requested once on startup
- [privval] [\#2923](https://github.com/tendermint/tendermint/issues/2923) Retry RemoteSigner connections on error
-
-### BUG FIXES:
-
- [build] [\#3085](https://github.com/tendermint/tendermint/issues/3085) Fix `Version` field in build scripts (@husio)
- [crypto/multisig] [\#3102](https://github.com/tendermint/tendermint/issues/3102) Fix multisig keys address length
- [crypto/encoding] [\#3101](https://github.com/tendermint/tendermint/issues/3101) Fix `PubKeyMultisigThreshold` unmarshalling into `crypto.PubKey` interface
- [p2p/conn] [\#3111](https://github.com/tendermint/tendermint/issues/3111) Make SecretConnection thread safe
- [rpc] [\#3053](https://github.com/tendermint/tendermint/issues/3053) Fix internal error in `/tx_search` when results are empty
-  (@gianfelipe93)
- [types] [\#2926](https://github.com/tendermint/tendermint/issues/2926) Do not panic if retrieving the privval's public key fails
-
-## v0.27.4
-
-*December 21st, 2018*
-
-### BUG FIXES:
-
- [mempool] [\#3036](https://github.com/tendermint/tendermint/issues/3036) Fix
-  LRU cache by popping the least recently used item when the cache is full,
-  not the most recently used one!
-
-## v0.27.3
-
-*December 16th, 2018*
-
-### BREAKING CHANGES:
-
-* Go API
-  - [dep] [\#3027](https://github.com/tendermint/tendermint/issues/3027) Revert to mainline Go crypto library, eliminating the modified
-    `bcrypt.GenerateFromPassword`
-
-## v0.27.2
-
-*December 16th, 2018*
-
-### IMPROVEMENTS:
-
- [node] [\#3025](https://github.com/tendermint/tendermint/issues/3025) Validate NodeInfo addresses on startup.
-
-### BUG FIXES:
-
- [p2p] [\#3025](https://github.com/tendermint/tendermint/pull/3025) Revert to using defers in addrbook.  Fixes deadlocks in pex and consensus upon invalid ExternalAddr/ListenAddr configuration.
-
-## v0.27.1
-
-*December 15th, 2018*
-
-Special thanks to external contributors on this release:
-@danil-lashin, @hleb-albau, @james-ray, @leo-xinwang
-
-### FEATURES:
- [rpc] [\#2964](https://github.com/tendermint/tendermint/issues/2964) Add `UnconfirmedTxs(limit)` and `NumUnconfirmedTxs()` methods to HTTP/Local clients (@danil-lashin)
- [docs] [\#3004](https://github.com/tendermint/tendermint/issues/3004) Enable full-text search on docs pages
-
-### IMPROVEMENTS:
- [consensus] [\#2971](https://github.com/tendermint/tendermint/issues/2971) Return error if ValidatorSet is empty after InitChain
-  (@leo-xinwang)
- [ci/cd] [\#3005](https://github.com/tendermint/tendermint/issues/3005) Updated CircleCI job to trigger website build when docs are updated
- [docs] Various updates
-
-### BUG FIXES:
- [cmd] [\#2983](https://github.com/tendermint/tendermint/issues/2983) `testnet` command always sets `addr_book_strict = false`
- [config] [\#2980](https://github.com/tendermint/tendermint/issues/2980) Fix CORS options formatting
- [kv indexer] [\#2912](https://github.com/tendermint/tendermint/issues/2912) Don't ignore key when executing CONTAINS
- [mempool] [\#2961](https://github.com/tendermint/tendermint/issues/2961) Call `notifyTxsAvailable` if there're txs left after committing a block, but recheck=false
- [mempool] [\#2994](https://github.com/tendermint/tendermint/issues/2994) Reject txs with negative GasWanted
- [p2p] [\#2990](https://github.com/tendermint/tendermint/issues/2990) Fix a bug where seeds don't disconnect from a peer after 3h
- [consensus] [\#3006](https://github.com/tendermint/tendermint/issues/3006) Save state after InitChain only when stateHeight is also 0 (@james-ray)
-
 ## v0.27.0

 *December 5th, 2018*
@@ -440,17 +46,17 @@ message.
 ### IMPROVEMENTS:

 - [state] [\#2929](https://github.com/tendermint/tendermint/issues/2929) Minor refactor of updateState logic (@danil-lashin)
- [node] [\#2959](https://github.com/tendermint/tendermint/issues/2959) Allow node to start even if software's BlockProtocol is
+- [node] \#2959 Allow node to start even if software's BlockProtocol is
  different from state's BlockProtocol
- [pex] [\#2959](https://github.com/tendermint/tendermint/issues/2959) Pex reactor logger uses `module=pex`
+- [pex] \#2959 Pex reactor logger uses `module=pex`

 ### BUG FIXES:

- [p2p] [\#2968](https://github.com/tendermint/tendermint/issues/2968) Panic on transport error rather than continuing to run but not
+- [p2p] \#2968 Panic on transport error rather than continuing to run but not
  accept new connections
- [p2p] [\#2969](https://github.com/tendermint/tendermint/issues/2969) Fix mismatch in peer count between `/net_info` and the prometheus
+- [p2p] \#2969 Fix mismatch in peer count between `/net_info` and the prometheus
  metrics
- [rpc] [\#2408](https://github.com/tendermint/tendermint/issues/2408) `/broadcast_tx_commit`: Fix "interface conversion: interface {} in nil, not EventDataTx" panic (could happen if somebody sent a tx using `/broadcast_tx_commit` while Tendermint was being stopped)
+- [rpc] \#2408 `/broadcast_tx_commit`: Fix "interface conversion: interface {} in nil, not EventDataTx" panic (could happen if somebody sent a tx using `/broadcast_tx_commit` while Tendermint was being stopped)
 - [state] [\#2785](https://github.com/tendermint/tendermint/issues/2785) Fix accum for new validators to be `-1.125*totalVotingPower`
  instead of 0, forcing them to wait before becoming the proposer. Also:
    - do not batch clip
--- a/CHANGELOG_PENDING.md
+++ b/CHANGELOG_PENDING.md
@@ -1,6 +1,6 @@
-## v0.31.0
+## v0.27.1

-**
+*TBD*

 Special thanks to external contributors on this release:

@@ -8,9 +8,14 @@ Special thanks to external contributors on this release:

 * CLI/RPC/Config

+- [privval] \#2926 split up `PubKeyMsg` into `PubKeyRequest` and `PubKeyResponse` to be consistent with other message types
+
 * Apps

-* Go API
+* Go API  
+- [types] \#2926 memoize consensus public key on initialization of remote signer and return the memoized key on 
+`PrivValidator.GetPubKey()` instead of requesting it again 
+- [types] \#2981 Remove `PrivValidator.GetAddress()`

 * Blockchain Protocol

@@ -19,5 +24,11 @@ Special thanks to external contributors on this release:
 ### FEATURES:

 ### IMPROVEMENTS:
+- [rpc] Add `UnconfirmedTxs(limit)` and `NumUnconfirmedTxs()` methods to HTTP/Local clients (@danil-lashin)
+- [ci/cd] Updated CircleCI job to trigger website build when docs are updated

 ### BUG FIXES:
+- [kv indexer] \#2912 don't ignore key when executing CONTAINS
+- [types] \#2926 do not panic if retrieving the private validator's public key fails
+- [mempool] \#2994 Don't allow txs with negative gas wanted
+- [p2p] \#2715 fix a bug where seeds don't disconnect from a peer after 3h
--- a/DOCKER/Dockerfile
+++ b/DOCKER/Dockerfile
@@ -1,5 +1,5 @@
-FROM alpine:3.9
-LABEL maintainer="hello@tendermint.com"
+FROM alpine:3.7
+MAINTAINER Greg Szabo <greg@tendermint.com>

 # Tendermint will be looking for the genesis file in /tendermint/config/genesis.json
 # (unless you change `genesis_file` in config.toml). You can put your config.toml and
--- a/DOCKER/build.sh
+++ b/DOCKER/build.sh
@@ -3,7 +3,7 @@ set -e

 # Get the tag from the version, or try to figure it out.
 if [ -z "$TAG" ]; then
-	TAG=$(awk -F\" '/TMCoreSemVer =/ { print $2; exit }' < ../version/version.go)
+	TAG=$(awk -F\" '/Version =/ { print $2; exit }' < ../version/version.go)
 fi
 if [ -z "$TAG" ]; then
 		echo "Please specify a tag."
--- a/DOCKER/push.sh
+++ b/DOCKER/push.sh
@@ -3,7 +3,7 @@ set -e

 # Get the tag from the version, or try to figure it out.
 if [ -z "$TAG" ]; then
-	TAG=$(awk -F\" '/TMCoreSemVer =/ { print $2; exit }' < ../version/version.go)
+	TAG=$(awk -F\" '/Version =/ { print $2; exit }' < ../version/version.go)
 fi
 if [ -z "$TAG" ]; then
 		echo "Please specify a tag."
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -10,11 +10,12 @@
  revision = "3a771d992973f24aa725d07868b467d1ddfceafb"

 [[projects]]
-  digest = "1:093bf93a65962e8191e3e8cd8fc6c363f83d43caca9739c906531ba7210a9904"
+  branch = "master"
+  digest = "1:c0decf632843204d2b8781de7b26e7038584e2dcccc7e2f401e88ae85b1df2b7"
  name = "github.com/btcsuite/btcd"
  packages = ["btcec"]
  pruneopts = "UT"
-  revision = "ed77733ec07dfc8a513741138419b8d9d3de9d2d"
+  revision = "67e573d211ace594f1366b4ce9d39726c4b19bd0"

 [[projects]]
  digest = "1:1d8e1cb71c33a9470bbbae09bfec09db43c6bf358dfcae13cd8807c4e2a9a2bf"
@@ -34,14 +35,6 @@
  revision = "8991bc29aa16c548c550c7ff78260e27b9ab7c73"
  version = "v1.1.1"

-[[projects]]
-  digest = "1:b42be5a3601f833e0b9f2d6625d887ec1309764bfcac3d518f3db425dcd4ec5c"
-  name = "github.com/ethereum/go-ethereum"
-  packages = ["crypto/secp256k1"]
-  pruneopts = "T"
-  revision = "9dc5d1a915ac0e0bd8429d6ac41df50eec91de5f"
-  version = "v1.8.21"
-
 [[projects]]
  digest = "1:544229a3ca0fb2dd5ebc2896d3d2ff7ce096d9751635301e44e37e761349ee70"
  name = "github.com/fortytw2/leaktest"
@@ -367,6 +360,13 @@
  pruneopts = "UT"
  revision = "6b91fda63f2e36186f1c9d0e48578defb69c5d43"

+[[projects]]
+  digest = "1:605b6546f3f43745695298ec2d342d3e952b6d91cdf9f349bea9315f677d759f"
+  name = "github.com/tendermint/btcd"
+  packages = ["btcec"]
+  pruneopts = "UT"
+  revision = "e5840949ff4fff0c56f9b6a541e22b63581ea9df"
+
 [[projects]]
  digest = "1:ad9c4c1a4e7875330b1f62906f2830f043a23edb5db997e3a5ac5d3e6eadf80a"
  name = "github.com/tendermint/go-amino"
@@ -376,7 +376,7 @@
  version = "v0.14.1"

 [[projects]]
-  digest = "1:00d2b3e64cdc3fa69aa250dfbe4cc38c4837d4f37e62279be2ae52107ffbbb44"
+  digest = "1:72b71e3a29775e5752ed7a8012052a3dee165e27ec18cedddae5288058f09acf"
  name = "golang.org/x/crypto"
  packages = [
    "bcrypt",
@@ -397,7 +397,8 @@
    "salsa20/salsa",
  ]
  pruneopts = "UT"
-  revision = "505ab145d0a99da450461ae2c1a9f6cd10d1f447"
+  revision = "3764759f34a542a3aef74d6b02e35be7ab893bba"
+  source = "github.com/tendermint/crypto"

 [[projects]]
  digest = "1:d36f55a999540d29b6ea3c2ea29d71c76b1d9853fdcd3e5c5cb4836f2ba118f1"
@@ -503,10 +504,8 @@
  analyzer-name = "dep"
  analyzer-version = 1
  input-imports = [
-    "github.com/btcsuite/btcd/btcec",
    "github.com/btcsuite/btcutil/base58",
    "github.com/btcsuite/btcutil/bech32",
-    "github.com/ethereum/go-ethereum/crypto/secp256k1",
    "github.com/fortytw2/leaktest",
    "github.com/go-kit/kit/log",
    "github.com/go-kit/kit/log/level",
@@ -536,6 +535,7 @@
    "github.com/syndtr/goleveldb/leveldb/errors",
    "github.com/syndtr/goleveldb/leveldb/iterator",
    "github.com/syndtr/goleveldb/leveldb/opt",
+    "github.com/tendermint/btcd/btcec",
    "github.com/tendermint/go-amino",
    "golang.org/x/crypto/bcrypt",
    "golang.org/x/crypto/chacha20poly1305",
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -75,29 +75,14 @@
  name = "github.com/prometheus/client_golang"
  version = "^0.9.1"

-# we use the secp256k1 implementation:
-[[constraint]]
-  name = "github.com/ethereum/go-ethereum"
-  version = "^v1.8.21"
-
-   # Prevent dep from pruning build scripts and codegen templates
-   # note: this leaves the whole go-ethereum package in vendor
-   # can be removed when https://github.com/golang/dep/issues/1847 is resolved
-   [[prune.project]]
-     name = "github.com/ethereum/go-ethereum"
-     unused-packages = false
-
 ###################################
 ## Some repos dont have releases.
 ## Pin to revision

-[[constraint]]
-  name = "github.com/btcsuite/btcd"
-  revision = "ed77733ec07dfc8a513741138419b8d9d3de9d2d"
-
 [[constraint]]
  name = "golang.org/x/crypto"
-  revision = "505ab145d0a99da450461ae2c1a9f6cd10d1f447"
+  source = "github.com/tendermint/crypto"
+  revision = "3764759f34a542a3aef74d6b02e35be7ab893bba"

 [[override]]
  name = "github.com/jmhodges/levigo"
@@ -108,6 +93,9 @@
  name = "github.com/btcsuite/btcutil"
  revision = "d4cc87b860166d00d6b5b9e0d3b3d71d6088d4d4"

+[[constraint]]
+  name = "github.com/tendermint/btcd"
+  revision = "e5840949ff4fff0c56f9b6a541e22b63581ea9df"

 [[constraint]]
  name = "github.com/rcrowley/go-metrics"
--- a/75
+++ b/75
@@ -1,17 +1,18 @@
 GOTOOLS = \
 	github.com/mitchellh/gox \
 	github.com/golang/dep/cmd/dep \
-	github.com/golangci/golangci-lint/cmd/golangci-lint \
+	github.com/alecthomas/gometalinter \
 	github.com/gogo/protobuf/protoc-gen-gogo \
 	github.com/square/certstrap
 GOBIN?=${GOPATH}/bin
 PACKAGES=$(shell go list ./...)
-OUTPUT?=build/tendermint

 INCLUDE = -I=. -I=${GOPATH}/src -I=${GOPATH}/src/github.com/gogo/protobuf/protobuf
 BUILD_TAGS?='tendermint'
 BUILD_FLAGS = -ldflags "-X github.com/tendermint/tendermint/version.GitCommit=`git rev-parse --short=8 HEAD`"

+LINT_FLAGS = --exclude '.*\.pb\.go' --exclude 'vendor/*' --vendor --deadline=600s
+
 all: check build test install

 check: check_tools get_vendor_deps
@@ -20,13 +21,13 @@ check: check_tools get_vendor_deps
 ### Build Tendermint

 build:
-	CGO_ENABLED=0 go build $(BUILD_FLAGS) -tags $(BUILD_TAGS) -o $(OUTPUT) ./cmd/tendermint/
+	CGO_ENABLED=0 go build $(BUILD_FLAGS) -tags $(BUILD_TAGS) -o build/tendermint ./cmd/tendermint/

 build_c:
-	CGO_ENABLED=1 go build $(BUILD_FLAGS) -tags "$(BUILD_TAGS) gcc" -o $(OUTPUT) ./cmd/tendermint/
+	CGO_ENABLED=1 go build $(BUILD_FLAGS) -tags "$(BUILD_TAGS) gcc" -o build/tendermint ./cmd/tendermint/

 build_race:
-	CGO_ENABLED=0 go build -race $(BUILD_FLAGS) -tags $(BUILD_TAGS) -o $(OUTPUT) ./cmd/tendermint
+	CGO_ENABLED=0 go build -race $(BUILD_FLAGS) -tags $(BUILD_TAGS) -o build/tendermint ./cmd/tendermint

 install:
 	CGO_ENABLED=0 go install  $(BUILD_FLAGS) -tags $(BUILD_TAGS) ./cmd/tendermint
@@ -81,6 +82,10 @@ 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)
+
 update_tools:
 	@echo "--> Updating tools"
 	./scripts/get_tools.sh
@@ -110,7 +115,7 @@ draw_deps:

 get_deps_bin_size:
 	@# Copy of build recipe with additional flags to perform binary size analysis
-	$(eval $(shell go build -work -a $(BUILD_FLAGS) -tags $(BUILD_TAGS) -o $(OUTPUT) ./cmd/tendermint/ 2>&1))
+	$(eval $(shell go build -work -a $(BUILD_FLAGS) -tags $(BUILD_TAGS) -o build/tendermint ./cmd/tendermint/ 2>&1))
 	@find $(WORK) -type f -name "*.a" | xargs -I{} du -hxs "{}" | sort -rh | sed -e s:${WORK}/::g > deps_bin_size.log
 	@echo "Results can be found here: $(CURDIR)/deps_bin_size.log"

@@ -221,22 +226,6 @@ test_race:
 	@echo "--> Running go test --race"
 	@GOCACHE=off go test -p 1 -v -race $(PACKAGES)

-# uses https://github.com/sasha-s/go-deadlock/ to detect potential deadlocks
-test_with_deadlock:
-	make set_with_deadlock
-	make test
-	make cleanup_after_test_with_deadlock
-
-set_with_deadlock:
-	find . -name "*.go" | grep -v "vendor/" | xargs -n 1 sed -i.bak 's/sync.RWMutex/deadlock.RWMutex/'
-	find . -name "*.go" | grep -v "vendor/" | xargs -n 1 sed -i.bak 's/sync.Mutex/deadlock.Mutex/'
-	find . -name "*.go" | grep -v "vendor/" | xargs -n 1 goimports -w
-
-# cleanes up after you ran test_with_deadlock
-cleanup_after_test_with_deadlock:
-	find . -name "*.go" | grep -v "vendor/" | xargs -n 1 sed -i.bak 's/deadlock.RWMutex/sync.RWMutex/'
-	find . -name "*.go" | grep -v "vendor/" | xargs -n 1 sed -i.bak 's/deadlock.Mutex/sync.Mutex/'
-	find . -name "*.go" | grep -v "vendor/" | xargs -n 1 goimports -w

 ########################################
 ### Formatting, linting, and vetting
@@ -244,9 +233,38 @@ cleanup_after_test_with_deadlock:
 fmt:
 	@go fmt ./...

-lint:
+metalinter:
 	@echo "--> Running linter"
-	@golangci-lint run
+	@gometalinter $(LINT_FLAGS) --disable-all  \
+		--enable=deadcode \
+		--enable=gosimple \
+	 	--enable=misspell \
+		--enable=safesql \
+		./...
+		#--enable=gas \
+		#--enable=maligned \
+		#--enable=dupl \
+		#--enable=errcheck \
+		#--enable=goconst \
+		#--enable=gocyclo \
+		#--enable=goimports \
+		#--enable=golint \ <== comments on anything exported
+		#--enable=gotype \
+	 	#--enable=ineffassign \
+	   	#--enable=interfacer \
+	   	#--enable=megacheck \
+	   	#--enable=staticcheck \
+	   	#--enable=structcheck \
+	   	#--enable=unconvert \
+	   	#--enable=unparam \
+		#--enable=unused \
+	   	#--enable=varcheck \
+		#--enable=vet \
+		#--enable=vetshadow \
+
+metalinter_all:
+	@echo "--> Running linter (all)"
+	gometalinter $(LINT_FLAGS) --enable-all --disable=lll ./...

 DESTINATION = ./index.html.md

@@ -262,7 +280,7 @@ check_dep:
 ### Docker image

 build-docker:
-	cp $(OUTPUT) DOCKER/tendermint
+	cp build/tendermint DOCKER/tendermint
 	docker build --label=tendermint --tag="tendermint/tendermint" DOCKER
 	rm -rf DOCKER/tendermint

@@ -270,11 +288,12 @@ build-docker:
 ### Local testnet using docker

 # Build linux binary on other platforms
-build-linux: get_tools get_vendor_deps
+build-linux:
 	GOOS=linux GOARCH=amd64 $(MAKE) build

 build-docker-localnode:
-	@cd networks/local && make
+	cd networks/local
+	make

 # Run a 4-node testnet locally
 localnet-start: localnet-stop
@@ -312,4 +331,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 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 test_with_deadlock cleanup_after_test_with_deadlock lint
+.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
--- a/PHILOSOPHY.md
+++ b/PHILOSOPHY.md
@@ -1,158 +0,0 @@
-## Design goals
-
-The design goals for Tendermint (and the SDK and related libraries) are:
-
- * Simplicity and Legibility
- * Parallel performance, namely ability to utilize multicore architecture
- * Ability to evolve the codebase bug-free
- * Debuggability
- * Complete correctness that considers all edge cases, esp in concurrency
- * Future-proof modular architecture, message protocol, APIs, and encapsulation
-
-
-### Justification
-
-Legibility is key to maintaining bug-free software as it evolves toward more
-optimizations, more ease of debugging, and additional features.
-
-It is too easy to introduce bugs over time by replacing lines of code with
-those that may panic, which means ideally locks are unlocked by defer
-statements.
-
-For example,
-
-```go
-func (obj *MyObj) something() {
-	mtx.Lock()
-	obj.something = other
-	mtx.Unlock()
-}
-```
-
-It is too easy to refactor the codebase in the future to replace `other` with
-`other.String()` for example, and this may introduce a bug that causes a
-deadlock.  So as much as reasonably possible, we need to be using defer
-statements, even though it introduces additional overhead.
-
-If it is necessary to optimize the unlocking of mutex locks, the solution is
-more modularity via smaller functions, so that defer'd unlocks are scoped
-within a smaller function.
-
-Similarly, idiomatic for-loops should always be preferred over those that use
-custom counters, because it is too easy to evolve the body of a for-loop to
-become more complicated over time, and it becomes more and more difficult to
-assess the correctness of such a for-loop by visual inspection.
-
-
-### On performance
-
-It doesn't matter whether there are alternative implementations that are 2x or
-3x more performant, when the software doesn't work, deadlocks, or if bugs
-cannot be debugged.  By taking advantage of multicore concurrency, the
-Tendermint implementation will at least be an order of magnitude within the
-range of what is theoretically possible.  The design philosophy of Tendermint,
-and the choice of Go as implementation language, is designed to make Tendermint
-implementation the standard specification for concurrent BFT software.
-
-By focusing on the message protocols (e.g. ABCI, p2p messages), and
-encapsulation e.g. IAVL module, (relatively) independent reactors, we are both
-implementing a standard implementation to be used as the specification for
-future implementations in more optimizable languages like Rust, Java, and C++;
-as well as creating sufficiently performant software. Tendermint Core will
-never be as fast as future implementations of the Tendermint Spec, because Go
-isn't designed to be as fast as possible.  The advantage of using Go is that we
-can develop the whole stack of modular components **faster** than in other
-languages.
-
-Furthermore, the real bottleneck is in the application layer, and it isn't
-necessary to support more than a sufficiently decentralized set of validators
-(e.g. 100 ~ 300 validators is sufficient, with delegated bonded PoS).
-
-Instead of optimizing Tendermint performance down to the metal, lets focus on
-optimizing on other matters, namely ability to push feature complete software
-that works well enough, can be debugged and maintained, and can serve as a spec
-for future implementations.
-
-
-### On encapsulation
-
-In order to create maintainable, forward-optimizable software, it is critical
-to develop well-encapsulated objects that have well understood properties, and
-to re-use these easy-to-use-correctly components as building blocks for further
-encapsulated meta-objects.
-
-For example, mutexes are cheap enough for Tendermint's design goals when there
-isn't goroutine contention, so it is encouraged to create concurrency safe
-structures with struct-level mutexes.  If they are used in the context of
-non-concurrent logic, then the performance is good enough.  If they are used in
-the context of concurrent logic, then it will still perform correctly.
-
-Examples of this design principle can be seen in the types.ValidatorSet struct,
-and the cmn.Rand struct.  It's one single struct declaration that can be used
-in both concurrent and non-concurrent logic, and due to its well encapsulation,
-it's easy to get the usage of the mutex right.
-
-#### example: cmn.Rand:
-
-`The default Source is safe for concurrent use by multiple goroutines, but
-Sources created by NewSource are not`.  The reason why the default
-package-level source is safe for concurrent use is because it is protected (see
-`lockedSource` in https://golang.org/src/math/rand/rand.go).
-
-But we shouldn't rely on the global source, we should be creating our own
-Rand/Source instances and using them, especially for determinism in testing.
-So it is reasonable to have cmn.Rand be protected by a mutex.  Whether we want
-our own implementation of Rand is another question, but the answer there is
-also in the affirmative.  Sometimes you want to know where Rand is being used
-in your code, so it becomes a simple matter of dropping in a log statement to
-inject inspectability into Rand usage.  Also, it is nice to be able to extend
-the functionality of Rand with custom methods.  For these reasons, and for the
-reasons which is outlined in this design philosophy document, we should
-continue to use the cmn.Rand object, with mutex protection.
-
-Another key aspect of good encapsulation is the choice of exposed vs unexposed
-methods.  It should be clear to the reader of the code, which methods are
-intended to be used in what context, and what safe usage is.  Part of this is
-solved by hiding methods via unexported methods.  Another part of this is
-naming conventions on the methods (e.g. underscores) with good documentation,
-and code organization.  If there are too many exposed methods and it isn't
-clear what methods have what side effects, then there is something wrong about
-the design of abstractions that should be revisited.
-
-
-### On concurrency
-
-In order for Tendermint to remain relevant in the years to come, it is vital
-for Tendermint to take advantage of multicore architectures.  Due to the nature
-of the problem, namely consensus across a concurrent p2p gossip network, and to
-handle RPC requests for a large number of consuming subscribers, it is
-unavoidable for Tendermint development to require expertise in concurrency
-design, especially when it comes to the reactor design, and also for RPC
-request handling.
-
-
-## Guidelines
-
-Here are some guidelines for designing for (sufficient) performance and concurrency:
-
- * Mutex locks are cheap enough when there isn't contention.
- * Do not optimize code without analytical or observed proof that it is in a hot path.
- * Don't over-use channels when mutex locks w/ encapsulation are sufficient.
- * The need to drain channels are often a hint of unconsidered edge cases.
- * The creation of O(N) one-off goroutines is generally technical debt that
-   needs to get addressed sooner than later.  Avoid creating too many
-goroutines as a patch around incomplete concurrency design, or at least be
-aware of the debt and do not invest in the debt.  On the other hand, Tendermint
-is designed to have a limited number of peers (e.g. 10 or 20), so the creation
-of O(C) goroutines per O(P) peers is still O(C\*P=constant).
-  * Use defer statements to unlock as much as possible.  If you want to unlock sooner,
-    try to create more modular functions that do make use of defer statements.
-
-## Matras
-
-* Premature optimization kills
-* Readability is paramount
-* Beautiful is better than fast.
-* In the face of ambiguity, refuse the temptation to guess.
-* In the face of bugs, refuse the temptation to cover the bug.
-* There should be one-- and preferably only one --obvious way to do it.
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
 # Tendermint

 [Byzantine-Fault Tolerant](https://en.wikipedia.org/wiki/Byzantine_fault_tolerance)
-[State Machines](https://en.wikipedia.org/wiki/State_machine_replication).
-Or [Blockchain](https://en.wikipedia.org/wiki/Blockchain_(database)), for short.
+[State Machine Replication](https://en.wikipedia.org/wiki/State_machine_replication).
+Or [Blockchain](https://en.wikipedia.org/wiki/Blockchain_(database)) for short.

 [![version](https://img.shields.io/github/tag/tendermint/tendermint.svg)](https://github.com/tendermint/tendermint/releases/latest)
 [![API Reference](
@@ -49,7 +49,7 @@ For examples of the kinds of bugs we're looking for, see [SECURITY.md](SECURITY.

 Requirement|Notes
 ---|---
-Go version | Go1.11.4 or higher
+Go version | Go1.10 or higher

 ## Documentation

@@ -66,26 +66,49 @@ See the [install instructions](/docs/introduction/install.md)
 - [Remote cluster using terraform and ansible](/docs/networks/terraform-and-ansible.md)
 - [Join the Cosmos testnet](https://cosmos.network/testnet)

+## Resources
+
+### Tendermint Core
+
+For details about the blockchain data structures and the p2p protocols, see the
+the [Tendermint specification](/docs/spec).
+
+For details on using the software, see the [documentation](/docs/) which is also
+hosted at: https://tendermint.com/docs/
+
+### Tools
+
+Benchmarking and monitoring is provided by `tm-bench` and `tm-monitor`, respectively.
+Their code is found [here](/tools) and these binaries need to be built seperately.
+Additional documentation is found [here](/docs/tools).
+
+### Sub-projects
+
+* [Amino](http://github.com/tendermint/go-amino), a reflection-based improvement on proto3
+* [IAVL](http://github.com/tendermint/iavl), Merkleized IAVL+ Tree implementation
+
+### Applications
+
+* [Cosmos SDK](http://github.com/cosmos/cosmos-sdk); a cryptocurrency application framework
+* [Ethermint](http://github.com/cosmos/ethermint); Ethereum on Tendermint
+* [Many more](https://tendermint.com/ecosystem)
+
+### 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)
+
 ## Contributing

-Please abide by the [Code of Conduct](CODE_OF_CONDUCT.md) in all interactions,
-and the [contributing guidelines](CONTRIBUTING.md) when submitting code.
-
-Join the larger community on the [forum](https://forum.cosmos.network/) and the [chat](https://riot.im/app/#/room/#tendermint:matrix.org).
-
-To learn more about the structure of the software, watch the [Developer
-Sessions](https://www.youtube.com/playlist?list=PLdQIb0qr3pnBbG5ZG-0gr3zM86_s8Rpqv)
-and read some [Architectural
-Decision Records](https://github.com/tendermint/tendermint/tree/master/docs/architecture).
-
-Learn more by reading the code and comparing it to the
-[specification](https://github.com/tendermint/tendermint/tree/develop/docs/spec).
+Yay open source! Please see our [contributing guidelines](CONTRIBUTING.md).

 ## Versioning

-### Semantic Versioning
+### SemVer

-Tendermint uses [Semantic Versioning](http://semver.org/) to determine when and how the version changes.
+Tendermint uses [SemVer](http://semver.org/) to determine when and how the version changes.
 According to SemVer, anything in the public API can change at any time before version 1.0.0

 To provide some stability to Tendermint users in these 0.X.X days, the MINOR version is used
@@ -96,7 +119,6 @@ include the in-process Go APIs.
 That said, breaking changes in the following packages will be documented in the
 CHANGELOG even if they don't lead to MINOR version bumps:

- crypto
 - types
 - rpc/client
 - config
@@ -123,40 +145,8 @@ data into the new chain.
 However, any bump in the PATCH version should be compatible with existing histories
 (if not please open an [issue](https://github.com/tendermint/tendermint/issues)).

-For more information on upgrading, see [UPGRADING.md](./UPGRADING.md)
+For more information on upgrading, see [here](./UPGRADING.md)

-## Resources
-
-### Tendermint Core
-
-For details about the blockchain data structures and the p2p protocols, see the
-[Tendermint specification](/docs/spec).
-
-For details on using the software, see the [documentation](/docs/) which is also
-hosted at: https://tendermint.com/docs/
-
-### Tools
-
-Benchmarking and monitoring is provided by `tm-bench` and `tm-monitor`, respectively.
-Their code is found [here](/tools) and these binaries need to be built seperately.
-Additional documentation is found [here](/docs/tools).
-
-### Sub-projects
-
-* [Amino](http://github.com/tendermint/go-amino), reflection-based proto3, with
-  interfaces
-* [IAVL](http://github.com/tendermint/iavl), Merkleized IAVL+ Tree implementation
-
-### Applications
-
-* [Cosmos SDK](http://github.com/cosmos/cosmos-sdk); a cryptocurrency application framework
-* [Ethermint](http://github.com/cosmos/ethermint); Ethereum on Tendermint
-* [Many more](https://tendermint.com/ecosystem)
-
-### 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)
+## Code of Conduct

+Please read, understand and adhere to our [code of conduct](CODE_OF_CONDUCT.md).
--- a/UPGRADING.md
+++ b/UPGRADING.md
@@ -3,100 +3,6 @@
 This guide provides steps to be followed when you upgrade your applications to
 a newer version of Tendermint Core.

-## v0.30.0
-
-This release contains a breaking change to both the block and p2p protocols,
-however it may be compatible with blockchains created with v0.29.0 depending on
-the chain history. If your blockchain has not included any pieces of evidence,
-or no piece of evidence has been included in more than one block,
-and if your application has never returned multiple updates
-for the same validator in a single block, then v0.30.0 will work fine with
-blockchains created with v0.29.0.
-
-The p2p protocol change is to fix the proposer selection algorithm again.
-Note that proposer selection is purely a p2p concern right
-now since the algorithm is only relevant during real time consensus.
-This change is thus compatible with v0.29.0, but
-all nodes must be upgraded to avoid disagreements on the proposer.
-
-### Applications
-
-Applications must ensure they do not return duplicates in
-`ResponseEndBlock.ValidatorUpdates`. A pubkey must only appear once per set of
-updates. Duplicates will cause irrecoverable failure. If you have a very good
-reason why we shouldn't do this, please open an issue.
-
-## v0.29.0
-
-This release contains some breaking changes to the block and p2p protocols,
-and will not be compatible with any previous versions of the software, primarily
-due to changes in how various data structures are hashed.
-
-Any implementations of Tendermint blockchain verification, including lite clients,
-will need to be updated. For specific details:
- [Merkle tree](./docs/spec/blockchain/encoding.md#merkle-trees)
- [ConsensusParams](./docs/spec/blockchain/state.md#consensusparams)
-
-There was also a small change to field ordering in the vote struct. Any
-implementations of an out-of-process validator (like a Key-Management Server)
-will need to be updated. For specific details:
- [Vote](https://github.com/tendermint/tendermint/blob/develop/docs/spec/consensus/signing.md#votes)
-
-Finally, the proposer selection algorithm continues to evolve. See the
-[work-in-progress
-specification](https://github.com/tendermint/tendermint/pull/3140).
-
-For everything else, please see the [CHANGELOG](./CHANGELOG.md#v0.29.0).
-
-## v0.28.0
-
-This release breaks the format for the `priv_validator.json` file
-and the protocol used for the external validator process.
-It is compatible with v0.27.0 blockchains (neither the BlockProtocol nor the
-P2PProtocol have changed).
-
-Please read carefully for details about upgrading.
-
-**Note:** Backup your `config/priv_validator.json`
-before proceeding.
-
-### `priv_validator.json`
-
-The `config/priv_validator.json` is now two files:
-`config/priv_validator_key.json` and `data/priv_validator_state.json`.
-The former contains the key material, the later contains the details on the last
-message signed.
-
-When running v0.28.0 for the first time, it will back up any pre-existing
-`priv_validator.json` file and proceed to split it into the two new files.
-Upgrading should happen automatically without problem.
-
-To upgrade manually, use the provided `privValUpgrade.go` script, with exact paths for the old
-`priv_validator.json` and the locations for the two new files. It's recomended
-to use the default paths, of `config/priv_validator_key.json` and
-`data/priv_validator_state.json`, respectively:
-
-```
-go run scripts/privValUpgrade.go <old-path> <new-key-path> <new-state-path>
-```
-
-### External validator signers
-
-The Unix and TCP implementations of the remote signing validator
-have been consolidated into a single implementation.
-Thus in both cases, the external process is expected to dial
-Tendermint. This is different from how Unix sockets used to work, where
-Tendermint dialed the external process.
-
-The `PubKeyMsg` was also split into separate `Request` and `Response` types
-for consistency with other messages.
-
-Note that the TCP sockets don't yet use a persistent key,
-so while they're encrypted, they can't yet be properly authenticated.
-See [#3105](https://github.com/tendermint/tendermint/issues/3105).
-Note the Unix socket has neither encryption nor authentication, but will
-add a shared-secret in [#3099](https://github.com/tendermint/tendermint/issues/3099).
-
 ## v0.27.0

 This release contains some breaking changes to the block and p2p protocols,
--- 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_vendor_deps'
+    su - vagrant -c 'cd /home/vagrant/go/src/github.com/tendermint/tendermint && make get_tools && make get_dev_tools && make get_vendor_deps'
  SHELL
 end
--- a/abci/client/grpc_client.go
+++ b/abci/client/grpc_client.go
@@ -129,7 +129,7 @@ func (cli *grpcClient) EchoAsync(msg string) *ReqRes {
 	if err != nil {
 		cli.StopForError(err)
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Echo{Echo: res}})
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Echo{res}})
 }

 func (cli *grpcClient) FlushAsync() *ReqRes {
@@ -138,7 +138,7 @@ func (cli *grpcClient) FlushAsync() *ReqRes {
 	if err != nil {
 		cli.StopForError(err)
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Flush{Flush: res}})
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Flush{res}})
 }

 func (cli *grpcClient) InfoAsync(params types.RequestInfo) *ReqRes {
@@ -147,7 +147,7 @@ func (cli *grpcClient) InfoAsync(params types.RequestInfo) *ReqRes {
 	if err != nil {
 		cli.StopForError(err)
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Info{Info: res}})
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Info{res}})
 }

 func (cli *grpcClient) SetOptionAsync(params types.RequestSetOption) *ReqRes {
@@ -156,7 +156,7 @@ func (cli *grpcClient) SetOptionAsync(params types.RequestSetOption) *ReqRes {
 	if err != nil {
 		cli.StopForError(err)
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_SetOption{SetOption: res}})
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_SetOption{res}})
 }

 func (cli *grpcClient) DeliverTxAsync(tx []byte) *ReqRes {
@@ -165,7 +165,7 @@ func (cli *grpcClient) DeliverTxAsync(tx []byte) *ReqRes {
 	if err != nil {
 		cli.StopForError(err)
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_DeliverTx{DeliverTx: res}})
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_DeliverTx{res}})
 }

 func (cli *grpcClient) CheckTxAsync(tx []byte) *ReqRes {
@@ -174,7 +174,7 @@ func (cli *grpcClient) CheckTxAsync(tx []byte) *ReqRes {
 	if err != nil {
 		cli.StopForError(err)
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_CheckTx{CheckTx: res}})
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_CheckTx{res}})
 }

 func (cli *grpcClient) QueryAsync(params types.RequestQuery) *ReqRes {
@@ -183,7 +183,7 @@ func (cli *grpcClient) QueryAsync(params types.RequestQuery) *ReqRes {
 	if err != nil {
 		cli.StopForError(err)
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Query{Query: res}})
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Query{res}})
 }

 func (cli *grpcClient) CommitAsync() *ReqRes {
@@ -192,7 +192,7 @@ func (cli *grpcClient) CommitAsync() *ReqRes {
 	if err != nil {
 		cli.StopForError(err)
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Commit{Commit: res}})
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Commit{res}})
 }

 func (cli *grpcClient) InitChainAsync(params types.RequestInitChain) *ReqRes {
@@ -201,7 +201,7 @@ func (cli *grpcClient) InitChainAsync(params types.RequestInitChain) *ReqRes {
 	if err != nil {
 		cli.StopForError(err)
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_InitChain{InitChain: res}})
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_InitChain{res}})
 }

 func (cli *grpcClient) BeginBlockAsync(params types.RequestBeginBlock) *ReqRes {
@@ -210,7 +210,7 @@ func (cli *grpcClient) BeginBlockAsync(params types.RequestBeginBlock) *ReqRes {
 	if err != nil {
 		cli.StopForError(err)
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_BeginBlock{BeginBlock: res}})
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_BeginBlock{res}})
 }

 func (cli *grpcClient) EndBlockAsync(params types.RequestEndBlock) *ReqRes {
@@ -219,7 +219,7 @@ func (cli *grpcClient) EndBlockAsync(params types.RequestEndBlock) *ReqRes {
 	if err != nil {
 		cli.StopForError(err)
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_EndBlock{EndBlock: res}})
+	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_EndBlock{res}})
 }

 func (cli *grpcClient) finishAsyncCall(req *types.Request, res *types.Response) *ReqRes {
--- a/abci/cmd/abci-cli/abci-cli.go
+++ b/abci/cmd/abci-cli/abci-cli.go
@@ -58,7 +58,7 @@ var RootCmd = &cobra.Command{
 	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {

 		switch cmd.Use {
-		case "counter", "kvstore": // for the examples apps, don't pre-run
+		case "counter", "kvstore", "dummy": // for the examples apps, don't pre-run
 			return nil
 		case "version": // skip running for version command
 			return nil
@@ -127,6 +127,10 @@ func addCounterFlags() {
 	counterCmd.PersistentFlags().BoolVarP(&flagSerial, "serial", "", false, "enforce incrementing (serial) transactions")
 }

+func addDummyFlags() {
+	dummyCmd.PersistentFlags().StringVarP(&flagPersist, "persist", "", "", "directory to use for a database")
+}
+
 func addKVStoreFlags() {
 	kvstoreCmd.PersistentFlags().StringVarP(&flagPersist, "persist", "", "", "directory to use for a database")
 }
@@ -148,6 +152,10 @@ func addCommands() {
 	// examples
 	addCounterFlags()
 	RootCmd.AddCommand(counterCmd)
+	// deprecated, left for backwards compatibility
+	addDummyFlags()
+	RootCmd.AddCommand(dummyCmd)
+	// replaces dummy, see issue #196
 	addKVStoreFlags()
 	RootCmd.AddCommand(kvstoreCmd)
 }
@@ -283,6 +291,18 @@ var counterCmd = &cobra.Command{
 	},
 }

+// deprecated, left for backwards compatibility
+var dummyCmd = &cobra.Command{
+	Use:        "dummy",
+	Deprecated: "use: [abci-cli kvstore] instead",
+	Short:      "ABCI demo example",
+	Long:       "ABCI demo example",
+	Args:       cobra.ExactArgs(0),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return cmdKVStore(cmd, args)
+	},
+}
+
 var kvstoreCmd = &cobra.Command{
 	Use:   "kvstore",
 	Short: "ABCI demo example",
@@ -394,6 +414,7 @@ func cmdConsole(cmd *cobra.Command, args []string) error {
 			return err
 		}
 	}
+	return nil
 }

 func muxOnCommands(cmd *cobra.Command, pArgs []string) error {
--- a/abci/types/messages_test.go
+++ b/abci/types/messages_test.go
@@ -83,7 +83,7 @@ func TestWriteReadMessage2(t *testing.T) {
 			Log:       phrase,
 			GasWanted: 10,
 			Tags: []cmn.KVPair{
-				{Key: []byte("abc"), Value: []byte("def")},
+				cmn.KVPair{Key: []byte("abc"), Value: []byte("def")},
 			},
 		},
 		// TODO: add the rest
--- a/benchmarks/codec_test.go
+++ b/benchmarks/codec_test.go
@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"

-	amino "github.com/tendermint/go-amino"
+	"github.com/tendermint/go-amino"

 	proto "github.com/tendermint/tendermint/benchmarks/proto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
--- a/blockchain/pool.go
+++ b/blockchain/pool.go
@@ -363,8 +363,7 @@ func (pool *BlockPool) sendError(err error, peerID p2p.ID) {
 	pool.errorsCh <- peerError{err, peerID}
 }

-// for debugging purposes
-//nolint:unused
+// unused by tendermint; left for debugging purposes
 func (pool *BlockPool) debug() string {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
--- a/blockchain/reactor.go
+++ b/blockchain/reactor.go
@@ -8,6 +8,7 @@ import (

 	amino "github.com/tendermint/go-amino"

+	cmn "github.com/tendermint/tendermint/libs/common"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/p2p"
 	sm "github.com/tendermint/tendermint/state"
@@ -301,7 +302,7 @@ FOR_LOOP:

 			firstParts := first.MakePartSet(types.BlockPartSizeBytes)
 			firstPartsHeader := firstParts.Header()
-			firstID := types.BlockID{Hash: first.Hash(), PartsHeader: firstPartsHeader}
+			firstID := types.BlockID{first.Hash(), firstPartsHeader}
 			// Finally, verify the first block using the second's commit
 			// NOTE: we can probably make this more efficient, but note that calling
 			// first.Hash() doesn't verify the tx contents, so MakePartSet() is
@@ -337,7 +338,8 @@ FOR_LOOP:
 				state, err = bcR.blockExec.ApplyBlock(state, firstID, first)
 				if err != nil {
 					// TODO This is bad, are we zombie?
-					panic(fmt.Sprintf("Failed to process committed block (%d:%X): %v", first.Height, first.Hash(), err))
+					cmn.PanicQ(fmt.Sprintf("Failed to process committed block (%d:%X): %v",
+						first.Height, first.Hash(), err))
 				}
 				blocksSynced++

@@ -430,7 +432,11 @@ type bcBlockResponseMessage struct {

 // ValidateBasic performs basic validation.
 func (m *bcBlockResponseMessage) ValidateBasic() error {
-	return m.Block.ValidateBasic()
+	if err := m.Block.ValidateBasic(); err != nil {
+		return err
+	}
+
+	return nil
 }

 func (m *bcBlockResponseMessage) String() string {
--- a/blockchain/reactor_test.go
+++ b/blockchain/reactor_test.go
@@ -1,7 +1,6 @@
 package blockchain

 import (
-	"os"
 	"sort"
 	"testing"
 	"time"
@@ -96,13 +95,13 @@ func newBlockchainReactor(logger log.Logger, genDoc *types.GenesisDoc, privVals

 	// let's add some blocks in
 	for blockHeight := int64(1); blockHeight <= maxBlockHeight; blockHeight++ {
-		lastCommit := types.NewCommit(types.BlockID{}, nil)
+		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]).CommitSig()
-			lastCommit = types.NewCommit(lastBlockMeta.BlockID, []*types.CommitSig{vote})
+			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)
@@ -126,7 +125,6 @@ func newBlockchainReactor(logger log.Logger, genDoc *types.GenesisDoc, privVals

 func TestNoBlockResponse(t *testing.T) {
 	config = cfg.ResetTestRoot("blockchain_reactor_test")
-	defer os.RemoveAll(config.RootDir)
 	genDoc, privVals := randGenesisDoc(1, false, 30)

 	maxBlockHeight := int64(65)
@@ -186,7 +184,6 @@ func TestNoBlockResponse(t *testing.T) {
 // that seems extreme.
 func TestBadBlockStopsPeer(t *testing.T) {
 	config = cfg.ResetTestRoot("blockchain_reactor_test")
-	defer os.RemoveAll(config.RootDir)
 	genDoc, privVals := randGenesisDoc(1, false, 30)

 	maxBlockHeight := int64(148)
--- a/blockchain/store_test.go
+++ b/blockchain/store_test.go
@@ -3,11 +3,9 @@ package blockchain
 import (
 	"bytes"
 	"fmt"
-	"os"
 	"runtime/debug"
 	"strings"
 	"testing"
-	"time"

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -22,17 +20,7 @@ import (
 	tmtime "github.com/tendermint/tendermint/types/time"
 )

-// A cleanupFunc cleans up any config / test files created for a particular
-// test.
-type cleanupFunc func()
-
-// make a Commit with a single vote containing just the height and a timestamp
-func makeTestCommit(height int64, timestamp time.Time) *types.Commit {
-	commitSigs := []*types.CommitSig{{Height: height, Timestamp: timestamp}}
-	return types.NewCommit(types.BlockID{}, commitSigs)
-}
-
-func makeStateAndBlockStore(logger log.Logger) (sm.State, *BlockStore, cleanupFunc) {
+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())
@@ -42,7 +30,7 @@ func makeStateAndBlockStore(logger log.Logger) (sm.State, *BlockStore, cleanupFu
 	if err != nil {
 		panic(cmn.ErrorWrap(err, "error constructing state from genesis file"))
 	}
-	return state, NewBlockStore(blockDB), func() { os.RemoveAll(config.RootDir) }
+	return state, NewBlockStore(blockDB)
 }

 func TestLoadBlockStoreStateJSON(t *testing.T) {
@@ -92,32 +80,20 @@ func freshBlockStore() (*BlockStore, db.DB) {
 }

 var (
-	state       sm.State
-	block       *types.Block
-	partSet     *types.PartSet
-	part1       *types.Part
-	part2       *types.Part
-	seenCommit1 *types.Commit
-)
+	state, _ = makeStateAndBlockStore(log.NewTMLogger(new(bytes.Buffer)))

-func TestMain(m *testing.M) {
-	var cleanup cleanupFunc
-	state, _, cleanup = makeStateAndBlockStore(log.NewTMLogger(new(bytes.Buffer)))
-	block = makeBlock(1, state, new(types.Commit))
-	partSet = block.MakePartSet(2)
-	part1 = partSet.GetPart(0)
-	part2 = partSet.GetPart(1)
-	seenCommit1 = makeTestCommit(10, tmtime.Now())
-	code := m.Run()
-	cleanup()
-	os.Exit(code)
-}
+	block       = makeBlock(1, state, new(types.Commit))
+	partSet     = block.MakePartSet(2)
+	part1       = partSet.GetPart(0)
+	part2       = partSet.GetPart(1)
+	seenCommit1 = &types.Commit{Precommits: []*types.Vote{{Height: 10,
+		Timestamp: tmtime.Now()}}}
+)

 // TODO: This test should be simplified ...

 func TestBlockStoreSaveLoadBlock(t *testing.T) {
-	state, bs, cleanup := makeStateAndBlockStore(log.NewTMLogger(new(bytes.Buffer)))
-	defer cleanup()
+	state, bs := makeStateAndBlockStore(log.NewTMLogger(new(bytes.Buffer)))
 	require.Equal(t, bs.Height(), int64(0), "initially the height should be zero")

 	// check there are no blocks at various heights
@@ -131,7 +107,8 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 	// save a block
 	block := makeBlock(bs.Height()+1, state, new(types.Commit))
 	validPartSet := block.MakePartSet(2)
-	seenCommit := makeTestCommit(10, tmtime.Now())
+	seenCommit := &types.Commit{Precommits: []*types.Vote{{Height: 10,
+		Timestamp: tmtime.Now()}}}
 	bs.SaveBlock(block, partSet, seenCommit)
 	require.Equal(t, bs.Height(), block.Header.Height, "expecting the new height to be changed")

@@ -150,7 +127,8 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {

 	// End of setup, test data

-	commitAtH10 := makeTestCommit(10, tmtime.Now())
+	commitAtH10 := &types.Commit{Precommits: []*types.Vote{{Height: 10,
+		Timestamp: tmtime.Now()}}}
 	tuples := []struct {
 		block      *types.Block
 		parts      *types.PartSet
@@ -333,7 +311,7 @@ func TestLoadBlockPart(t *testing.T) {
 	gotPart, _, panicErr := doFn(loadPart)
 	require.Nil(t, panicErr, "an existent and proper block should not panic")
 	require.Nil(t, res, "a properly saved block should return a proper block")
-	require.Equal(t, gotPart.(*types.Part), part1,
+	require.Equal(t, gotPart.(*types.Part).Hash(), part1.Hash(),
 		"expecting successful retrieval of previously saved block")
 }

@@ -368,13 +346,14 @@ func TestLoadBlockMeta(t *testing.T) {
 }

 func TestBlockFetchAtHeight(t *testing.T) {
-	state, bs, cleanup := makeStateAndBlockStore(log.NewTMLogger(new(bytes.Buffer)))
-	defer cleanup()
+	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))

 	partSet := block.MakePartSet(2)
-	seenCommit := makeTestCommit(10, tmtime.Now())
+	seenCommit := &types.Commit{Precommits: []*types.Vote{{Height: 10,
+		Timestamp: tmtime.Now()}}}
+
 	bs.SaveBlock(block, partSet, seenCommit)
 	require.Equal(t, bs.Height(), block.Header.Height, "expecting the new height to be changed")

--- a/blockchain/wire.go
+++ b/blockchain/wire.go
@@ -1,7 +1,7 @@
 package blockchain

 import (
-	amino "github.com/tendermint/go-amino"
+	"github.com/tendermint/go-amino"
 	"github.com/tendermint/tendermint/types"
 )

--- a/cmd/priv_val_server/main.go
+++ b/cmd/priv_val_server/main.go
@@ -3,7 +3,6 @@ package main
 import (
 	"flag"
 	"os"
-	"time"

 	"github.com/tendermint/tendermint/crypto/ed25519"
 	cmn "github.com/tendermint/tendermint/libs/common"
@@ -14,10 +13,9 @@ import (

 func main() {
 	var (
-		addr             = flag.String("addr", ":26659", "Address of client to connect to")
-		chainID          = flag.String("chain-id", "mychain", "chain id")
-		privValKeyPath   = flag.String("priv-key", "", "priv val key file path")
-		privValStatePath = flag.String("priv-state", "", "priv val state file path")
+		addr        = flag.String("addr", ":26659", "Address of client to connect to")
+		chainID     = flag.String("chain-id", "mychain", "chain id")
+		privValPath = flag.String("priv", "", "priv val file path")

 		logger = log.NewTMLogger(
 			log.NewSyncWriter(os.Stdout),
@@ -29,26 +27,18 @@ func main() {
 		"Starting private validator",
 		"addr", *addr,
 		"chainID", *chainID,
-		"privKeyPath", *privValKeyPath,
-		"privStatePath", *privValStatePath,
+		"privPath", *privValPath,
 	)

-	pv := privval.LoadFilePV(*privValKeyPath, *privValStatePath)
+	pv := privval.LoadFilePV(*privValPath)

-	var dialer privval.Dialer
-	protocol, address := cmn.ProtocolAndAddress(*addr)
-	switch protocol {
-	case "unix":
-		dialer = privval.DialUnixFn(address)
-	case "tcp":
-		connTimeout := 3 * time.Second // TODO
-		dialer = privval.DialTCPFn(address, connTimeout, ed25519.GenPrivKey())
-	default:
-		logger.Error("Unknown protocol", "protocol", protocol)
-		os.Exit(1)
-	}
-
-	rs := privval.NewRemoteSigner(logger, *chainID, pv, dialer)
+	rs := privval.NewRemoteSigner(
+		logger,
+		*chainID,
+		*addr,
+		pv,
+		ed25519.GenPrivKey(),
+	)
 	err := rs.Start()
 	if err != nil {
 		panic(err)
--- a/cmd/tendermint/commands/gen_validator.go
+++ b/cmd/tendermint/commands/gen_validator.go
@@ -17,7 +17,7 @@ var GenValidatorCmd = &cobra.Command{
 }

 func genValidator(cmd *cobra.Command, args []string) {
-	pv := privval.GenFilePV("", "")
+	pv := privval.GenFilePV("")
 	jsbz, err := cdc.MarshalJSON(pv)
 	if err != nil {
 		panic(err)
--- a/cmd/tendermint/commands/init.go
+++ b/cmd/tendermint/commands/init.go
@@ -4,6 +4,7 @@ import (
 	"fmt"

 	"github.com/spf13/cobra"
+
 	cfg "github.com/tendermint/tendermint/config"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	"github.com/tendermint/tendermint/p2p"
@@ -25,18 +26,15 @@ func initFiles(cmd *cobra.Command, args []string) error {

 func initFilesWithConfig(config *cfg.Config) error {
 	// private validator
-	privValKeyFile := config.PrivValidatorKeyFile()
-	privValStateFile := config.PrivValidatorStateFile()
+	privValFile := config.PrivValidatorFile()
 	var pv *privval.FilePV
-	if cmn.FileExists(privValKeyFile) {
-		pv = privval.LoadFilePV(privValKeyFile, privValStateFile)
-		logger.Info("Found private validator", "keyFile", privValKeyFile,
-			"stateFile", privValStateFile)
+	if cmn.FileExists(privValFile) {
+		pv = privval.LoadFilePV(privValFile)
+		logger.Info("Found private validator", "path", privValFile)
 	} else {
-		pv = privval.GenFilePV(privValKeyFile, privValStateFile)
+		pv = privval.GenFilePV(privValFile)
 		pv.Save()
-		logger.Info("Generated private validator", "keyFile", privValKeyFile,
-			"stateFile", privValStateFile)
+		logger.Info("Generated private validator", "path", privValFile)
 	}

 	nodeKeyFile := config.NodeKeyFile()
--- a/cmd/tendermint/commands/reset_priv_validator.go
+++ b/cmd/tendermint/commands/reset_priv_validator.go
@@ -5,7 +5,6 @@ import (

 	"github.com/spf13/cobra"

-	cmn "github.com/tendermint/tendermint/libs/common"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/privval"
 )
@@ -28,41 +27,36 @@ var ResetPrivValidatorCmd = &cobra.Command{
 // XXX: this is totally unsafe.
 // it's only suitable for testnets.
 func resetAll(cmd *cobra.Command, args []string) {
-	ResetAll(config.DBDir(), config.P2P.AddrBookFile(), config.PrivValidatorKeyFile(),
-		config.PrivValidatorStateFile(), logger)
+	ResetAll(config.DBDir(), config.P2P.AddrBookFile(), config.PrivValidatorFile(), logger)
 }

 // XXX: this is totally unsafe.
 // it's only suitable for testnets.
 func resetPrivValidator(cmd *cobra.Command, args []string) {
-	resetFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile(), logger)
+	resetFilePV(config.PrivValidatorFile(), logger)
 }

-// ResetAll removes address book files plus all data, and resets the privValdiator data.
+// ResetAll removes the privValidator and address book files plus all data.
 // Exported so other CLI tools can use it.
-func ResetAll(dbDir, addrBookFile, privValKeyFile, privValStateFile string, logger log.Logger) {
+func ResetAll(dbDir, addrBookFile, privValFile string, logger log.Logger) {
+	resetFilePV(privValFile, logger)
 	removeAddrBook(addrBookFile, logger)
 	if err := os.RemoveAll(dbDir); err == nil {
 		logger.Info("Removed all blockchain history", "dir", dbDir)
 	} else {
 		logger.Error("Error removing all blockchain history", "dir", dbDir, "err", err)
 	}
-	// recreate the dbDir since the privVal state needs to live there
-	cmn.EnsureDir(dbDir, 0700)
-	resetFilePV(privValKeyFile, privValStateFile, logger)
 }

-func resetFilePV(privValKeyFile, privValStateFile string, logger log.Logger) {
-	if _, err := os.Stat(privValKeyFile); err == nil {
-		pv := privval.LoadFilePVEmptyState(privValKeyFile, privValStateFile)
+func resetFilePV(privValFile string, logger log.Logger) {
+	if _, err := os.Stat(privValFile); err == nil {
+		pv := privval.LoadFilePV(privValFile)
 		pv.Reset()
-		logger.Info("Reset private validator file to genesis state", "keyFile", privValKeyFile,
-			"stateFile", privValStateFile)
+		logger.Info("Reset private validator file to genesis state", "file", privValFile)
 	} else {
-		pv := privval.GenFilePV(privValKeyFile, privValStateFile)
+		pv := privval.GenFilePV(privValFile)
 		pv.Save()
-		logger.Info("Generated private validator file", "keyFile", privValKeyFile,
-			"stateFile", privValStateFile)
+		logger.Info("Generated private validator file", "file", privValFile)
 	}
 }

--- a/cmd/tendermint/commands/root_test.go
+++ b/cmd/tendermint/commands/root_test.go
@@ -22,6 +22,10 @@ var (
 	defaultRoot = os.ExpandEnv("$HOME/.some/test/dir")
 )

+const (
+	rootName = "root"
+)
+
 // clearConfig clears env vars, the given root dir, and resets viper.
 func clearConfig(dir string) {
 	if err := os.Unsetenv("TMHOME"); err != nil {
--- a/cmd/tendermint/commands/run_node.go
+++ b/cmd/tendermint/commands/run_node.go
@@ -24,7 +24,7 @@ func AddNodeFlags(cmd *cobra.Command) {
 	cmd.Flags().Bool("fast_sync", config.FastSync, "Fast blockchain syncing")

 	// abci flags
-	cmd.Flags().String("proxy_app", config.ProxyApp, "Proxy app address, or one of: 'kvstore', 'persistent_kvstore', 'counter', 'counter_serial' or 'noop' for local testing.")
+	cmd.Flags().String("proxy_app", config.ProxyApp, "Proxy app address, or 'nilapp' or 'kvstore' for local testing.")
 	cmd.Flags().String("abci", config.ABCI, "Specify abci transport (socket | grpc)")

 	// rpc flags
@@ -77,6 +77,8 @@ func NewRunNodeCmd(nodeProvider nm.NodeProvider) *cobra.Command {

 			// Run forever
 			select {}
+
+			return nil
 		},
 	}

--- a/cmd/tendermint/commands/show_node_id.go
+++ b/cmd/tendermint/commands/show_node_id.go
@@ -16,11 +16,12 @@ var ShowNodeIDCmd = &cobra.Command{
 }

 func showNodeID(cmd *cobra.Command, args []string) error {
+
 	nodeKey, err := p2p.LoadNodeKey(config.NodeKeyFile())
 	if err != nil {
 		return err
 	}
-
 	fmt.Println(nodeKey.ID())
+
 	return nil
 }
--- a/cmd/tendermint/commands/show_validator.go
+++ b/cmd/tendermint/commands/show_validator.go
@@ -2,33 +2,47 @@ package commands

 import (
 	"fmt"
+	"os"

-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"

+	"github.com/tendermint/tendermint/crypto"
 	cmn "github.com/tendermint/tendermint/libs/common"
+	"github.com/tendermint/tendermint/node"
 	"github.com/tendermint/tendermint/privval"
 )

+func init() {
+	ShowValidatorCmd.Flags().String("priv_validator_laddr", config.PrivValidatorListenAddr, "Socket address to listen on for connections from external priv_validator process")
+}
+
 // ShowValidatorCmd adds capabilities for showing the validator info.
 var ShowValidatorCmd = &cobra.Command{
 	Use:   "show_validator",
 	Short: "Show this node's validator info",
-	RunE:  showValidator,
+	Run:   showValidator,
 }

-func showValidator(cmd *cobra.Command, args []string) error {
-	keyFilePath := config.PrivValidatorKeyFile()
-	if !cmn.FileExists(keyFilePath) {
-		return fmt.Errorf("private validator file %s does not exist", keyFilePath)
+func showValidator(cmd *cobra.Command, args []string) {
+	var pubKey crypto.PubKey
+	if config.PrivValidatorListenAddr != "" {
+		// If an address is provided, listen on the socket for a connection from an
+		// external signing process and request the public key from there.
+		privValidator, err := node.CreateAndStartPrivValidatorSocketClient(config.PrivValidatorListenAddr, logger)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to get private validator's public key: %v", err)
+			os.Exit(-1)
+		}
+		if pvsc, ok := privValidator.(cmn.Service); ok {
+			if err := pvsc.Stop(); err != nil {
+				fmt.Fprintf(os.Stderr, "Failed to get stop private validator client: %v", err)
+			}
+		}
+		pubKey = privValidator.GetPubKey()
+	} else {
+		privValidator := privval.LoadOrGenFilePV(config.PrivValidatorFile())
+		pubKey = privValidator.GetPubKey()
 	}
-
-	pv := privval.LoadFilePV(keyFilePath, config.PrivValidatorStateFile())
-	bz, err := cdc.MarshalJSON(pv.GetPubKey())
-	if err != nil {
-		return errors.Wrap(err, "failed to marshal private validator pubkey")
-	}
-
-	fmt.Println(string(bz))
-	return nil
+	pubKeyJSONBytes, _ := cdc.MarshalJSON(pubKey)
+	fmt.Println(string(pubKeyJSONBytes))
 }
--- a/cmd/tendermint/commands/testnet.go
+++ b/cmd/tendermint/commands/testnet.go
@@ -85,21 +85,15 @@ func testnetFiles(cmd *cobra.Command, args []string) error {
 			_ = os.RemoveAll(outputDir)
 			return err
 		}
-		err = os.MkdirAll(filepath.Join(nodeDir, "data"), nodeDirPerm)
-		if err != nil {
-			_ = os.RemoveAll(outputDir)
-			return err
-		}

 		initFilesWithConfig(config)

-		pvKeyFile := filepath.Join(nodeDir, config.BaseConfig.PrivValidatorKey)
-		pvStateFile := filepath.Join(nodeDir, config.BaseConfig.PrivValidatorState)
-
-		pv := privval.LoadFilePV(pvKeyFile, pvStateFile)
+		pvFile := filepath.Join(nodeDir, config.BaseConfig.PrivValidator)
+		pv := privval.LoadFilePV(pvFile)
+		pubKey := pv.GetPubKey()
 		genVals[i] = types.GenesisValidator{
-			Address: pv.GetPubKey().Address(),
-			PubKey:  pv.GetPubKey(),
+			Address: pubKey.Address(),
+			PubKey:  pubKey,
 			Power:   1,
 			Name:    nodeDirName,
 		}
@@ -152,7 +146,6 @@ func testnetFiles(cmd *cobra.Command, args []string) error {
 		nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i))
 		config.SetRoot(nodeDir)
 		config.P2P.AddrBookStrict = false
-		config.P2P.AllowDuplicateIP = true
 		if populatePersistentPeers {
 			config.P2P.PersistentPeers = persistentPeers
 		}
--- a/cmd/tendermint/commands/wire.go
+++ b/cmd/tendermint/commands/wire.go
@@ -1,7 +1,7 @@
 package commands

 import (
-	amino "github.com/tendermint/go-amino"
+	"github.com/tendermint/go-amino"
 	cryptoAmino "github.com/tendermint/tendermint/crypto/encoding/amino"
 )

--- a/config/config.go
+++ b/config/config.go
@@ -35,24 +35,15 @@ var (
 	defaultConfigFileName  = "config.toml"
 	defaultGenesisJSONName = "genesis.json"

-	defaultPrivValKeyName   = "priv_validator_key.json"
-	defaultPrivValStateName = "priv_validator_state.json"
-
+	defaultPrivValName  = "priv_validator.json"
 	defaultNodeKeyName  = "node_key.json"
 	defaultAddrBookName = "addrbook.json"

-	defaultConfigFilePath   = filepath.Join(defaultConfigDir, defaultConfigFileName)
-	defaultGenesisJSONPath  = filepath.Join(defaultConfigDir, defaultGenesisJSONName)
-	defaultPrivValKeyPath   = filepath.Join(defaultConfigDir, defaultPrivValKeyName)
-	defaultPrivValStatePath = filepath.Join(defaultDataDir, defaultPrivValStateName)
-
-	defaultNodeKeyPath  = filepath.Join(defaultConfigDir, defaultNodeKeyName)
-	defaultAddrBookPath = filepath.Join(defaultConfigDir, defaultAddrBookName)
-)
-
-var (
-	oldPrivVal     = "priv_validator.json"
-	oldPrivValPath = filepath.Join(defaultConfigDir, oldPrivVal)
+	defaultConfigFilePath  = filepath.Join(defaultConfigDir, defaultConfigFileName)
+	defaultGenesisJSONPath = filepath.Join(defaultConfigDir, defaultGenesisJSONName)
+	defaultPrivValPath     = filepath.Join(defaultConfigDir, defaultPrivValName)
+	defaultNodeKeyPath     = filepath.Join(defaultConfigDir, defaultNodeKeyName)
+	defaultAddrBookPath    = filepath.Join(defaultConfigDir, defaultAddrBookName)
 )

 // Config defines the top level configuration for a Tendermint node
@@ -169,10 +160,7 @@ type BaseConfig struct {
 	Genesis string `mapstructure:"genesis_file"`

 	// Path to the JSON file containing the private key to use as a validator in the consensus protocol
-	PrivValidatorKey string `mapstructure:"priv_validator_key_file"`
-
-	// Path to the JSON file containing the last sign state of a validator
-	PrivValidatorState string `mapstructure:"priv_validator_state_file"`
+	PrivValidator string `mapstructure:"priv_validator_file"`

 	// TCP or UNIX socket address for Tendermint to listen on for
 	// connections from an external PrivValidator process
@@ -195,20 +183,19 @@ type BaseConfig struct {
 // DefaultBaseConfig returns a default base configuration for a Tendermint node
 func DefaultBaseConfig() BaseConfig {
 	return BaseConfig{
-		Genesis:            defaultGenesisJSONPath,
-		PrivValidatorKey:   defaultPrivValKeyPath,
-		PrivValidatorState: defaultPrivValStatePath,
-		NodeKey:            defaultNodeKeyPath,
-		Moniker:            defaultMoniker,
-		ProxyApp:           "tcp://127.0.0.1:26658",
-		ABCI:               "socket",
-		LogLevel:           DefaultPackageLogLevels(),
-		LogFormat:          LogFormatPlain,
-		ProfListenAddress:  "",
-		FastSync:           true,
-		FilterPeers:        false,
-		DBBackend:          "leveldb",
-		DBPath:             "data",
+		Genesis:           defaultGenesisJSONPath,
+		PrivValidator:     defaultPrivValPath,
+		NodeKey:           defaultNodeKeyPath,
+		Moniker:           defaultMoniker,
+		ProxyApp:          "tcp://127.0.0.1:26658",
+		ABCI:              "socket",
+		LogLevel:          DefaultPackageLogLevels(),
+		LogFormat:         LogFormatPlain,
+		ProfListenAddress: "",
+		FastSync:          true,
+		FilterPeers:       false,
+		DBBackend:         "leveldb",
+		DBPath:            "data",
 	}
 }

@@ -231,20 +218,9 @@ func (cfg BaseConfig) GenesisFile() string {
 	return rootify(cfg.Genesis, cfg.RootDir)
 }

-// PrivValidatorKeyFile returns the full path to the priv_validator_key.json file
-func (cfg BaseConfig) PrivValidatorKeyFile() string {
-	return rootify(cfg.PrivValidatorKey, cfg.RootDir)
-}
-
-// PrivValidatorFile returns the full path to the priv_validator_state.json file
-func (cfg BaseConfig) PrivValidatorStateFile() string {
-	return rootify(cfg.PrivValidatorState, cfg.RootDir)
-}
-
-// OldPrivValidatorFile returns the full path of the priv_validator.json from pre v0.28.0.
-// TODO: eventually remove.
-func (cfg BaseConfig) OldPrivValidatorFile() string {
-	return rootify(oldPrivValPath, cfg.RootDir)
+// PrivValidatorFile returns the full path to the priv_validator.json file
+func (cfg BaseConfig) PrivValidatorFile() string {
+	return rootify(cfg.PrivValidator, cfg.RootDir)
 }

 // NodeKeyFile returns the full path to the node_key.json file
@@ -307,7 +283,7 @@ type RPCConfig struct {

 	// Maximum number of simultaneous connections.
 	// Does not include RPC (HTTP&WebSocket) connections. See max_open_connections
-	// If you want to accept a larger number than the default, make sure
+	// If you want to accept more significant number than the default, make sure
 	// you increase your OS limits.
 	// 0 - unlimited.
 	GRPCMaxOpenConnections int `mapstructure:"grpc_max_open_connections"`
@@ -317,7 +293,7 @@ type RPCConfig struct {

 	// Maximum number of simultaneous connections (including WebSocket).
 	// Does not include gRPC connections. See grpc_max_open_connections
-	// If you want to accept a larger number than the default, make sure
+	// If you want to accept more significant number than the default, make sure
 	// you increase your OS limits.
 	// 0 - unlimited.
 	// Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
@@ -458,7 +434,7 @@ func DefaultP2PConfig() *P2PConfig {
 		RecvRate:                5120000, // 5 mB/s
 		PexReactor:              true,
 		SeedMode:                false,
-		AllowDuplicateIP:        false,
+		AllowDuplicateIP:        true, // so non-breaking yet
 		HandshakeTimeout:        20 * time.Second,
 		DialTimeout:             3 * time.Second,
 		TestDialFail:            false,
@@ -798,12 +774,12 @@ type InstrumentationConfig struct {
 	PrometheusListenAddr string `mapstructure:"prometheus_listen_addr"`

 	// Maximum number of simultaneous connections.
-	// If you want to accept a larger number than the default, make sure
+	// If you want to accept more significant number than the default, make sure
 	// you increase your OS limits.
 	// 0 - unlimited.
 	MaxOpenConnections int `mapstructure:"max_open_connections"`

-	// Instrumentation namespace.
+	// Tendermint instrumentation namespace.
 	Namespace string `mapstructure:"namespace"`
 }

--- a/config/toml.go
+++ b/config/toml.go
@@ -2,17 +2,13 @@ package config

 import (
 	"bytes"
-	"fmt"
-	"io/ioutil"
+	"os"
 	"path/filepath"
 	"text/template"

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

-// DefaultDirPerm is the default permissions used when creating directories.
-const DefaultDirPerm = 0700
-
 var configTemplate *template.Template

 func init() {
@@ -27,13 +23,13 @@ func init() {
 // EnsureRoot creates the root, config, and data directories if they don't exist,
 // and panics if it fails.
 func EnsureRoot(rootDir string) {
-	if err := cmn.EnsureDir(rootDir, DefaultDirPerm); err != nil {
+	if err := cmn.EnsureDir(rootDir, 0700); err != nil {
 		cmn.PanicSanity(err.Error())
 	}
-	if err := cmn.EnsureDir(filepath.Join(rootDir, defaultConfigDir), DefaultDirPerm); err != nil {
+	if err := cmn.EnsureDir(filepath.Join(rootDir, defaultConfigDir), 0700); err != nil {
 		cmn.PanicSanity(err.Error())
 	}
-	if err := cmn.EnsureDir(filepath.Join(rootDir, defaultDataDir), DefaultDirPerm); err != nil {
+	if err := cmn.EnsureDir(filepath.Join(rootDir, defaultDataDir), 0700); err != nil {
 		cmn.PanicSanity(err.Error())
 	}

@@ -99,10 +95,7 @@ log_format = "{{ .BaseConfig.LogFormat }}"
 genesis_file = "{{ js .BaseConfig.Genesis }}"

 # Path to the JSON file containing the private key to use as a validator in the consensus protocol
-priv_validator_key_file = "{{ js .BaseConfig.PrivValidatorKey }}"
-
-# Path to the JSON file containing the last sign state of a validator
-priv_validator_state_file = "{{ js .BaseConfig.PrivValidatorState }}"
+priv_validator_file = "{{ js .BaseConfig.PrivValidator }}"

 # TCP or UNIX socket address for Tendermint to listen on for
 # connections from an external PrivValidator process
@@ -132,13 +125,13 @@ 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 = [{{ range .RPC.CORSAllowedOrigins }}{{ printf "%q, " . }}{{end}}]
+cors_allowed_origins = "{{ .RPC.CORSAllowedOrigins }}"

 # A list of methods the client is allowed to use with cross-domain requests
-cors_allowed_methods = [{{ range .RPC.CORSAllowedMethods }}{{ printf "%q, " . }}{{end}}]
+cors_allowed_methods = "{{ .RPC.CORSAllowedMethods }}"

 # A list of non simple headers the client is allowed to use with cross-domain requests
-cors_allowed_headers = [{{ range .RPC.CORSAllowedHeaders }}{{ printf "%q, " . }}{{end}}]
+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
@@ -146,7 +139,7 @@ grpc_laddr = "{{ .RPC.GRPCListenAddress }}"

 # Maximum number of simultaneous connections.
 # Does not include RPC (HTTP&WebSocket) connections. See max_open_connections
-# If you want to accept a larger number than the default, make sure
+# If you want to accept more significant number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
 # Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
@@ -158,7 +151,7 @@ unsafe = {{ .RPC.Unsafe }}

 # Maximum number of simultaneous connections (including WebSocket).
 # Does not include gRPC connections. See grpc_max_open_connections
-# If you want to accept a larger number than the default, make sure
+# If you want to accept more significant number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
 # Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
@@ -276,8 +269,8 @@ blocktime_iota = "{{ .Consensus.BlockTimeIota }}"
 # What indexer to use for transactions
 #
 # Options:
-#   1) "null"
-#   2) "kv" (default) - the simplest possible indexer, backed by key-value storage (defaults to levelDB; see DBBackend).
+#   1) "null" (default)
+#   2) "kv" - the simplest possible indexer, backed by key-value storage (defaults to levelDB; see DBBackend).
 indexer = "{{ .TxIndex.Indexer }}"

 # Comma-separated list of tags to index (by default the only tag is "tx.hash")
@@ -309,7 +302,7 @@ prometheus = {{ .Instrumentation.Prometheus }}
 prometheus_listen_addr = "{{ .Instrumentation.PrometheusListenAddr }}"

 # Maximum number of simultaneous connections.
-# If you want to accept a larger number than the default, make sure
+# If you want to accept more significant number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
 max_open_connections = {{ .Instrumentation.MaxOpenConnections }}
@@ -321,51 +314,53 @@ namespace = "{{ .Instrumentation.Namespace }}"
 /****** these are for test settings ***********/

 func ResetTestRoot(testName string) *Config {
-	return ResetTestRootWithChainID(testName, "")
-}
-
-func ResetTestRootWithChainID(testName string, chainID string) *Config {
-	// create a unique, concurrency-safe test directory under os.TempDir()
-	rootDir, err := ioutil.TempDir("", fmt.Sprintf("%s-%s_", chainID, testName))
-	if err != nil {
-		panic(err)
+	rootDir := os.ExpandEnv("$HOME/.tendermint_test")
+	rootDir = filepath.Join(rootDir, testName)
+	// Remove ~/.tendermint_test_bak
+	if cmn.FileExists(rootDir + "_bak") {
+		if err := os.RemoveAll(rootDir + "_bak"); err != nil {
+			cmn.PanicSanity(err.Error())
+		}
 	}
-	// ensure config and data subdirs are created
-	if err := cmn.EnsureDir(filepath.Join(rootDir, defaultConfigDir), DefaultDirPerm); err != nil {
-		panic(err)
+	// Move ~/.tendermint_test to ~/.tendermint_test_bak
+	if cmn.FileExists(rootDir) {
+		if err := os.Rename(rootDir, rootDir+"_bak"); err != nil {
+			cmn.PanicSanity(err.Error())
+		}
 	}
-	if err := cmn.EnsureDir(filepath.Join(rootDir, defaultDataDir), DefaultDirPerm); err != nil {
-		panic(err)
+	// Create new dir
+	if err := cmn.EnsureDir(rootDir, 0700); err != nil {
+		cmn.PanicSanity(err.Error())
+	}
+	if err := cmn.EnsureDir(filepath.Join(rootDir, defaultConfigDir), 0700); err != nil {
+		cmn.PanicSanity(err.Error())
+	}
+	if err := cmn.EnsureDir(filepath.Join(rootDir, defaultDataDir), 0700); err != nil {
+		cmn.PanicSanity(err.Error())
 	}

 	baseConfig := DefaultBaseConfig()
 	configFilePath := filepath.Join(rootDir, defaultConfigFilePath)
 	genesisFilePath := filepath.Join(rootDir, baseConfig.Genesis)
-	privKeyFilePath := filepath.Join(rootDir, baseConfig.PrivValidatorKey)
-	privStateFilePath := filepath.Join(rootDir, baseConfig.PrivValidatorState)
+	privFilePath := filepath.Join(rootDir, baseConfig.PrivValidator)

 	// Write default config file if missing.
 	if !cmn.FileExists(configFilePath) {
 		writeDefaultConfigFile(configFilePath)
 	}
 	if !cmn.FileExists(genesisFilePath) {
-		if chainID == "" {
-			chainID = "tendermint_test"
-		}
-		testGenesis := fmt.Sprintf(testGenesisFmt, chainID)
 		cmn.MustWriteFile(genesisFilePath, []byte(testGenesis), 0644)
 	}
 	// we always overwrite the priv val
-	cmn.MustWriteFile(privKeyFilePath, []byte(testPrivValidatorKey), 0644)
-	cmn.MustWriteFile(privStateFilePath, []byte(testPrivValidatorState), 0644)
+	cmn.MustWriteFile(privFilePath, []byte(testPrivValidator), 0644)

 	config := TestConfig().SetRoot(rootDir)
 	return config
 }

-var testGenesisFmt = `{
+var testGenesis = `{
  "genesis_time": "2018-10-10T08:20:13.695936996Z",
-  "chain_id": "%s",
+  "chain_id": "tendermint_test",
  "validators": [
    {
      "pub_key": {
@@ -379,7 +374,7 @@ var testGenesisFmt = `{
  "app_hash": ""
 }`

-var testPrivValidatorKey = `{
+var testPrivValidator = `{
  "address": "A3258DCBF45DCA0DF052981870F2D1441A36D145",
  "pub_key": {
    "type": "tendermint/PubKeyEd25519",
@@ -388,11 +383,8 @@ var testPrivValidatorKey = `{
  "priv_key": {
    "type": "tendermint/PrivKeyEd25519",
    "value": "EVkqJO/jIXp3rkASXfh9YnyToYXRXhBr6g9cQVxPFnQBP/5povV4HTjvsy530kybxKHwEi85iU8YL0qQhSYVoQ=="
-  }
-}`
-
-var testPrivValidatorState = `{
-  "height": "0",
-  "round": "0",
-  "step": 0
+  },
+  "last_height": "0",
+  "last_round": "0",
+  "last_step": 0
 }`
--- a/config/toml_test.go
+++ b/config/toml_test.go
@@ -48,7 +48,6 @@ func TestEnsureTestRoot(t *testing.T) {

 	// create root dir
 	cfg := ResetTestRoot(testName)
-	defer os.RemoveAll(cfg.RootDir)
 	rootDir := cfg.RootDir

 	// make sure config is set properly
@@ -61,7 +60,7 @@ func TestEnsureTestRoot(t *testing.T) {

 	// TODO: make sure the cfg returned and testconfig are the same!
 	baseConfig := DefaultBaseConfig()
-	ensureFiles(t, rootDir, defaultDataDir, baseConfig.Genesis, baseConfig.PrivValidatorKey, baseConfig.PrivValidatorState)
+	ensureFiles(t, rootDir, defaultDataDir, baseConfig.Genesis, baseConfig.PrivValidator)
 }

 func checkConfig(configFile string) bool {
--- a/consensus/byzantine_test.go
+++ b/consensus/byzantine_test.go
@@ -13,6 +13,10 @@ import (
 	"github.com/tendermint/tendermint/types"
 )

+func init() {
+	config = ResetConfig("consensus_byzantine_test")
+}
+
 //----------------------------------------------
 // byzantine failures

@@ -25,8 +29,7 @@ import (
 func TestByzantine(t *testing.T) {
 	N := 4
 	logger := consensusLogger().With("test", "byzantine")
-	css, cleanup := randConsensusNet(N, "consensus_byzantine_test", newMockTickerFunc(false), newCounter)
-	defer cleanup()
+	css := randConsensusNet(N, "consensus_byzantine_test", newMockTickerFunc(false), newCounter)

 	// give the byzantine validator a normal ticker
 	ticker := NewTimeoutTicker()
@@ -73,7 +76,8 @@ func TestByzantine(t *testing.T) {
 		conR.SetLogger(logger.With("validator", i))
 		conR.SetEventBus(eventBus)

-		var conRI p2p.Reactor = conR
+		var conRI p2p.Reactor // nolint: gotype, gosimple
+		conRI = conR

 		// make first val byzantine
 		if i == 0 {
--- a/consensus/common_test.go
+++ b/consensus/common_test.go
@@ -6,18 +6,14 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"path/filepath"
+	"path"
 	"reflect"
 	"sort"
 	"sync"
 	"testing"
 	"time"

-	"github.com/go-kit/kit/log/term"
-
-	abcicli "github.com/tendermint/tendermint/abci/client"
-	"github.com/tendermint/tendermint/abci/example/counter"
-	"github.com/tendermint/tendermint/abci/example/kvstore"
+	"github.com/tendermint/tendermint/abci/client"
 	abci "github.com/tendermint/tendermint/abci/types"
 	bc "github.com/tendermint/tendermint/blockchain"
 	cfg "github.com/tendermint/tendermint/config"
@@ -31,19 +27,19 @@ import (
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
+
+	"github.com/tendermint/tendermint/abci/example/counter"
+	"github.com/tendermint/tendermint/abci/example/kvstore"
+
+	"github.com/go-kit/kit/log/term"
 )

 const (
 	testSubscriber = "test-client"
 )

-// A cleanupFunc cleans up any config / test files created for a particular
-// test.
-type cleanupFunc func()
-
 // genesis, chain_id, priv_val
 var config *cfg.Config // NOTE: must be reset for each _test.go file
-var consensusReplayConfig *cfg.Config
 var ensureTimeout = time.Millisecond * 100

 func ensureDir(dir string, mode os.FileMode) {
@@ -129,21 +125,15 @@ func startTestRound(cs *ConsensusState, height int64, round int) {

 // Create proposal block from cs1 but sign it with vs
 func decideProposal(cs1 *ConsensusState, vs *validatorStub, height int64, round int) (proposal *types.Proposal, block *types.Block) {
-	cs1.mtx.Lock()
 	block, blockParts := cs1.createProposalBlock()
-	cs1.mtx.Unlock()
 	if block == nil { // on error
 		panic("error creating proposal block")
 	}

 	// Make proposal
-	cs1.mtx.RLock()
-	validRound := cs1.ValidRound
-	chainID := cs1.state.ChainID
-	cs1.mtx.RUnlock()
-	polRound, propBlockID := validRound, types.BlockID{block.Hash(), blockParts.Header()}
+	polRound, propBlockID := cs1.ValidRound, types.BlockID{block.Hash(), blockParts.Header()}
 	proposal = types.NewProposal(height, round, polRound, propBlockID)
-	if err := vs.SignProposal(chainID, proposal); err != nil {
+	if err := vs.SignProposal(cs1.state.ChainID, proposal); err != nil {
 		panic(err)
 	}
 	return
@@ -253,7 +243,6 @@ func subscribeToVoter(cs *ConsensusState, addr []byte) chan interface{} {
 // consensus states

 func newConsensusState(state sm.State, pv types.PrivValidator, app abci.Application) *ConsensusState {
-	config := cfg.ResetTestRoot("consensus_state_test")
 	return newConsensusStateWithConfig(config, state, pv, app)
 }

@@ -296,10 +285,9 @@ func newConsensusStateWithConfigAndBlockStore(thisConfig *cfg.Config, state sm.S
 }

 func loadPrivValidator(config *cfg.Config) *privval.FilePV {
-	privValidatorKeyFile := config.PrivValidatorKeyFile()
-	ensureDir(filepath.Dir(privValidatorKeyFile), 0700)
-	privValidatorStateFile := config.PrivValidatorStateFile()
-	privValidator := privval.LoadOrGenFilePV(privValidatorKeyFile, privValidatorStateFile)
+	privValidatorFile := config.PrivValidatorFile()
+	ensureDir(path.Dir(privValidatorFile), 0700)
+	privValidator := privval.LoadOrGenFilePV(privValidatorFile)
 	privValidator.Reset()
 	return privValidator
 }
@@ -390,6 +378,36 @@ func ensureNewEvent(
 	}
 }

+func ensureNewRoundStep(stepCh <-chan interface{}, height int64, round int) {
+	ensureNewEvent(
+		stepCh,
+		height,
+		round,
+		ensureTimeout,
+		"Timeout expired while waiting for NewStep event")
+}
+
+func ensureNewVote(voteCh <-chan interface{}, height int64, round int) {
+	select {
+	case <-time.After(ensureTimeout):
+		break
+	case v := <-voteCh:
+		edv, ok := v.(types.EventDataVote)
+		if !ok {
+			panic(fmt.Sprintf("expected a *types.Vote, "+
+				"got %v. wrong subscription channel?",
+				reflect.TypeOf(v)))
+		}
+		vote := edv.Vote
+		if vote.Height != height {
+			panic(fmt.Sprintf("expected height %v, got %v", height, vote.Height))
+		}
+		if vote.Round != round {
+			panic(fmt.Sprintf("expected round %v, got %v", round, vote.Round))
+		}
+	}
+}
+
 func ensureNewRound(roundCh <-chan interface{}, height int64, round int) {
 	select {
 	case <-time.After(ensureTimeout):
@@ -412,7 +430,7 @@ func ensureNewRound(roundCh <-chan interface{}, height int64, round int) {
 }

 func ensureNewTimeout(timeoutCh <-chan interface{}, height int64, round int, timeout int64) {
-	timeoutDuration := time.Duration(timeout*5) * time.Nanosecond
+	timeoutDuration := time.Duration(timeout*3) * time.Nanosecond
 	ensureNewEvent(timeoutCh, height, round, timeoutDuration,
 		"Timeout expired while waiting for NewTimeout event")
 }
@@ -566,21 +584,18 @@ func consensusLogger() log.Logger {
 	}).With("module", "consensus")
 }

-func randConsensusNet(nValidators int, testName string, tickerFunc func() TimeoutTicker,
-	appFunc func() abci.Application, configOpts ...func(*cfg.Config)) ([]*ConsensusState, cleanupFunc) {
+func randConsensusNet(nValidators int, testName string, tickerFunc func() TimeoutTicker, appFunc func() abci.Application, configOpts ...func(*cfg.Config)) []*ConsensusState {
 	genDoc, privVals := randGenesisDoc(nValidators, false, 30)
 	css := make([]*ConsensusState, nValidators)
 	logger := consensusLogger()
-	configRootDirs := make([]string, 0, nValidators)
 	for i := 0; i < nValidators; i++ {
 		stateDB := dbm.NewMemDB() // each state needs its own db
 		state, _ := sm.LoadStateFromDBOrGenesisDoc(stateDB, genDoc)
 		thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
-		configRootDirs = append(configRootDirs, thisConfig.RootDir)
 		for _, opt := range configOpts {
 			opt(thisConfig)
 		}
-		ensureDir(filepath.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
+		ensureDir(path.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
 		app := appFunc()
 		vals := types.TM2PB.ValidatorUpdates(state.Validators)
 		app.InitChain(abci.RequestInitChain{Validators: vals})
@@ -589,41 +604,28 @@ func randConsensusNet(nValidators int, testName string, tickerFunc func() Timeou
 		css[i].SetTimeoutTicker(tickerFunc())
 		css[i].SetLogger(logger.With("validator", i, "module", "consensus"))
 	}
-	return css, func() {
-		for _, dir := range configRootDirs {
-			os.RemoveAll(dir)
-		}
-	}
+	return css
 }

 // nPeers = nValidators + nNotValidator
-func randConsensusNetWithPeers(nValidators, nPeers int, testName string, tickerFunc func() TimeoutTicker,
-	appFunc func() abci.Application) ([]*ConsensusState, cleanupFunc) {
-
+func randConsensusNetWithPeers(nValidators, nPeers int, testName string, tickerFunc func() TimeoutTicker, appFunc func() abci.Application) []*ConsensusState {
 	genDoc, privVals := randGenesisDoc(nValidators, false, testMinPower)
 	css := make([]*ConsensusState, nPeers)
 	logger := consensusLogger()
-	configRootDirs := make([]string, 0, nPeers)
 	for i := 0; i < nPeers; i++ {
 		stateDB := dbm.NewMemDB() // each state needs its own db
 		state, _ := sm.LoadStateFromDBOrGenesisDoc(stateDB, genDoc)
 		thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
-		configRootDirs = append(configRootDirs, thisConfig.RootDir)
-		ensureDir(filepath.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
+		ensureDir(path.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
 		var privVal types.PrivValidator
 		if i < nValidators {
 			privVal = privVals[i]
 		} else {
-			tempKeyFile, err := ioutil.TempFile("", "priv_validator_key_")
+			tempFile, err := ioutil.TempFile("", "priv_validator_")
 			if err != nil {
 				panic(err)
 			}
-			tempStateFile, err := ioutil.TempFile("", "priv_validator_state_")
-			if err != nil {
-				panic(err)
-			}
-
-			privVal = privval.GenFilePV(tempKeyFile.Name(), tempStateFile.Name())
+			privVal = privval.GenFilePV(tempFile.Name())
 		}

 		app := appFunc()
@@ -634,11 +636,7 @@ func randConsensusNetWithPeers(nValidators, nPeers int, testName string, tickerF
 		css[i].SetTimeoutTicker(tickerFunc())
 		css[i].SetLogger(logger.With("validator", i, "module", "consensus"))
 	}
-	return css, func() {
-		for _, dir := range configRootDirs {
-			os.RemoveAll(dir)
-		}
-	}
+	return css
 }

 func getSwitchIndex(switches []*p2p.Switch, peer p2p.Peer) int {
@@ -648,6 +646,7 @@ func getSwitchIndex(switches []*p2p.Switch, peer p2p.Peer) int {
 		}
 	}
 	panic("didnt find peer in switches")
+	return -1
 }

 //-------------------------------------------------------------------------------
@@ -725,7 +724,8 @@ func (m *mockTicker) Chan() <-chan timeoutInfo {
 	return m.c
 }

-func (*mockTicker) SetLogger(log.Logger) {}
+func (mockTicker) SetLogger(log.Logger) {
+}

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

@@ -734,9 +734,6 @@ func newCounter() abci.Application {
 }

 func newPersistentKVStore() abci.Application {
-	dir, err := ioutil.TempDir("", "persistent-kvstore")
-	if err != nil {
-		panic(err)
-	}
+	dir, _ := ioutil.TempDir("/tmp", "persistent-kvstore")
 	return kvstore.NewPersistentKVStoreApplication(dir)
 }
--- a/consensus/mempool_test.go
+++ b/consensus/mempool_test.go
@@ -3,7 +3,6 @@ package consensus
 import (
 	"encoding/binary"
 	"fmt"
-	"os"
 	"testing"
 	"time"

@@ -11,22 +10,19 @@ import (

 	"github.com/tendermint/tendermint/abci/example/code"
 	abci "github.com/tendermint/tendermint/abci/types"
-	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
 )

-// for testing
-func assertMempool(txn txNotifier) sm.Mempool {
-	return txn.(sm.Mempool)
+func init() {
+	config = ResetConfig("consensus_mempool_test")
 }

 func TestMempoolNoProgressUntilTxsAvailable(t *testing.T) {
 	config := ResetConfig("consensus_mempool_txs_available_test")
-	defer os.RemoveAll(config.RootDir)
 	config.Consensus.CreateEmptyBlocks = false
 	state, privVals := randGenesisState(1, false, 10)
 	cs := newConsensusStateWithConfig(config, state, privVals[0], NewCounterApplication())
-	assertMempool(cs.txNotifier).EnableTxsAvailable()
+	cs.mempool.EnableTxsAvailable()
 	height, round := cs.Height, cs.Round
 	newBlockCh := subscribe(cs.eventBus, types.EventQueryNewBlock)
 	startTestRound(cs, height, round)
@@ -41,11 +37,10 @@ func TestMempoolNoProgressUntilTxsAvailable(t *testing.T) {

 func TestMempoolProgressAfterCreateEmptyBlocksInterval(t *testing.T) {
 	config := ResetConfig("consensus_mempool_txs_available_test")
-	defer os.RemoveAll(config.RootDir)
 	config.Consensus.CreateEmptyBlocksInterval = ensureTimeout
 	state, privVals := randGenesisState(1, false, 10)
 	cs := newConsensusStateWithConfig(config, state, privVals[0], NewCounterApplication())
-	assertMempool(cs.txNotifier).EnableTxsAvailable()
+	cs.mempool.EnableTxsAvailable()
 	height, round := cs.Height, cs.Round
 	newBlockCh := subscribe(cs.eventBus, types.EventQueryNewBlock)
 	startTestRound(cs, height, round)
@@ -57,11 +52,10 @@ func TestMempoolProgressAfterCreateEmptyBlocksInterval(t *testing.T) {

 func TestMempoolProgressInHigherRound(t *testing.T) {
 	config := ResetConfig("consensus_mempool_txs_available_test")
-	defer os.RemoveAll(config.RootDir)
 	config.Consensus.CreateEmptyBlocks = false
 	state, privVals := randGenesisState(1, false, 10)
 	cs := newConsensusStateWithConfig(config, state, privVals[0], NewCounterApplication())
-	assertMempool(cs.txNotifier).EnableTxsAvailable()
+	cs.mempool.EnableTxsAvailable()
 	height, round := cs.Height, cs.Round
 	newBlockCh := subscribe(cs.eventBus, types.EventQueryNewBlock)
 	newRoundCh := subscribe(cs.eventBus, types.EventQueryNewRound)
@@ -97,7 +91,7 @@ func deliverTxsRange(cs *ConsensusState, start, end int) {
 	for i := start; i < end; i++ {
 		txBytes := make([]byte, 8)
 		binary.BigEndian.PutUint64(txBytes, uint64(i))
-		err := assertMempool(cs.txNotifier).CheckTx(txBytes, nil)
+		err := cs.mempool.CheckTx(txBytes, nil)
 		if err != nil {
 			panic(fmt.Sprintf("Error after CheckTx: %v", err))
 		}
@@ -147,7 +141,7 @@ func TestMempoolRmBadTx(t *testing.T) {
 		// Try to send the tx through the mempool.
 		// CheckTx should not err, but the app should return a bad abci code
 		// and the tx should get removed from the pool
-		err := assertMempool(cs.txNotifier).CheckTx(txBytes, func(r *abci.Response) {
+		err := cs.mempool.CheckTx(txBytes, func(r *abci.Response) {
 			if r.GetCheckTx().Code != code.CodeTypeBadNonce {
 				t.Fatalf("expected checktx to return bad nonce, got %v", r)
 			}
@@ -159,7 +153,7 @@ func TestMempoolRmBadTx(t *testing.T) {

 		// check for the tx
 		for {
-			txs := assertMempool(cs.txNotifier).ReapMaxBytesMaxGas(int64(len(txBytes)), -1)
+			txs := cs.mempool.ReapMaxBytesMaxGas(int64(len(txBytes)), -1)
 			if len(txs) == 0 {
 				emptyMempoolCh <- struct{}{}
 				return
--- a/consensus/metrics.go
+++ b/consensus/metrics.go
@@ -8,11 +8,7 @@ import (
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
 )

-const (
-	// MetricsSubsystem is a subsystem shared by all metrics exposed by this
-	// package.
-	MetricsSubsystem = "consensus"
-)
+const MetricsSubsystem = "consensus"

 // Metrics contains metrics exposed by this package.
 type Metrics struct {
@@ -54,107 +50,101 @@ type Metrics struct {
 }

 // PrometheusMetrics returns Metrics build using Prometheus client library.
-// Optionally, labels can be provided along with their values ("foo",
-// "fooValue").
-func PrometheusMetrics(namespace string, labelsAndValues ...string) *Metrics {
-	labels := []string{}
-	for i := 0; i < len(labelsAndValues); i += 2 {
-		labels = append(labels, labelsAndValues[i])
-	}
+func PrometheusMetrics(namespace string) *Metrics {
 	return &Metrics{
 		Height: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "height",
 			Help:      "Height of the chain.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),
 		Rounds: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "rounds",
 			Help:      "Number of rounds.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),

 		Validators: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "validators",
 			Help:      "Number of validators.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),
 		ValidatorsPower: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "validators_power",
 			Help:      "Total power of all validators.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),
 		MissingValidators: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "missing_validators",
 			Help:      "Number of validators who did not sign.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),
 		MissingValidatorsPower: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "missing_validators_power",
 			Help:      "Total power of the missing validators.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),
 		ByzantineValidators: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "byzantine_validators",
 			Help:      "Number of validators who tried to double sign.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),
 		ByzantineValidatorsPower: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "byzantine_validators_power",
 			Help:      "Total power of the byzantine validators.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),

 		BlockIntervalSeconds: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "block_interval_seconds",
 			Help:      "Time between this and the last block.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),

 		NumTxs: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "num_txs",
 			Help:      "Number of transactions.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),
 		BlockSizeBytes: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "block_size_bytes",
 			Help:      "Size of the block.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),
 		TotalTxs: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "total_txs",
 			Help:      "Total number of transactions.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),
 		CommittedHeight: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "latest_block_height",
 			Help:      "The latest block height.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),
 		FastSyncing: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "fast_syncing",
 			Help:      "Whether or not a node is fast syncing. 1 if yes, 0 if no.",
-		}, labels).With(labelsAndValues...),
+		}, []string{}),
 		BlockParts: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
 			Namespace: namespace,
 			Subsystem: MetricsSubsystem,
 			Name:      "block_parts",
 			Help:      "Number of blockparts transmitted by peer.",
-		}, append(labels, "peer_id")).With(labelsAndValues...),
+		}, []string{"peer_id"}),
 	}
 }

--- a/consensus/reactor.go
+++ b/consensus/reactor.go
@@ -8,7 +8,7 @@ import (

 	"github.com/pkg/errors"

-	amino "github.com/tendermint/go-amino"
+	"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"
@@ -438,9 +438,9 @@ func (conR *ConsensusReactor) broadcastHasVoteMessage(vote *types.Vote) {

 func makeRoundStepMessage(rs *cstypes.RoundState) (nrsMsg *NewRoundStepMessage) {
 	nrsMsg = &NewRoundStepMessage{
-		Height:                rs.Height,
-		Round:                 rs.Round,
-		Step:                  rs.Step,
+		Height: rs.Height,
+		Round:  rs.Round,
+		Step:   rs.Step,
 		SecondsSinceStartTime: int(time.Since(rs.StartTime).Seconds()),
 		LastCommitRound:       rs.LastCommit.Round(),
 	}
@@ -896,7 +896,7 @@ type PeerState struct {
 	peer   p2p.Peer
 	logger log.Logger

-	mtx   sync.Mutex             // NOTE: Modify below using setters, never directly.
+	mtx   sync.Mutex             `json:"-"`           // NOTE: Modify below using setters, never directly.
 	PRS   cstypes.PeerRoundState `json:"round_state"` // Exposed.
 	Stats *peerStateStats        `json:"stats"`       // Exposed.
 }
--- a/consensus/reactor_test.go
+++ b/consensus/reactor_test.go
@@ -14,7 +14,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"

-	abcicli "github.com/tendermint/tendermint/abci/client"
+	"github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abci "github.com/tendermint/tendermint/abci/types"
 	bc "github.com/tendermint/tendermint/blockchain"
@@ -27,6 +27,10 @@ import (
 	"github.com/tendermint/tendermint/types"
 )

+func init() {
+	config = ResetConfig("consensus_reactor_test")
+}
+
 //----------------------------------------------
 // in-process testnets

@@ -82,8 +86,7 @@ func stopConsensusNet(logger log.Logger, reactors []*ConsensusReactor, eventBuse
 // Ensure a testnet makes blocks
 func TestReactorBasic(t *testing.T) {
 	N := 4
-	css, cleanup := randConsensusNet(N, "consensus_reactor_test", newMockTickerFunc(true), newCounter)
-	defer cleanup()
+	css := randConsensusNet(N, "consensus_reactor_test", newMockTickerFunc(true), newCounter)
 	reactors, eventChans, eventBuses := startConsensusNet(t, css, N)
 	defer stopConsensusNet(log.TestingLogger(), reactors, eventBuses)
 	// wait till everyone makes the first new block
@@ -113,7 +116,6 @@ func TestReactorWithEvidence(t *testing.T) {
 		stateDB := dbm.NewMemDB() // each state needs its own db
 		state, _ := sm.LoadStateFromDBOrGenesisDoc(stateDB, genDoc)
 		thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
-		defer os.RemoveAll(thisConfig.RootDir)
 		ensureDir(path.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
 		app := appFunc()
 		vals := types.TM2PB.ValidatorUpdates(state.Validators)
@@ -209,23 +211,21 @@ func (m *mockEvidencePool) Update(block *types.Block, state sm.State) {
 	}
 	m.height++
 }
-func (m *mockEvidencePool) IsCommitted(types.Evidence) bool { return false }

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

 // Ensure a testnet makes blocks when there are txs
 func TestReactorCreatesBlockWhenEmptyBlocksFalse(t *testing.T) {
 	N := 4
-	css, cleanup := randConsensusNet(N, "consensus_reactor_test", newMockTickerFunc(true), newCounter,
+	css := randConsensusNet(N, "consensus_reactor_test", newMockTickerFunc(true), newCounter,
 		func(c *cfg.Config) {
 			c.Consensus.CreateEmptyBlocks = false
 		})
-	defer cleanup()
 	reactors, eventChans, eventBuses := startConsensusNet(t, css, N)
 	defer stopConsensusNet(log.TestingLogger(), reactors, eventBuses)

 	// send a tx
-	if err := assertMempool(css[3].txNotifier).CheckTx([]byte{1, 2, 3}, nil); err != nil {
+	if err := css[3].mempool.CheckTx([]byte{1, 2, 3}, nil); err != nil {
 		//t.Fatal(err)
 	}

@@ -238,8 +238,7 @@ func TestReactorCreatesBlockWhenEmptyBlocksFalse(t *testing.T) {
 // Test we record stats about votes and block parts from other peers.
 func TestReactorRecordsVotesAndBlockParts(t *testing.T) {
 	N := 4
-	css, cleanup := randConsensusNet(N, "consensus_reactor_test", newMockTickerFunc(true), newCounter)
-	defer cleanup()
+	css := randConsensusNet(N, "consensus_reactor_test", newMockTickerFunc(true), newCounter)
 	reactors, eventChans, eventBuses := startConsensusNet(t, css, N)
 	defer stopConsensusNet(log.TestingLogger(), reactors, eventBuses)

@@ -263,8 +262,7 @@ func TestReactorRecordsVotesAndBlockParts(t *testing.T) {
 func TestReactorVotingPowerChange(t *testing.T) {
 	nVals := 4
 	logger := log.TestingLogger()
-	css, cleanup := randConsensusNet(nVals, "consensus_voting_power_changes_test", newMockTickerFunc(true), newPersistentKVStore)
-	defer cleanup()
+	css := randConsensusNet(nVals, "consensus_voting_power_changes_test", newMockTickerFunc(true), newPersistentKVStore)
 	reactors, eventChans, eventBuses := startConsensusNet(t, css, nVals)
 	defer stopConsensusNet(logger, reactors, eventBuses)

@@ -283,7 +281,9 @@ func TestReactorVotingPowerChange(t *testing.T) {
 	//---------------------------------------------------------------------------
 	logger.Debug("---------------------------- Testing changing the voting power of one validator a few times")

-	val1PubKey := css[0].privValidator.GetPubKey()
+	pubKey := css[0].privValidator.GetPubKey()
+
+	val1PubKey := pubKey
 	val1PubKeyABCI := types.TM2PB.PubKey(val1PubKey)
 	updateValidatorTx := kvstore.MakeValSetChangeTx(val1PubKeyABCI, 25)
 	previousTotalVotingPower := css[0].GetRoundState().LastValidators.TotalVotingPower()
@@ -325,8 +325,8 @@ func TestReactorVotingPowerChange(t *testing.T) {
 func TestReactorValidatorSetChanges(t *testing.T) {
 	nPeers := 7
 	nVals := 4
-	css, cleanup := randConsensusNetWithPeers(nVals, nPeers, "consensus_val_set_changes_test", newMockTickerFunc(true), newPersistentKVStore)
-	defer cleanup()
+	css := randConsensusNetWithPeers(nVals, nPeers, "consensus_val_set_changes_test", newMockTickerFunc(true), newPersistentKVStore)
+
 	logger := log.TestingLogger()

 	reactors, eventChans, eventBuses := startConsensusNet(t, css, nPeers)
@@ -347,7 +347,8 @@ func TestReactorValidatorSetChanges(t *testing.T) {
 	//---------------------------------------------------------------------------
 	logger.Info("---------------------------- Testing adding one validator")

-	newValidatorPubKey1 := css[nVals].privValidator.GetPubKey()
+	pubKey := css[nVals].privValidator.GetPubKey()
+	newValidatorPubKey1 := pubKey
 	valPubKey1ABCI := types.TM2PB.PubKey(newValidatorPubKey1)
 	newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower)

@@ -374,7 +375,8 @@ func TestReactorValidatorSetChanges(t *testing.T) {
 	//---------------------------------------------------------------------------
 	logger.Info("---------------------------- Testing changing the voting power of one validator")

-	updateValidatorPubKey1 := css[nVals].privValidator.GetPubKey()
+	pubKey = css[nVals].privValidator.GetPubKey()
+	updateValidatorPubKey1 := pubKey
 	updatePubKey1ABCI := types.TM2PB.PubKey(updateValidatorPubKey1)
 	updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25)
 	previousTotalVotingPower := css[nVals].GetRoundState().LastValidators.TotalVotingPower()
@@ -391,11 +393,13 @@ func TestReactorValidatorSetChanges(t *testing.T) {
 	//---------------------------------------------------------------------------
 	logger.Info("---------------------------- Testing adding two validators at once")

-	newValidatorPubKey2 := css[nVals+1].privValidator.GetPubKey()
+	pubKey = css[nVals+1].privValidator.GetPubKey()
+	newValidatorPubKey2 := pubKey
 	newVal2ABCI := types.TM2PB.PubKey(newValidatorPubKey2)
 	newValidatorTx2 := kvstore.MakeValSetChangeTx(newVal2ABCI, testMinPower)

-	newValidatorPubKey3 := css[nVals+2].privValidator.GetPubKey()
+	pubKey = css[nVals+2].privValidator.GetPubKey()
+	newValidatorPubKey3 := pubKey
 	newVal3ABCI := types.TM2PB.PubKey(newValidatorPubKey3)
 	newValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, testMinPower)

@@ -423,8 +427,7 @@ func TestReactorValidatorSetChanges(t *testing.T) {
 // Check we can make blocks with skip_timeout_commit=false
 func TestReactorWithTimeoutCommit(t *testing.T) {
 	N := 4
-	css, cleanup := randConsensusNet(N, "consensus_reactor_with_timeout_commit_test", newMockTickerFunc(false), newCounter)
-	defer cleanup()
+	css := randConsensusNet(N, "consensus_reactor_with_timeout_commit_test", newMockTickerFunc(false), newCounter)
 	// override default SkipTimeoutCommit == true for tests
 	for i := 0; i < N; i++ {
 		css[i].config.SkipTimeoutCommit = false
@@ -451,7 +454,7 @@ func waitForAndValidateBlock(t *testing.T, n int, activeVals map[string]struct{}
 		err := validateBlock(newBlock, activeVals)
 		assert.Nil(t, err)
 		for _, tx := range txs {
-			err := assertMempool(css[j].txNotifier).CheckTx(tx, nil)
+			err := css[j].mempool.CheckTx(tx, nil)
 			assert.Nil(t, err)
 		}
 	}, css)
--- a/consensus/replay.go
+++ b/consensus/replay.go
@@ -6,12 +6,12 @@ import (
 	"hash/crc32"
 	"io"
 	"reflect"
-
 	//"strconv"
 	//"strings"
 	"time"

 	abci "github.com/tendermint/tendermint/abci/types"
+	"github.com/tendermint/tendermint/version"
 	//auto "github.com/tendermint/tendermint/libs/autofile"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	dbm "github.com/tendermint/tendermint/libs/db"
@@ -20,7 +20,6 @@ import (
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
-	"github.com/tendermint/tendermint/version"
 )

 var crc32c = crc32.MakeTable(crc32.Castagnoli)
@@ -144,8 +143,8 @@ func (cs *ConsensusState) catchupReplay(csHeight int64) error {
 		if err == io.EOF {
 			break
 		} else if IsDataCorruptionError(err) {
-			cs.Logger.Error("data has been corrupted in last height of consensus WAL", "err", err, "height", csHeight)
-			return err
+			cs.Logger.Debug("data has been corrupted in last height of consensus WAL", "err", err, "height", csHeight)
+			panic(fmt.Sprintf("data has been corrupted (%v) in last height %d of consensus WAL", err, csHeight))
 		} else if err != nil {
 			return err
 		}
@@ -197,7 +196,6 @@ type Handshaker struct {
 	stateDB      dbm.DB
 	initialState sm.State
 	store        sm.BlockStore
-	eventBus     types.BlockEventPublisher
 	genDoc       *types.GenesisDoc
 	logger       log.Logger

@@ -211,7 +209,6 @@ func NewHandshaker(stateDB dbm.DB, state sm.State,
 		stateDB:      stateDB,
 		initialState: state,
 		store:        store,
-		eventBus:     types.NopEventBus{},
 		genDoc:       genDoc,
 		logger:       log.NewNopLogger(),
 		nBlocks:      0,
@@ -222,12 +219,6 @@ func (h *Handshaker) SetLogger(l log.Logger) {
 	h.logger = l
 }

-// SetEventBus - sets the event bus for publishing block related events.
-// If not called, it defaults to types.NopEventBus.
-func (h *Handshaker) SetEventBus(eventBus types.BlockEventPublisher) {
-	h.eventBus = eventBus
-}
-
 func (h *Handshaker) NBlocks() int {
 	return h.nBlocks
 }
@@ -256,7 +247,6 @@ func (h *Handshaker) Handshake(proxyApp proxy.AppConns) error {

 	// Set AppVersion on the state.
 	h.initialState.Version.Consensus.App = version.Protocol(res.AppVersion)
-	sm.SaveState(h.stateDB, h.initialState)

 	// Replay blocks up to the latest in the blockstore.
 	_, err = h.ReplayBlocks(h.initialState, appHash, blockHeight, proxyApp)
@@ -305,27 +295,25 @@ func (h *Handshaker) ReplayBlocks(
 			return nil, err
 		}

-		if stateBlockHeight == 0 { //we only update state when we are in initial state
-			// If the app returned validators or consensus params, update the state.
-			if len(res.Validators) > 0 {
-				vals, err := types.PB2TM.ValidatorUpdates(res.Validators)
-				if err != nil {
-					return nil, err
-				}
-				state.Validators = types.NewValidatorSet(vals)
-				state.NextValidators = types.NewValidatorSet(vals)
-			} else {
-				// If validator set is not set in genesis and still empty after InitChain, exit.
-				if len(h.genDoc.Validators) == 0 {
-					return nil, fmt.Errorf("Validator set is nil in genesis and still empty after InitChain")
-				}
+		// If the app returned validators or consensus params, update the state.
+		if len(res.Validators) > 0 {
+			vals, err := types.PB2TM.ValidatorUpdates(res.Validators)
+			if err != nil {
+				return nil, err
 			}
-
-			if res.ConsensusParams != nil {
-				state.ConsensusParams = types.PB2TM.ConsensusParams(res.ConsensusParams)
+			state.Validators = types.NewValidatorSet(vals)
+			state.NextValidators = types.NewValidatorSet(vals)
+		} else {
+			// If validator set is not set in genesis and still empty after InitChain, exit.
+			if len(h.genDoc.Validators) == 0 {
+				return nil, fmt.Errorf("Validator set is nil in genesis and still empty after InitChain")
 			}
-			sm.SaveState(h.stateDB, state)
 		}
+		
+		if res.ConsensusParams != nil {
+			state.ConsensusParams = types.PB2TM.ConsensusParams(res.ConsensusParams)
+		}
+		sm.SaveState(h.stateDB, state)
 	}

 	// First handle edge cases and constraints on the storeBlockHeight.
@@ -334,7 +322,7 @@ func (h *Handshaker) ReplayBlocks(

 	} else if storeBlockHeight < appBlockHeight {
 		// the app should never be ahead of the store (but this is under app's control)
-		return appHash, sm.ErrAppBlockHeightTooHigh{CoreHeight: storeBlockHeight, AppHeight: appBlockHeight}
+		return appHash, sm.ErrAppBlockHeightTooHigh{storeBlockHeight, appBlockHeight}

 	} else if storeBlockHeight < stateBlockHeight {
 		// the state should never be ahead of the store (this is under tendermint's control)
@@ -441,7 +429,6 @@ func (h *Handshaker) replayBlock(state sm.State, height int64, proxyApp proxy.Ap
 	meta := h.store.LoadBlockMeta(height)

 	blockExec := sm.NewBlockExecutor(h.stateDB, h.logger, proxyApp, sm.MockMempool{}, sm.MockEvidencePool{})
-	blockExec.SetEventBus(h.eventBus)

 	var err error
 	state, err = blockExec.ApplyBlock(state, meta.BlockID, block)
--- a/consensus/replay_file.go
+++ b/consensus/replay_file.go
@@ -103,6 +103,7 @@ func (cs *ConsensusState) ReplayFile(file string, console bool) error {
 		}
 		pb.count++
 	}
+	return nil
 }

 //------------------------------------------------
@@ -136,7 +137,7 @@ func (pb *playback) replayReset(count int, newStepCh chan interface{}) error {
 	pb.cs.Wait()

 	newCS := NewConsensusState(pb.cs.config, pb.genesisState.Copy(), pb.cs.blockExec,
-		pb.cs.blockStore, pb.cs.txNotifier, pb.cs.evpool)
+		pb.cs.blockStore, pb.cs.mempool, pb.cs.evpool)
 	newCS.SetEventBus(pb.cs.eventBus)
 	newCS.startForReplay()

@@ -294,6 +295,7 @@ func (pb *playback) replayConsoleLoop() int {
 			fmt.Println(pb.count)
 		}
 	}
+	return 0
 }

 //--------------------------------------------------------------------------------
@@ -324,18 +326,17 @@ func newConsensusStateForReplay(config cfg.BaseConfig, csConfig *cfg.ConsensusCo
 		cmn.Exit(fmt.Sprintf("Error starting proxy app conns: %v", err))
 	}

-	eventBus := types.NewEventBus()
-	if err := eventBus.Start(); err != nil {
-		cmn.Exit(fmt.Sprintf("Failed to start event bus: %v", err))
-	}
-
 	handshaker := NewHandshaker(stateDB, state, blockStore, gdoc)
-	handshaker.SetEventBus(eventBus)
 	err = handshaker.Handshake(proxyApp)
 	if err != nil {
 		cmn.Exit(fmt.Sprintf("Error on handshake: %v", err))
 	}

+	eventBus := types.NewEventBus()
+	if err := eventBus.Start(); err != nil {
+		cmn.Exit(fmt.Sprintf("Failed to start event bus: %v", err))
+	}
+
 	mempool, evpool := sm.MockMempool{}, sm.MockEvidencePool{}
 	blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(), proxyApp.Consensus(), mempool, evpool)

--- a/consensus/replay_test.go
+++ b/consensus/replay_test.go
@@ -17,31 +17,23 @@ import (

 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abci "github.com/tendermint/tendermint/abci/types"
-	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
 	auto "github.com/tendermint/tendermint/libs/autofile"
 	dbm "github.com/tendermint/tendermint/libs/db"
+	"github.com/tendermint/tendermint/version"
+
+	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/privval"
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
-	"github.com/tendermint/tendermint/version"
 )

-func TestMain(m *testing.M) {
-	config = ResetConfig("consensus_reactor_test")
+var consensusReplayConfig *cfg.Config
+
+func init() {
 	consensusReplayConfig = ResetConfig("consensus_replay_test")
-	configStateTest := ResetConfig("consensus_state_test")
-	configMempoolTest := ResetConfig("consensus_mempool_test")
-	configByzantineTest := ResetConfig("consensus_byzantine_test")
-	code := m.Run()
-	os.RemoveAll(config.RootDir)
-	os.RemoveAll(consensusReplayConfig.RootDir)
-	os.RemoveAll(configStateTest.RootDir)
-	os.RemoveAll(configMempoolTest.RootDir)
-	os.RemoveAll(configByzantineTest.RootDir)
-	os.Exit(code)
 }

 // These tests ensure we can always recover from failure at any part of the consensus process.
@@ -59,8 +51,7 @@ func TestMain(m *testing.M) {
 // and which ones we need the wal for - then we'd also be able to only flush the
 // wal writer when we need to, instead of with every message.

-func startNewConsensusStateAndWaitForBlock(t *testing.T, consensusReplayConfig *cfg.Config,
-	lastBlockHeight int64, blockDB dbm.DB, stateDB dbm.DB) {
+func startNewConsensusStateAndWaitForBlock(t *testing.T, lastBlockHeight int64, blockDB dbm.DB, stateDB dbm.DB) {
 	logger := log.TestingLogger()
 	state, _ := sm.LoadStateFromDBOrGenesisFile(stateDB, consensusReplayConfig.GenesisFile())
 	privValidator := loadPrivValidator(consensusReplayConfig)
@@ -68,6 +59,7 @@ func startNewConsensusStateAndWaitForBlock(t *testing.T, consensusReplayConfig *
 	cs.SetLogger(logger)

 	bytes, _ := ioutil.ReadFile(cs.config.WalFile())
+	// fmt.Printf("====== WAL: \n\r%s\n", bytes)
 	t.Logf("====== WAL: \n\r%X\n", bytes)

 	err := cs.Start()
@@ -95,7 +87,7 @@ func sendTxs(cs *ConsensusState, ctx context.Context) {
 			return
 		default:
 			tx := []byte{byte(i)}
-			assertMempool(cs.txNotifier).CheckTx(tx, nil)
+			cs.mempool.CheckTx(tx, nil)
 			i++
 		}
 	}
@@ -118,22 +110,21 @@ func TestWALCrash(t *testing.T) {
 			3},
 	}

-	for i, tc := range testCases {
-		consensusReplayConfig := ResetConfig(fmt.Sprintf("%s_%d", t.Name(), i))
+	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			crashWALandCheckLiveness(t, consensusReplayConfig, tc.initFn, tc.heightToStop)
+			crashWALandCheckLiveness(t, tc.initFn, tc.heightToStop)
 		})
 	}
 }

-func crashWALandCheckLiveness(t *testing.T, consensusReplayConfig *cfg.Config,
-	initFn func(dbm.DB, *ConsensusState, context.Context), heightToStop int64) {
+func crashWALandCheckLiveness(t *testing.T, initFn func(dbm.DB, *ConsensusState, context.Context), heightToStop int64) {
 	walPaniced := make(chan error)
 	crashingWal := &crashingWAL{panicCh: walPaniced, heightToStop: heightToStop}

 	i := 1
 LOOP:
 	for {
+		// fmt.Printf("====== LOOP %d\n", i)
 		t.Logf("====== LOOP %d\n", i)

 		// create consensus state from a clean slate
@@ -172,7 +163,7 @@ LOOP:
 			t.Logf("WAL paniced: %v", err)

 			// make sure we can make blocks after a crash
-			startNewConsensusStateAndWaitForBlock(t, consensusReplayConfig, cs.Height, blockDB, stateDB)
+			startNewConsensusStateAndWaitForBlock(t, cs.Height, blockDB, stateDB)

 			// stop consensus state and transactions sender (initFn)
 			cs.Stop()
@@ -278,37 +269,29 @@ var modes = []uint{0, 1, 2}

 // Sync from scratch
 func TestHandshakeReplayAll(t *testing.T) {
-	for i, m := range modes {
-		config := ResetConfig(fmt.Sprintf("%s_%v", t.Name(), i))
-		defer os.RemoveAll(config.RootDir)
-		testHandshakeReplay(t, config, 0, m)
+	for _, m := range modes {
+		testHandshakeReplay(t, 0, m)
 	}
 }

 // Sync many, not from scratch
 func TestHandshakeReplaySome(t *testing.T) {
-	for i, m := range modes {
-		config := ResetConfig(fmt.Sprintf("%s_%v", t.Name(), i))
-		defer os.RemoveAll(config.RootDir)
-		testHandshakeReplay(t, config, 1, m)
+	for _, m := range modes {
+		testHandshakeReplay(t, 1, m)
 	}
 }

 // Sync from lagging by one
 func TestHandshakeReplayOne(t *testing.T) {
-	for i, m := range modes {
-		config := ResetConfig(fmt.Sprintf("%s_%v", t.Name(), i))
-		defer os.RemoveAll(config.RootDir)
-		testHandshakeReplay(t, config, NUM_BLOCKS-1, m)
+	for _, m := range modes {
+		testHandshakeReplay(t, NUM_BLOCKS-1, m)
 	}
 }

 // Sync from caught up
 func TestHandshakeReplayNone(t *testing.T) {
-	for i, m := range modes {
-		config := ResetConfig(fmt.Sprintf("%s_%v", t.Name(), i))
-		defer os.RemoveAll(config.RootDir)
-		testHandshakeReplay(t, config, NUM_BLOCKS, m)
+	for _, m := range modes {
+		testHandshakeReplay(t, NUM_BLOCKS, m)
 	}
 }

@@ -328,13 +311,15 @@ func tempWALWithData(data []byte) string {
 }

 // Make some blocks. Start a fresh app and apply nBlocks blocks. Then restart the app and sync it up with the remaining blocks
-func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uint) {
-	walBody, err := WALWithNBlocks(t, NUM_BLOCKS)
+func testHandshakeReplay(t *testing.T, nBlocks int, mode uint) {
+	config := ResetConfig("proxy_test_")
+
+	walBody, err := WALWithNBlocks(NUM_BLOCKS)
 	require.NoError(t, err)
 	walFile := tempWALWithData(walBody)
 	config.Consensus.SetWalFile(walFile)

-	privVal := privval.LoadFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile())
+	privVal := privval.LoadFilePV(config.PrivValidatorFile())

 	wal, err := NewWAL(walFile)
 	require.NoError(t, err)
@@ -346,7 +331,9 @@ func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uin
 	chain, commits, err := makeBlockchainFromWAL(wal)
 	require.NoError(t, err)

-	stateDB, state, store := stateAndStore(config, privVal.GetPubKey(), kvstore.ProtocolVersion)
+	pubKey := privVal.GetPubKey()
+	require.NoError(t, err)
+	stateDB, state, store := stateAndStore(config, pubKey, kvstore.ProtocolVersion)
 	store.chain = chain
 	store.commits = commits

@@ -361,7 +348,7 @@ func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uin
 		// run nBlocks against a new client to build up the app state.
 		// use a throwaway tendermint state
 		proxyApp := proxy.NewAppConns(clientCreator2)
-		stateDB, state, _ := stateAndStore(config, privVal.GetPubKey(), kvstore.ProtocolVersion)
+		stateDB, state, _ := stateAndStore(config, pubKey, kvstore.ProtocolVersion)
 		buildAppStateFromChain(proxyApp, stateDB, state, chain, nBlocks, mode)
 	}

@@ -552,8 +539,10 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
 			}
 		case *types.Vote:
 			if p.Type == types.PrecommitType {
-				commitSigs := []*types.CommitSig{p.CommitSig()}
-				thisBlockCommit = types.NewCommit(p.BlockID, commitSigs)
+				thisBlockCommit = &types.Commit{
+					BlockID:    p.BlockID,
+					Precommits: []*types.Vote{p},
+				}
 			}
 		}
 	}
@@ -646,9 +635,9 @@ func TestInitChainUpdateValidators(t *testing.T) {
 	clientCreator := proxy.NewLocalClientCreator(app)

 	config := ResetConfig("proxy_test_")
-	defer os.RemoveAll(config.RootDir)
-	privVal := privval.LoadFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile())
-	stateDB, state, store := stateAndStore(config, privVal.GetPubKey(), 0x0)
+	privVal := privval.LoadFilePV(config.PrivValidatorFile())
+	pubKey := privVal.GetPubKey()
+	stateDB, state, store := stateAndStore(config, pubKey, 0x0)

 	oldValAddr := state.Validators.Validators[0].Address

--- a/consensus/state.go
+++ b/consensus/state.go
@@ -57,16 +57,6 @@ func (ti *timeoutInfo) String() string {
 	return fmt.Sprintf("%v ; %d/%d %v", ti.Duration, ti.Height, ti.Round, ti.Step)
 }

-// interface to the mempool
-type txNotifier interface {
-	TxsAvailable() <-chan struct{}
-}
-
-// interface to the evidence pool
-type evidencePool interface {
-	AddEvidence(types.Evidence) error
-}
-
 // ConsensusState handles execution of the consensus algorithm.
 // It processes votes and proposals, and upon reaching agreement,
 // commits blocks to the chain and executes them against the application.
@@ -78,23 +68,17 @@ type ConsensusState struct {
 	config        *cfg.ConsensusConfig
 	privValidator types.PrivValidator // for signing votes

-	// store blocks and commits
+	// services for creating and executing blocks
+	blockExec  *sm.BlockExecutor
 	blockStore sm.BlockStore
-
-	// create and execute blocks
-	blockExec *sm.BlockExecutor
-
-	// notify us if txs are available
-	txNotifier txNotifier
-
-	// add evidence to the pool
-	// when it's detected
-	evpool evidencePool
+	mempool    sm.Mempool
+	evpool     sm.EvidencePool

 	// internal state
 	mtx sync.RWMutex
 	cstypes.RoundState
-	state sm.State // State until height-1.
+	triggeredTimeoutPrecommit bool
+	state                     sm.State // State until height-1.

 	// state changes may be triggered by: msgs from peers,
 	// msgs from ourself, or by timeouts
@@ -144,15 +128,15 @@ func NewConsensusState(
 	state sm.State,
 	blockExec *sm.BlockExecutor,
 	blockStore sm.BlockStore,
-	txNotifier txNotifier,
-	evpool evidencePool,
+	mempool sm.Mempool,
+	evpool sm.EvidencePool,
 	options ...StateOption,
 ) *ConsensusState {
 	cs := &ConsensusState{
 		config:           config,
 		blockExec:        blockExec,
 		blockStore:       blockStore,
-		txNotifier:       txNotifier,
+		mempool:          mempool,
 		peerMsgQueue:     make(chan msgInfo, msgQueueSize),
 		internalMsgQueue: make(chan msgInfo, msgQueueSize),
 		timeoutTicker:    NewTimeoutTicker(),
@@ -307,23 +291,6 @@ func (cs *ConsensusState) OnStart() error {
 	// reload from consensus log to catchup
 	if cs.doWALCatchup {
 		if err := cs.catchupReplay(cs.Height); err != nil {
-			// don't try to recover from data corruption error
-			if IsDataCorruptionError(err) {
-				cs.Logger.Error("Encountered corrupt WAL file", "err", err.Error())
-				cs.Logger.Error("Please repair the WAL file before restarting")
-				fmt.Println(`You can attempt to repair the WAL as follows:
-
----
-WALFILE=~/.tendermint/data/cs.wal/wal
-cp $WALFILE ${WALFILE}.bak # backup the file
-go run scripts/wal2json/main.go $WALFILE > wal.json # this will panic, but can be ignored
-rm $WALFILE # remove the corrupt file
-go run scripts/json2wal/main.go wal.json $WALFILE # rebuild the file without corruption
----`)
-
-				return err
-			}
-
 			cs.Logger.Error("Error on catchup replay. Proceeding to start ConsensusState anyway", "err", err.Error())
 			// NOTE: if we ever do return an error here,
 			// make sure to stop the timeoutTicker
@@ -454,7 +421,7 @@ func (cs *ConsensusState) updateRoundStep(round int, step cstypes.RoundStepType)
 // enterNewRound(height, 0) at cs.StartTime.
 func (cs *ConsensusState) scheduleRound0(rs *cstypes.RoundState) {
 	//cs.Logger.Info("scheduleRound0", "now", tmtime.Now(), "startTime", cs.StartTime)
-	sleepDuration := rs.StartTime.Sub(tmtime.Now())
+	sleepDuration := rs.StartTime.Sub(tmtime.Now()) // nolint: gotype, gosimple
 	cs.scheduleTimeout(sleepDuration, rs.Height, 0, cstypes.RoundStepNewHeight)
 }

@@ -489,7 +456,7 @@ func (cs *ConsensusState) reconstructLastCommit(state sm.State) {
 		if precommit == nil {
 			continue
 		}
-		added, err := lastPrecommits.AddVote(seenCommit.ToVote(precommit))
+		added, err := lastPrecommits.AddVote(precommit)
 		if !added || err != nil {
 			cmn.PanicCrisis(fmt.Sprintf("Failed to reconstruct LastCommit: %v", err))
 		}
@@ -517,7 +484,7 @@ func (cs *ConsensusState) updateToState(state sm.State) {
 	// If state isn't further out than cs.state, just ignore.
 	// This happens when SwitchToConsensus() is called in the reactor.
 	// We don't want to reset e.g. the Votes, but we still want to
-	// signal the new round step, because other services (eg. txNotifier)
+	// signal the new round step, because other services (eg. mempool)
 	// depend on having an up-to-date peer state!
 	if !cs.state.IsEmpty() && (state.LastBlockHeight <= cs.state.LastBlockHeight) {
 		cs.Logger.Info("Ignoring updateToState()", "newHeight", state.LastBlockHeight+1, "oldHeight", cs.state.LastBlockHeight+1)
@@ -566,7 +533,6 @@ func (cs *ConsensusState) updateToState(state sm.State) {
 	cs.CommitRound = -1
 	cs.LastCommit = lastPrecommits
 	cs.LastValidators = state.LastValidators
-	cs.TriggeredTimeoutPrecommit = false

 	cs.state = state

@@ -633,7 +599,7 @@ func (cs *ConsensusState) receiveRoutine(maxSteps int) {
 		var mi msgInfo

 		select {
-		case <-cs.txNotifier.TxsAvailable():
+		case <-cs.mempool.TxsAvailable():
 			cs.handleTxsAvailable()
 		case mi = <-cs.peerMsgQueue:
 			cs.wal.Write(mi)
@@ -642,15 +608,6 @@ func (cs *ConsensusState) receiveRoutine(maxSteps int) {
 			cs.handleMsg(mi)
 		case mi = <-cs.internalMsgQueue:
 			cs.wal.WriteSync(mi) // NOTE: fsync
-
-			if _, ok := mi.Msg.(*VoteMessage); ok {
-				// we actually want to simulate failing during
-				// the previous WriteSync, but this isn't easy to do.
-				// Equivalent would be to fail here and manually remove
-				// some bytes from the end of the wal.
-				fail.Fail() // XXX
-			}
-
 			// handles proposals, block parts, votes
 			cs.handleMsg(mi)
 		case ti := <-cs.timeoutTicker.Chan(): // tockChan:
@@ -758,7 +715,6 @@ func (cs *ConsensusState) handleTxsAvailable() {
 	cs.mtx.Lock()
 	defer cs.mtx.Unlock()
 	// we only need to do this for round 0
-	cs.enterNewRound(cs.Height, 0)
 	cs.enterPropose(cs.Height, 0)
 }

@@ -809,7 +765,7 @@ func (cs *ConsensusState) enterNewRound(height int64, round int) {
 		cs.ProposalBlockParts = nil
 	}
 	cs.Votes.SetRound(round + 1) // also track next round (round+1) to allow round-skipping
-	cs.TriggeredTimeoutPrecommit = false
+	cs.triggeredTimeoutPrecommit = false

 	cs.eventBus.PublishEventNewRound(cs.NewRoundEvent())
 	cs.metrics.Rounds.Set(float64(round))
@@ -910,7 +866,7 @@ func (cs *ConsensusState) defaultDecideProposal(height int64, round int) {
 	}

 	// Make proposal
-	propBlockId := types.BlockID{Hash: block.Hash(), PartsHeader: blockParts.Header()}
+	propBlockId := types.BlockID{block.Hash(), blockParts.Header()}
 	proposal := types.NewProposal(height, round, cs.ValidRound, propBlockId)
 	if err := cs.privValidator.SignProposal(cs.state.ChainID, proposal); err == nil {

@@ -955,7 +911,7 @@ func (cs *ConsensusState) createProposalBlock() (block *types.Block, blockParts
 	if cs.Height == 1 {
 		// We're creating a proposal for the first block.
 		// The commit is empty, but not nil.
-		commit = types.NewCommit(types.BlockID{}, nil)
+		commit = &types.Commit{}
 	} else if cs.LastCommit.HasTwoThirdsMajority() {
 		// Make the commit from LastCommit
 		commit = cs.LastCommit.MakeCommit()
@@ -965,8 +921,20 @@ func (cs *ConsensusState) createProposalBlock() (block *types.Block, blockParts
 		return
 	}

+	maxBytes := cs.state.ConsensusParams.BlockSize.MaxBytes
+	maxGas := cs.state.ConsensusParams.BlockSize.MaxGas
+	// bound evidence to 1/10th of the block
+	evidence := cs.evpool.PendingEvidence(types.MaxEvidenceBytesPerBlock(maxBytes))
+	// Mempool validated transactions
+	txs := cs.mempool.ReapMaxBytesMaxGas(types.MaxDataBytes(
+		maxBytes,
+		cs.state.Validators.Size(),
+		len(evidence),
+	), maxGas)
 	proposerAddr := cs.privValidator.GetPubKey().Address()
-	return cs.blockExec.CreateProposalBlock(cs.Height, cs.state, commit, proposerAddr)
+	block, parts := cs.state.MakeBlock(cs.Height, txs, commit, evidence, proposerAddr)
+
+	return block, parts
 }

 // Enter: `timeoutPropose` after entering Propose.
@@ -1155,12 +1123,12 @@ func (cs *ConsensusState) enterPrecommit(height int64, round int) {
 func (cs *ConsensusState) enterPrecommitWait(height int64, round int) {
 	logger := cs.Logger.With("height", height, "round", round)

-	if cs.Height != height || round < cs.Round || (cs.Round == round && cs.TriggeredTimeoutPrecommit) {
+	if cs.Height != height || round < cs.Round || (cs.Round == round && cs.triggeredTimeoutPrecommit) {
 		logger.Debug(
 			fmt.Sprintf(
 				"enterPrecommitWait(%v/%v): Invalid args. "+
-					"Current state is Height/Round: %v/%v/, TriggeredTimeoutPrecommit:%v",
-				height, round, cs.Height, cs.Round, cs.TriggeredTimeoutPrecommit))
+					"Current state is Height/Round: %v/%v/, triggeredTimeoutPrecommit:%v",
+				height, round, cs.Height, cs.Round, cs.triggeredTimeoutPrecommit))
 		return
 	}
 	if !cs.Votes.Precommits(round).HasTwoThirdsAny() {
@@ -1170,7 +1138,7 @@ func (cs *ConsensusState) enterPrecommitWait(height int64, round int) {

 	defer func() {
 		// Done enterPrecommitWait:
-		cs.TriggeredTimeoutPrecommit = true
+		cs.triggeredTimeoutPrecommit = true
 		cs.newStep()
 	}()

@@ -1321,7 +1289,7 @@ func (cs *ConsensusState) finalizeCommit(height int64) {
 	// Execute and commit the block, update and save the state, and update the mempool.
 	// NOTE The block.AppHash wont reflect these txs until the next block.
 	var err error
-	stateCopy, err = cs.blockExec.ApplyBlock(stateCopy, types.BlockID{Hash: block.Hash(), PartsHeader: blockParts.Header()}, block)
+	stateCopy, err = cs.blockExec.ApplyBlock(stateCopy, types.BlockID{block.Hash(), blockParts.Header()}, block)
 	if err != nil {
 		cs.Logger.Error("Error on ApplyBlock. Did the application crash? Please restart tendermint", "err", err)
 		err := cmn.Kill()
@@ -1357,7 +1325,7 @@ func (cs *ConsensusState) recordMetrics(height int64, block *types.Block) {
 	missingValidators := 0
 	missingValidatorsPower := int64(0)
 	for i, val := range cs.Validators.Validators {
-		var vote *types.CommitSig
+		var vote *types.Vote
 		if i < len(block.LastCommit.Precommits) {
 			vote = block.LastCommit.Precommits[i]
 		}
@@ -1544,7 +1512,7 @@ func (cs *ConsensusState) addVote(vote *types.Vote, peerID p2p.ID) (added bool,
 		}

 		cs.Logger.Info(fmt.Sprintf("Added to lastPrecommits: %v", cs.LastCommit.StringShort()))
-		cs.eventBus.PublishEventVote(types.EventDataVote{Vote: vote})
+		cs.eventBus.PublishEventVote(types.EventDataVote{vote})
 		cs.evsw.FireEvent(types.EventVote, vote)

 		// if we can skip timeoutCommit and have all the votes now,
@@ -1561,7 +1529,7 @@ func (cs *ConsensusState) addVote(vote *types.Vote, peerID p2p.ID) (added bool,
 	// Not necessarily a bad peer, but not favourable behaviour.
 	if vote.Height != cs.Height {
 		err = ErrVoteHeightMismatch
-		cs.Logger.Info("Vote ignored and not added", "voteHeight", vote.Height, "csHeight", cs.Height, "peerID", peerID)
+		cs.Logger.Info("Vote ignored and not added", "voteHeight", vote.Height, "csHeight", cs.Height, "err", err)
 		return
 	}

@@ -1572,7 +1540,7 @@ func (cs *ConsensusState) addVote(vote *types.Vote, peerID p2p.ID) (added bool,
 		return
 	}

-	cs.eventBus.PublishEventVote(types.EventDataVote{Vote: vote})
+	cs.eventBus.PublishEventVote(types.EventDataVote{vote})
 	cs.evsw.FireEvent(types.EventVote, vote)

 	switch vote.Type {
@@ -1684,7 +1652,7 @@ func (cs *ConsensusState) signVote(type_ types.SignedMsgType, hash []byte, heade
 		Round:            cs.Round,
 		Timestamp:        cs.voteTime(),
 		Type:             type_,
-		BlockID:          types.BlockID{Hash: hash, PartsHeader: header},
+		BlockID:          types.BlockID{hash, header},
 	}
 	err := cs.privValidator.SignVote(cs.state.ChainID, vote)
 	return vote, err
@@ -1710,7 +1678,8 @@ func (cs *ConsensusState) voteTime() time.Time {
 // sign the vote and publish on internalMsgQueue
 func (cs *ConsensusState) signAddVote(type_ types.SignedMsgType, hash []byte, header types.PartSetHeader) *types.Vote {
 	// if we don't have a key or we're not in the validator set, do nothing
-	if cs.privValidator == nil || !cs.Validators.HasAddress(cs.privValidator.GetPubKey().Address()) {
+	privValAddr := cs.privValidator.GetPubKey().Address()
+	if cs.privValidator == nil || !cs.Validators.HasAddress(privValAddr) {
 		return nil
 	}
 	vote, err := cs.signVote(type_, hash, header)
--- a/consensus/state_test.go
+++ b/consensus/state_test.go
@@ -14,10 +14,18 @@ import (
 	cmn "github.com/tendermint/tendermint/libs/common"
 	"github.com/tendermint/tendermint/libs/log"
 	tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
-	p2pmock "github.com/tendermint/tendermint/p2p/mock"
+	p2pdummy "github.com/tendermint/tendermint/p2p/dummy"
 	"github.com/tendermint/tendermint/types"
 )

+func init() {
+	config = ResetConfig("consensus_state_test")
+}
+
+func ensureProposeTimeout(timeoutPropose time.Duration) time.Duration {
+	return time.Duration(timeoutPropose.Nanoseconds()*2) * time.Nanosecond
+}
+
 /*

 ProposeSuite
@@ -1271,130 +1279,6 @@ func TestCommitFromPreviousRound(t *testing.T) {
 	ensureNewRound(newRoundCh, height+1, 0)
 }

-type fakeTxNotifier struct {
-	ch chan struct{}
-}
-
-func (n *fakeTxNotifier) TxsAvailable() <-chan struct{} {
-	return n.ch
-}
-
-func (n *fakeTxNotifier) Notify() {
-	n.ch <- struct{}{}
-}
-
-func TestStartNextHeightCorrectly(t *testing.T) {
-	config.Consensus.SkipTimeoutCommit = false
-	cs1, vss := randConsensusState(4)
-	cs1.txNotifier = &fakeTxNotifier{ch: make(chan struct{})}
-
-	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
-	height, round := cs1.Height, cs1.Round
-
-	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
-	timeoutProposeCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose)
-
-	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	newBlockHeader := subscribe(cs1.eventBus, types.EventQueryNewBlockHeader)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
-
-	// start round and wait for propose and prevote
-	startTestRound(cs1, height, round)
-	ensureNewRound(newRoundCh, height, round)
-
-	ensureNewProposal(proposalCh, height, round)
-	rs := cs1.GetRoundState()
-	theBlockHash := rs.ProposalBlock.Hash()
-	theBlockParts := rs.ProposalBlockParts.Header()
-
-	ensurePrevote(voteCh, height, round)
-	validatePrevote(t, cs1, round, vss[0], theBlockHash)
-
-	signAddVotes(cs1, types.PrevoteType, theBlockHash, theBlockParts, vs2, vs3, vs4)
-
-	ensurePrecommit(voteCh, height, round)
-	// the proposed block should now be locked and our precommit added
-	validatePrecommit(t, cs1, round, round, vss[0], theBlockHash, theBlockHash)
-
-	rs = cs1.GetRoundState()
-
-	// add precommits
-	signAddVotes(cs1, types.PrecommitType, nil, types.PartSetHeader{}, vs2)
-	signAddVotes(cs1, types.PrecommitType, theBlockHash, theBlockParts, vs3)
-	time.Sleep(5 * time.Millisecond)
-	signAddVotes(cs1, types.PrecommitType, theBlockHash, theBlockParts, vs4)
-
-	rs = cs1.GetRoundState()
-	assert.True(t, rs.TriggeredTimeoutPrecommit)
-
-	ensureNewBlockHeader(newBlockHeader, height, theBlockHash)
-
-	cs1.txNotifier.(*fakeTxNotifier).Notify()
-
-	ensureNewTimeout(timeoutProposeCh, height+1, round, cs1.config.TimeoutPropose.Nanoseconds())
-	rs = cs1.GetRoundState()
-	assert.False(t, rs.TriggeredTimeoutPrecommit, "triggeredTimeoutPrecommit should be false at the beginning of each round")
-}
-
-func TestResetTimeoutPrecommitUponNewHeight(t *testing.T) {
-	config.Consensus.SkipTimeoutCommit = false
-	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)
-
-	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	newBlockHeader := subscribe(cs1.eventBus, types.EventQueryNewBlockHeader)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
-
-	// start round and wait for propose and prevote
-	startTestRound(cs1, height, round)
-	ensureNewRound(newRoundCh, height, round)
-
-	ensureNewProposal(proposalCh, height, round)
-	rs := cs1.GetRoundState()
-	theBlockHash := rs.ProposalBlock.Hash()
-	theBlockParts := rs.ProposalBlockParts.Header()
-
-	ensurePrevote(voteCh, height, round)
-	validatePrevote(t, cs1, round, vss[0], theBlockHash)
-
-	signAddVotes(cs1, types.PrevoteType, theBlockHash, theBlockParts, vs2, vs3, vs4)
-
-	ensurePrecommit(voteCh, height, round)
-	validatePrecommit(t, cs1, round, round, vss[0], theBlockHash, theBlockHash)
-
-	rs = cs1.GetRoundState()
-
-	// add precommits
-	signAddVotes(cs1, types.PrecommitType, nil, types.PartSetHeader{}, vs2)
-	signAddVotes(cs1, types.PrecommitType, theBlockHash, theBlockParts, vs3)
-	time.Sleep(5 * time.Millisecond)
-	signAddVotes(cs1, types.PrecommitType, theBlockHash, theBlockParts, vs4)
-
-	rs = cs1.GetRoundState()
-	assert.True(t, rs.TriggeredTimeoutPrecommit)
-
-	ensureNewBlockHeader(newBlockHeader, height, theBlockHash)
-
-	prop, propBlock := decideProposal(cs1, vs2, height+1, 0)
-	propBlockParts := propBlock.MakePartSet(partSize)
-
-	if err := cs1.SetProposalAndBlock(prop, propBlock, propBlockParts, "some peer"); err != nil {
-		t.Fatal(err)
-	}
-	ensureNewProposal(proposalCh, height+1, 0)
-
-	rs = cs1.GetRoundState()
-	assert.False(t, rs.TriggeredTimeoutPrecommit, "triggeredTimeoutPrecommit should be false at the beginning of each height")
-}
-
 //------------------------------------------------------------------------------------------
 // SlashingSuite
 // TODO: Slashing
@@ -1548,7 +1432,7 @@ func TestStateHalt1(t *testing.T) {
 func TestStateOutputsBlockPartsStats(t *testing.T) {
 	// create dummy peer
 	cs, _ := randConsensusState(1)
-	peer := p2pmock.NewPeer(nil)
+	peer := p2pdummy.NewPeer()

 	// 1) new block part
 	parts := types.NewPartSetFromData(cmn.RandBytes(100), 10)
@@ -1591,7 +1475,7 @@ func TestStateOutputsBlockPartsStats(t *testing.T) {
 func TestStateOutputVoteStats(t *testing.T) {
 	cs, vss := randConsensusState(2)
 	// create dummy peer
-	peer := p2pmock.NewPeer(nil)
+	peer := p2pdummy.NewPeer()

 	vote := signVote(vss[1], types.PrecommitType, []byte("test"), types.PartSetHeader{})

--- a/consensus/types/height_vote_set_test.go
+++ b/consensus/types/height_vote_set_test.go
@@ -2,7 +2,6 @@ package types

 import (
 	"fmt"
-	"os"
 	"testing"

 	cfg "github.com/tendermint/tendermint/config"
@@ -12,11 +11,8 @@ import (

 var config *cfg.Config // NOTE: must be reset for each _test.go file

-func TestMain(m *testing.M) {
+func init() {
 	config = cfg.ResetTestRoot("consensus_height_vote_set_test")
-	code := m.Run()
-	os.RemoveAll(config.RootDir)
-	os.Exit(code)
 }

 func TestPeerCatchupRounds(t *testing.T) {
@@ -68,6 +64,7 @@ func makeVoteHR(t *testing.T, height int64, round int, privVals []types.PrivVali
 	err := privVal.SignVote(chainID, vote)
 	if err != nil {
 		panic(fmt.Sprintf("Error signing vote: %v", err))
+		return nil
 	}
 	return vote
 }
--- a/consensus/types/round_state.go
+++ b/consensus/types/round_state.go
@@ -65,26 +65,25 @@ func (rs RoundStepType) String() string {
 // NOTE: Not thread safe. Should only be manipulated by functions downstream
 // of the cs.receiveRoutine
 type RoundState struct {
-	Height                    int64               `json:"height"` // Height we are working on
-	Round                     int                 `json:"round"`
-	Step                      RoundStepType       `json:"step"`
-	StartTime                 time.Time           `json:"start_time"`
-	CommitTime                time.Time           `json:"commit_time"` // Subjective time when +2/3 precommits for Block at Round were found
-	Validators                *types.ValidatorSet `json:"validators"`
-	Proposal                  *types.Proposal     `json:"proposal"`
-	ProposalBlock             *types.Block        `json:"proposal_block"`
-	ProposalBlockParts        *types.PartSet      `json:"proposal_block_parts"`
-	LockedRound               int                 `json:"locked_round"`
-	LockedBlock               *types.Block        `json:"locked_block"`
-	LockedBlockParts          *types.PartSet      `json:"locked_block_parts"`
-	ValidRound                int                 `json:"valid_round"`       // Last known round with POL for non-nil valid block.
-	ValidBlock                *types.Block        `json:"valid_block"`       // Last known block of POL mentioned above.
-	ValidBlockParts           *types.PartSet      `json:"valid_block_parts"` // Last known block parts of POL metnioned above.
-	Votes                     *HeightVoteSet      `json:"votes"`
-	CommitRound               int                 `json:"commit_round"` //
-	LastCommit                *types.VoteSet      `json:"last_commit"`  // Last precommits at Height-1
-	LastValidators            *types.ValidatorSet `json:"last_validators"`
-	TriggeredTimeoutPrecommit bool                `json:"triggered_timeout_precommit"`
+	Height             int64               `json:"height"` // Height we are working on
+	Round              int                 `json:"round"`
+	Step               RoundStepType       `json:"step"`
+	StartTime          time.Time           `json:"start_time"`
+	CommitTime         time.Time           `json:"commit_time"` // Subjective time when +2/3 precommits for Block at Round were found
+	Validators         *types.ValidatorSet `json:"validators"`
+	Proposal           *types.Proposal     `json:"proposal"`
+	ProposalBlock      *types.Block        `json:"proposal_block"`
+	ProposalBlockParts *types.PartSet      `json:"proposal_block_parts"`
+	LockedRound        int                 `json:"locked_round"`
+	LockedBlock        *types.Block        `json:"locked_block"`
+	LockedBlockParts   *types.PartSet      `json:"locked_block_parts"`
+	ValidRound         int                 `json:"valid_round"`       // Last known round with POL for non-nil valid block.
+	ValidBlock         *types.Block        `json:"valid_block"`       // Last known block of POL mentioned above.
+	ValidBlockParts    *types.PartSet      `json:"valid_block_parts"` // Last known block parts of POL metnioned above.
+	Votes              *HeightVoteSet      `json:"votes"`
+	CommitRound        int                 `json:"commit_round"` //
+	LastCommit         *types.VoteSet      `json:"last_commit"`  // Last precommits at Height-1
+	LastValidators     *types.ValidatorSet `json:"last_validators"`
 }

 // Compressed version of the RoundState for use in RPC
--- a/consensus/types/round_state_test.go
+++ b/consensus/types/round_state_test.go
@@ -3,7 +3,7 @@ package types
 import (
 	"testing"

-	amino "github.com/tendermint/go-amino"
+	"github.com/tendermint/go-amino"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	"github.com/tendermint/tendermint/types"
@@ -16,7 +16,7 @@ func BenchmarkRoundStateDeepCopy(b *testing.B) {
 	// Random validators
 	nval, ntxs := 100, 100
 	vset, _ := types.RandValidatorSet(nval, 1)
-	precommits := make([]*types.CommitSig, nval)
+	precommits := make([]*types.Vote, nval)
 	blockID := types.BlockID{
 		Hash: cmn.RandBytes(20),
 		PartsHeader: types.PartSetHeader{
@@ -25,12 +25,12 @@ func BenchmarkRoundStateDeepCopy(b *testing.B) {
 	}
 	sig := make([]byte, ed25519.SignatureSize)
 	for i := 0; i < nval; i++ {
-		precommits[i] = (&types.Vote{
+		precommits[i] = &types.Vote{
 			ValidatorAddress: types.Address(cmn.RandBytes(20)),
 			Timestamp:        tmtime.Now(),
 			BlockID:          blockID,
 			Signature:        sig,
-		}).CommitSig()
+		}
 	}
 	txs := make([]types.Tx, ntxs)
 	for i := 0; i < ntxs; i++ {
@@ -53,8 +53,11 @@ func BenchmarkRoundStateDeepCopy(b *testing.B) {
 		Data: types.Data{
 			Txs: txs,
 		},
-		Evidence:   types.EvidenceData{},
-		LastCommit: types.NewCommit(blockID, precommits),
+		Evidence: types.EvidenceData{},
+		LastCommit: &types.Commit{
+			BlockID:    blockID,
+			Precommits: precommits,
+		},
 	}
 	parts := block.MakePartSet(4096)
 	// Random Proposal
--- a/consensus/wal.go
+++ b/consensus/wal.go
@@ -112,21 +112,11 @@ func (wal *baseWAL) OnStart() error {
 	return err
 }

-// Stop the underlying autofile group.
-// Use Wait() to ensure it's finished shutting down
-// before cleaning up files.
 func (wal *baseWAL) OnStop() {
-	wal.group.Flush()
 	wal.group.Stop()
 	wal.group.Close()
 }

-// Wait for the underlying autofile group to finish shutting down
-// so it's safe to cleanup files.
-func (wal *baseWAL) Wait() {
-	wal.group.Wait()
-}
-
 // Write is called in newStep and for each receive on the
 // peerMsgQueue and the timeoutTicker.
 // NOTE: does not call fsync()
@@ -173,7 +163,7 @@ func (wal *baseWAL) SearchForEndHeight(height int64, options *WALSearchOptions)
 	// NOTE: starting from the last file in the group because we're usually
 	// searching for the last height. See replay.go
 	min, max := wal.group.MinIndex(), wal.group.MaxIndex()
-	wal.Logger.Info("Searching for height", "height", height, "min", min, "max", max)
+	wal.Logger.Debug("Searching for height", "height", height, "min", min, "max", max)
 	for index := max; index >= min; index-- {
 		gr, err = wal.group.NewReader(index)
 		if err != nil {
@@ -193,7 +183,7 @@ func (wal *baseWAL) SearchForEndHeight(height int64, options *WALSearchOptions)
 				break
 			}
 			if options.IgnoreDataCorruptionErrors && IsDataCorruptionError(err) {
-				wal.Logger.Error("Corrupted entry. Skipping...", "err", err)
+				wal.Logger.Debug("Corrupted entry. Skipping...", "err", err)
 				// do nothing
 				continue
 			} else if err != nil {
@@ -204,7 +194,7 @@ func (wal *baseWAL) SearchForEndHeight(height int64, options *WALSearchOptions)
 			if m, ok := msg.Msg.(EndHeightMessage); ok {
 				lastHeightFound = m.Height
 				if m.Height == height { // found
-					wal.Logger.Info("Found", "height", height, "index", index)
+					wal.Logger.Debug("Found", "height", height, "index", index)
 					return gr, true, nil
 				}
 			}
@@ -229,17 +219,12 @@ func NewWALEncoder(wr io.Writer) *WALEncoder {
 	return &WALEncoder{wr}
 }

-// Encode writes the custom encoding of v to the stream. It returns an error if
-// the amino-encoded size of v is greater than 1MB. Any error encountered
-// during the write is also returned.
+// Encode writes the custom encoding of v to the stream.
 func (enc *WALEncoder) Encode(v *TimedWALMessage) error {
 	data := cdc.MustMarshalBinaryBare(v)

 	crc := crc32.Checksum(data, crc32c)
 	length := uint32(len(data))
-	if length > maxMsgSizeBytes {
-		return fmt.Errorf("Msg is too big: %d bytes, max: %d bytes", length, maxMsgSizeBytes)
-	}
 	totalLength := 8 + int(length)

 	msg := make([]byte, totalLength)
@@ -296,31 +281,31 @@ func (dec *WALDecoder) Decode() (*TimedWALMessage, error) {
 		return nil, err
 	}
 	if err != nil {
-		return nil, DataCorruptionError{fmt.Errorf("failed to read checksum: %v", err)}
+		return nil, fmt.Errorf("failed to read checksum: %v", err)
 	}
 	crc := binary.BigEndian.Uint32(b)

 	b = make([]byte, 4)
 	_, err = dec.rd.Read(b)
 	if err != nil {
-		return nil, DataCorruptionError{fmt.Errorf("failed to read length: %v", err)}
+		return nil, fmt.Errorf("failed to read length: %v", err)
 	}
 	length := binary.BigEndian.Uint32(b)

 	if length > maxMsgSizeBytes {
-		return nil, DataCorruptionError{fmt.Errorf("length %d exceeded maximum possible value of %d bytes", length, maxMsgSizeBytes)}
+		return nil, fmt.Errorf("length %d exceeded maximum possible value of %d bytes", length, maxMsgSizeBytes)
 	}

 	data := make([]byte, length)
-	n, err := dec.rd.Read(data)
+	_, err = dec.rd.Read(data)
 	if err != nil {
-		return nil, DataCorruptionError{fmt.Errorf("failed to read data: %v (read: %d, wanted: %d)", err, n, length)}
+		return nil, fmt.Errorf("failed to read data: %v", err)
 	}

 	// check checksum before decoding data
 	actualCRC := crc32.Checksum(data, crc32c)
 	if actualCRC != crc {
-		return nil, DataCorruptionError{fmt.Errorf("checksums do not match: read: %v, actual: %v", crc, actualCRC)}
+		return nil, DataCorruptionError{fmt.Errorf("checksums do not match: (read: %v, actual: %v)", crc, actualCRC)}
 	}

 	var res = new(TimedWALMessage) // nolint: gosimple
--- a/consensus/wal_generator.go
+++ b/consensus/wal_generator.go
@@ -7,7 +7,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
-	"testing"
+	"strings"
 	"time"

 	"github.com/pkg/errors"
@@ -28,9 +28,8 @@ import (
 // stripped down version of node (proxy app, event bus, consensus state) with a
 // persistent kvstore application and special consensus wal instance
 // (byteBufferWAL) and waits until numBlocks are created. If the node fails to produce given numBlocks, it returns an error.
-func WALGenerateNBlocks(t *testing.T, wr io.Writer, numBlocks int) (err error) {
-	config := getConfig(t)
-	defer os.RemoveAll(config.RootDir)
+func WALGenerateNBlocks(wr io.Writer, numBlocks int) (err error) {
+	config := getConfig()

 	app := kvstore.NewPersistentKVStoreApplication(filepath.Join(config.DBDir(), "wal_generator"))

@@ -41,9 +40,8 @@ func WALGenerateNBlocks(t *testing.T, wr io.Writer, numBlocks int) (err error) {
 	// COPY PASTE FROM node.go WITH A FEW MODIFICATIONS
 	// NOTE: we can't import node package because of circular dependency.
 	// NOTE: we don't do handshake so need to set state.Version.Consensus.App directly.
-	privValidatorKeyFile := config.PrivValidatorKeyFile()
-	privValidatorStateFile := config.PrivValidatorStateFile()
-	privValidator := privval.LoadOrGenFilePV(privValidatorKeyFile, privValidatorStateFile)
+	privValidatorFile := config.PrivValidatorFile()
+	privValidator := privval.LoadOrGenFilePV(privValidatorFile)
 	genDoc, err := types.GenesisDocFromFile(config.GenesisFile())
 	if err != nil {
 		return errors.Wrap(err, "failed to read genesis file")
@@ -103,11 +101,11 @@ func WALGenerateNBlocks(t *testing.T, wr io.Writer, numBlocks int) (err error) {
 }

 //WALWithNBlocks returns a WAL content with numBlocks.
-func WALWithNBlocks(t *testing.T, numBlocks int) (data []byte, err error) {
+func WALWithNBlocks(numBlocks int) (data []byte, err error) {
 	var b bytes.Buffer
 	wr := bufio.NewWriter(&b)

-	if err := WALGenerateNBlocks(t, wr, numBlocks); err != nil {
+	if err := WALGenerateNBlocks(wr, numBlocks); err != nil {
 		return []byte{}, err
 	}

@@ -115,6 +113,18 @@ func WALWithNBlocks(t *testing.T, numBlocks int) (data []byte, err error) {
 	return b.Bytes(), nil
 }

+// f**ing long, but unique for each test
+func makePathname() string {
+	// get path
+	p, err := os.Getwd()
+	if err != nil {
+		panic(err)
+	}
+	// fmt.Println(p)
+	sep := string(filepath.Separator)
+	return strings.Replace(p, sep, "_", -1)
+}
+
 func randPort() int {
 	// returns between base and base + spread
 	base, spread := 20000, 20000
@@ -129,8 +139,9 @@ func makeAddrs() (string, string, string) {
 }

 // getConfig returns a config for test cases
-func getConfig(t *testing.T) *cfg.Config {
-	c := cfg.ResetTestRoot(t.Name())
+func getConfig() *cfg.Config {
+	pathname := makePathname()
+	c := cfg.ResetTestRoot(fmt.Sprintf("%s_%d", pathname, cmn.RandInt()))

 	// and we use random ports to run in parallel
 	tm, rpc, grpc := makeAddrs()
--- a/consensus/wal_test.go
+++ b/consensus/wal_test.go
@@ -7,7 +7,6 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-
 	// "sync"
 	"testing"
 	"time"
@@ -39,16 +38,11 @@ func TestWALTruncate(t *testing.T) {
 	wal.SetLogger(log.TestingLogger())
 	err = wal.Start()
 	require.NoError(t, err)
-	defer func() {
-		wal.Stop()
-		// wait for the wal to finish shutting down so we
-		// can safely remove the directory
-		wal.Wait()
-	}()
+	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(t, wal.Group(), 60)
+	err = WALGenerateNBlocks(wal.Group(), 60)
 	require.NoError(t, err)

 	time.Sleep(1 * time.Millisecond) //wait groupCheckDuration, make sure RotateFile run
@@ -73,8 +67,8 @@ func TestWALTruncate(t *testing.T) {
 func TestWALEncoderDecoder(t *testing.T) {
 	now := tmtime.Now()
 	msgs := []TimedWALMessage{
-		{Time: now, Msg: EndHeightMessage{0}},
-		{Time: now, Msg: timeoutInfo{Duration: time.Second, Height: 1, Round: 1, Step: types.RoundStepPropose}},
+		TimedWALMessage{Time: now, Msg: EndHeightMessage{0}},
+		TimedWALMessage{Time: now, Msg: timeoutInfo{Duration: time.Second, Height: 1, Round: 1, Step: types.RoundStepPropose}},
 	}

 	b := new(bytes.Buffer)
@@ -95,28 +89,8 @@ func TestWALEncoderDecoder(t *testing.T) {
 	}
 }

-func TestWALWritePanicsIfMsgIsTooBig(t *testing.T) {
-	walDir, err := ioutil.TempDir("", "wal")
-	require.NoError(t, err)
-	defer os.RemoveAll(walDir)
-	walFile := filepath.Join(walDir, "wal")
-
-	wal, err := NewWAL(walFile)
-	require.NoError(t, err)
-	err = wal.Start()
-	require.NoError(t, err)
-	defer func() {
-		wal.Stop()
-		// wait for the wal to finish shutting down so we
-		// can safely remove the directory
-		wal.Wait()
-	}()
-
-	assert.Panics(t, func() { wal.Write(make([]byte, maxMsgSizeBytes+1)) })
-}
-
 func TestWALSearchForEndHeight(t *testing.T) {
-	walBody, err := WALWithNBlocks(t, 6)
+	walBody, err := WALWithNBlocks(6)
 	if err != nil {
 		t.Fatal(err)
 	}
--- a/consensus/wire.go
+++ b/consensus/wire.go
@@ -1,7 +1,7 @@
 package consensus

 import (
-	amino "github.com/tendermint/go-amino"
+	"github.com/tendermint/go-amino"
 	"github.com/tendermint/tendermint/types"
 )

--- a/crypto/armor/armor.go
+++ b/crypto/armor/armor.go
@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"io/ioutil"

-	"golang.org/x/crypto/openpgp/armor"
+	"golang.org/x/crypto/openpgp/armor" // forked to github.com/tendermint/crypto
 )

 func EncodeArmor(blockType string, headers map[string]string, data []byte) string {
--- a/crypto/ed25519/ed25519.go
+++ b/crypto/ed25519/ed25519.go
@@ -7,7 +7,7 @@ import (
 	"io"

 	amino "github.com/tendermint/go-amino"
-	"golang.org/x/crypto/ed25519"
+	"golang.org/x/crypto/ed25519" // forked to github.com/tendermint/crypto

 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/tmhash"
@@ -18,8 +18,8 @@ import (
 var _ crypto.PrivKey = PrivKeyEd25519{}

 const (
-	PrivKeyAminoName = "tendermint/PrivKeyEd25519"
-	PubKeyAminoName  = "tendermint/PubKeyEd25519"
+	PrivKeyAminoRoute = "tendermint/PrivKeyEd25519"
+	PubKeyAminoRoute  = "tendermint/PubKeyEd25519"
 	// Size of an Edwards25519 signature. Namely the size of a compressed
 	// Edwards25519 point, and a field element. Both of which are 32 bytes.
 	SignatureSize = 64
@@ -30,11 +30,11 @@ var cdc = amino.NewCodec()
 func init() {
 	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
 	cdc.RegisterConcrete(PubKeyEd25519{},
-		PubKeyAminoName, nil)
+		PubKeyAminoRoute, nil)

 	cdc.RegisterInterface((*crypto.PrivKey)(nil), nil)
 	cdc.RegisterConcrete(PrivKeyEd25519{},
-		PrivKeyAminoName, nil)
+		PrivKeyAminoRoute, nil)
 }

 // PrivKeyEd25519 implements crypto.PrivKey.
--- a/crypto/encoding/amino/amino.go
+++ b/crypto/encoding/amino/amino.go
@@ -12,11 +12,11 @@ import (

 var cdc = amino.NewCodec()

-// nameTable is used to map public key concrete types back
-// to their registered amino names. This should eventually be handled
+// routeTable is used to map public key concrete types back
+// to their amino routes. This should eventually be handled
 // by amino. Example usage:
-// nameTable[reflect.TypeOf(ed25519.PubKeyEd25519{})] = ed25519.PubKeyAminoName
-var nameTable = make(map[reflect.Type]string, 3)
+// routeTable[reflect.TypeOf(ed25519.PubKeyEd25519{})] = ed25519.PubKeyAminoRoute
+var routeTable = make(map[reflect.Type]string, 3)

 func init() {
 	// NOTE: It's important that there be no conflicts here,
@@ -29,16 +29,16 @@ func init() {

 	// TODO: Have amino provide a way to go from concrete struct to route directly.
 	// Its currently a private API
-	nameTable[reflect.TypeOf(ed25519.PubKeyEd25519{})] = ed25519.PubKeyAminoName
-	nameTable[reflect.TypeOf(secp256k1.PubKeySecp256k1{})] = secp256k1.PubKeyAminoName
-	nameTable[reflect.TypeOf(multisig.PubKeyMultisigThreshold{})] = multisig.PubKeyMultisigThresholdAminoRoute
+	routeTable[reflect.TypeOf(ed25519.PubKeyEd25519{})] = ed25519.PubKeyAminoRoute
+	routeTable[reflect.TypeOf(secp256k1.PubKeySecp256k1{})] = secp256k1.PubKeyAminoRoute
+	routeTable[reflect.TypeOf(&multisig.PubKeyMultisigThreshold{})] = multisig.PubKeyMultisigThresholdAminoRoute
 }

-// PubkeyAminoName returns the amino route of a pubkey
+// PubkeyAminoRoute returns the amino route of a pubkey
 // cdc is currently passed in, as eventually this will not be using
 // a package level codec.
-func PubkeyAminoName(cdc *amino.Codec, key crypto.PubKey) (string, bool) {
-	route, found := nameTable[reflect.TypeOf(key)]
+func PubkeyAminoRoute(cdc *amino.Codec, key crypto.PubKey) (string, bool) {
+	route, found := routeTable[reflect.TypeOf(key)]
 	return route, found
 }

@@ -47,17 +47,17 @@ func RegisterAmino(cdc *amino.Codec) {
 	// These are all written here instead of
 	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
 	cdc.RegisterConcrete(ed25519.PubKeyEd25519{},
-		ed25519.PubKeyAminoName, nil)
+		ed25519.PubKeyAminoRoute, nil)
 	cdc.RegisterConcrete(secp256k1.PubKeySecp256k1{},
-		secp256k1.PubKeyAminoName, nil)
+		secp256k1.PubKeyAminoRoute, nil)
 	cdc.RegisterConcrete(multisig.PubKeyMultisigThreshold{},
 		multisig.PubKeyMultisigThresholdAminoRoute, nil)

 	cdc.RegisterInterface((*crypto.PrivKey)(nil), nil)
 	cdc.RegisterConcrete(ed25519.PrivKeyEd25519{},
-		ed25519.PrivKeyAminoName, nil)
+		ed25519.PrivKeyAminoRoute, nil)
 	cdc.RegisterConcrete(secp256k1.PrivKeySecp256k1{},
-		secp256k1.PrivKeyAminoName, nil)
+		secp256k1.PrivKeyAminoRoute, nil)
 }

 func PrivKeyFromBytes(privKeyBytes []byte) (privKey crypto.PrivKey, err error) {
--- a/crypto/encoding/amino/encode_test.go
+++ b/crypto/encoding/amino/encode_test.go
@@ -25,8 +25,9 @@ func checkAminoBinary(t *testing.T, src, dst interface{}, size int) {
 		assert.Equal(t, byterSrc.Bytes(), bz, "Amino binary vs Bytes() mismatch")
 	}
 	// Make sure we have the expected length.
-	assert.Equal(t, size, len(bz), "Amino binary size mismatch")
-
+	if size != -1 {
+		assert.Equal(t, size, len(bz), "Amino binary size mismatch")
+	}
 	// Unmarshal.
 	err = cdc.UnmarshalBinaryBare(bz, dst)
 	require.Nil(t, err, "%+v", err)
@@ -47,8 +48,6 @@ func checkAminoJSON(t *testing.T, src interface{}, dst interface{}, isNil bool)
 	require.Nil(t, err, "%+v", err)
 }

-// ExamplePrintRegisteredTypes refers to unknown identifier: PrintRegisteredTypes
-//nolint:govet
 func ExamplePrintRegisteredTypes() {
 	cdc.PrintTypes(os.Stdout)
 	// Output: | Type | Name | Prefix | Length | Notes |
@@ -129,18 +128,18 @@ func TestPubKeyInvalidDataProperReturnsEmpty(t *testing.T) {
 	require.Nil(t, pk)
 }

-func TestPubkeyAminoName(t *testing.T) {
+func TestPubkeyAminoRoute(t *testing.T) {
 	tests := []struct {
 		key   crypto.PubKey
 		want  string
 		found bool
 	}{
-		{ed25519.PubKeyEd25519{}, ed25519.PubKeyAminoName, true},
-		{secp256k1.PubKeySecp256k1{}, secp256k1.PubKeyAminoName, true},
-		{multisig.PubKeyMultisigThreshold{}, multisig.PubKeyMultisigThresholdAminoRoute, true},
+		{ed25519.PubKeyEd25519{}, ed25519.PubKeyAminoRoute, true},
+		{secp256k1.PubKeySecp256k1{}, secp256k1.PubKeyAminoRoute, true},
+		{&multisig.PubKeyMultisigThreshold{}, multisig.PubKeyMultisigThresholdAminoRoute, true},
 	}
 	for i, tc := range tests {
-		got, found := PubkeyAminoName(cdc, tc.key)
+		got, found := PubkeyAminoRoute(cdc, tc.key)
 		require.Equal(t, tc.found, found, "not equal on tc %d", i)
 		if tc.found {
 			require.Equal(t, tc.want, got, "not equal on tc %d", i)
--- a/crypto/hash.go
+++ b/crypto/hash.go
@@ -3,7 +3,7 @@ package crypto
 import (
 	"crypto/sha256"

-	"golang.org/x/crypto/ripemd160"
+	"golang.org/x/crypto/ripemd160" // forked to github.com/tendermint/crypto
 )

 func Sha256(bytes []byte) []byte {
--- a/crypto/merkle/hash.go
+++ b/crypto/merkle/hash.go
@@ -1,21 +0,0 @@
-package merkle
-
-import (
-	"github.com/tendermint/tendermint/crypto/tmhash"
-)
-
-// TODO: make these have a large predefined capacity
-var (
-	leafPrefix  = []byte{0}
-	innerPrefix = []byte{1}
-)
-
-// returns tmhash(0x00 || leaf)
-func leafHash(leaf []byte) []byte {
-	return tmhash.Sum(append(leafPrefix, leaf...))
-}
-
-// returns tmhash(0x01 || left || right)
-func innerHash(left []byte, right []byte) []byte {
-	return tmhash.Sum(append(innerPrefix, append(left, right...)...))
-}
--- a/crypto/merkle/proof.go
+++ b/crypto/merkle/proof.go
@@ -98,7 +98,7 @@ func (prt *ProofRuntime) Decode(pop ProofOp) (ProofOperator, error) {
 }

 func (prt *ProofRuntime) DecodeProof(proof *Proof) (ProofOperators, error) {
-	poz := make(ProofOperators, 0, len(proof.Ops))
+	var poz ProofOperators
 	for _, pop := range proof.Ops {
 		operator, err := prt.Decode(pop)
 		if err != nil {
--- a/crypto/merkle/proof_key_path_test.go
+++ b/crypto/merkle/proof_key_path_test.go
@@ -1,8 +1,6 @@
 package merkle

 import (
-	// it is ok to use math/rand here: we do not need a cryptographically secure random
-	// number generator here and we can run the tests a bit faster
 	"math/rand"
 	"testing"

@@ -26,7 +24,7 @@ func TestKeyPath(t *testing.T) {
 					keys[i][j] = alphanum[rand.Intn(len(alphanum))]
 				}
 			case KeyEncodingHex:
-				rand.Read(keys[i]) //nolint: gosec
+				rand.Read(keys[i])
 			default:
 				panic("Unexpected encoding")
 			}
--- a/crypto/merkle/proof_simple_value.go
+++ b/crypto/merkle/proof_simple_value.go
@@ -71,11 +71,11 @@ func (op SimpleValueOp) Run(args [][]byte) ([][]byte, error) {
 	hasher.Write(value) // does not error
 	vhash := hasher.Sum(nil)

-	bz := new(bytes.Buffer)
 	// Wrap <op.Key, vhash> to hash the KVPair.
-	encodeByteSlice(bz, []byte(op.key)) // does not error
-	encodeByteSlice(bz, []byte(vhash))  // does not error
-	kvhash := leafHash(bz.Bytes())
+	hasher = tmhash.New()
+	encodeByteSlice(hasher, []byte(op.key)) // does not error
+	encodeByteSlice(hasher, []byte(vhash))  // does not error
+	kvhash := hasher.Sum(nil)

 	if !bytes.Equal(kvhash, op.Proof.LeafHash) {
 		return nil, cmn.NewError("leaf hash mismatch: want %X got %X", op.Proof.LeafHash, kvhash)
--- a/crypto/merkle/proof_test.go
+++ b/crypto/merkle/proof_test.go
@@ -4,7 +4,7 @@ import (
 	"testing"

 	"github.com/stretchr/testify/assert"
-	amino "github.com/tendermint/go-amino"
+	"github.com/tendermint/go-amino"
 	cmn "github.com/tendermint/tendermint/libs/common"
 )

@@ -26,7 +26,6 @@ func NewDominoOp(key, input, output string) DominoOp {
 	}
 }

-//nolint:unused
 func DominoOpDecoder(pop ProofOp) (ProofOperator, error) {
 	if pop.Type != ProofOpDomino {
 		panic("unexpected proof op type")
--- a/crypto/merkle/rfc6962_test.go
+++ b/crypto/merkle/rfc6962_test.go
@@ -1,97 +0,0 @@
-package merkle
-
-// Copyright 2016 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// These tests were taken from https://github.com/google/trillian/blob/master/merkle/rfc6962/rfc6962_test.go,
-// and consequently fall under the above license.
-import (
-	"bytes"
-	"encoding/hex"
-	"testing"
-
-	"github.com/tendermint/tendermint/crypto/tmhash"
-)
-
-func TestRFC6962Hasher(t *testing.T) {
-	_, leafHashTrail := trailsFromByteSlices([][]byte{[]byte("L123456")})
-	leafHash := leafHashTrail.Hash
-	_, leafHashTrail = trailsFromByteSlices([][]byte{{}})
-	emptyLeafHash := leafHashTrail.Hash
-	for _, tc := range []struct {
-		desc string
-		got  []byte
-		want string
-	}{
-		// Since creating a merkle tree of no leaves is unsupported here, we skip
-		// the corresponding trillian test vector.
-
-		// Check that the empty hash is not the same as the hash of an empty leaf.
-		// echo -n 00 | xxd -r -p | sha256sum
-		{
-			desc: "RFC6962 Empty Leaf",
-			want: "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d"[:tmhash.Size*2],
-			got:  emptyLeafHash,
-		},
-		// echo -n 004C313233343536 | xxd -r -p | sha256sum
-		{
-			desc: "RFC6962 Leaf",
-			want: "395aa064aa4c29f7010acfe3f25db9485bbd4b91897b6ad7ad547639252b4d56"[:tmhash.Size*2],
-			got:  leafHash,
-		},
-		// echo -n 014E3132334E343536 | xxd -r -p | sha256sum
-		{
-			desc: "RFC6962 Node",
-			want: "aa217fe888e47007fa15edab33c2b492a722cb106c64667fc2b044444de66bbb"[:tmhash.Size*2],
-			got:  innerHash([]byte("N123"), []byte("N456")),
-		},
-	} {
-		t.Run(tc.desc, func(t *testing.T) {
-			wantBytes, err := hex.DecodeString(tc.want)
-			if err != nil {
-				t.Fatalf("hex.DecodeString(%x): %v", tc.want, err)
-			}
-			if got, want := tc.got, wantBytes; !bytes.Equal(got, want) {
-				t.Errorf("got %x, want %x", got, want)
-			}
-		})
-	}
-}
-
-func TestRFC6962HasherCollisions(t *testing.T) {
-	// Check that different leaves have different hashes.
-	leaf1, leaf2 := []byte("Hello"), []byte("World")
-	_, leafHashTrail := trailsFromByteSlices([][]byte{leaf1})
-	hash1 := leafHashTrail.Hash
-	_, leafHashTrail = trailsFromByteSlices([][]byte{leaf2})
-	hash2 := leafHashTrail.Hash
-	if bytes.Equal(hash1, hash2) {
-		t.Errorf("Leaf hashes should differ, but both are %x", hash1)
-	}
-	// Compute an intermediate subtree hash.
-	_, subHash1Trail := trailsFromByteSlices([][]byte{hash1, hash2})
-	subHash1 := subHash1Trail.Hash
-	// Check that this is not the same as a leaf hash of their concatenation.
-	preimage := append(hash1, hash2...)
-	_, forgedHashTrail := trailsFromByteSlices([][]byte{preimage})
-	forgedHash := forgedHashTrail.Hash
-	if bytes.Equal(subHash1, forgedHash) {
-		t.Errorf("Hasher is not second-preimage resistant")
-	}
-	// Swap the order of nodes and check that the hash is different.
-	_, subHash2Trail := trailsFromByteSlices([][]byte{hash2, hash1})
-	subHash2 := subHash2Trail.Hash
-	if bytes.Equal(subHash1, subHash2) {
-		t.Errorf("Subtree hash does not depend on the order of leaves")
-	}
-}
--- 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"}, "a44d3cc7daba1a4600b00a2434b30f8b970652169810d6dfa9fb1793a2189324"},
-		{[]string{"key1"}, []string{"value2"}, "0638e99b3445caec9d95c05e1a3fc1487b4ddec6a952ff337080360b0dcc078c"},
+		{[]string{"key1"}, []string{"value1"}, "321d150de16dceb51c72981b432b115045383259b1a550adf8dc80f927508967"},
+		{[]string{"key1"}, []string{"value2"}, "2a9e4baf321eac99f6eecc3406603c14bc5e85bb7b80483cbfc75b3382d24a2f"},
 		// swap order with 2 keys
-		{[]string{"key1", "key2"}, []string{"value1", "value2"}, "8fd19b19e7bb3f2b3ee0574027d8a5a4cec370464ea2db2fbfa5c7d35bb0cff3"},
-		{[]string{"key2", "key1"}, []string{"value2", "value1"}, "8fd19b19e7bb3f2b3ee0574027d8a5a4cec370464ea2db2fbfa5c7d35bb0cff3"},
+		{[]string{"key1", "key2"}, []string{"value1", "value2"}, "c4d8913ab543ba26aa970646d4c99a150fd641298e3367cf68ca45fb45a49881"},
+		{[]string{"key2", "key1"}, []string{"value2", "value1"}, "c4d8913ab543ba26aa970646d4c99a150fd641298e3367cf68ca45fb45a49881"},
 		// swap order with 3 keys
-		{[]string{"key1", "key2", "key3"}, []string{"value1", "value2", "value3"}, "1dd674ec6782a0d586a903c9c63326a41cbe56b3bba33ed6ff5b527af6efb3dc"},
-		{[]string{"key1", "key3", "key2"}, []string{"value1", "value3", "value2"}, "1dd674ec6782a0d586a903c9c63326a41cbe56b3bba33ed6ff5b527af6efb3dc"},
+		{[]string{"key1", "key2", "key3"}, []string{"value1", "value2", "value3"}, "b23cef00eda5af4548a213a43793f2752d8d9013b3f2b64bc0523a4791196268"},
+		{[]string{"key1", "key3", "key2"}, []string{"value1", "value3", "value2"}, "b23cef00eda5af4548a213a43793f2752d8d9013b3f2b64bc0523a4791196268"},
 	}
 	for i, tc := range tests {
 		db := newSimpleMap()
--- a/crypto/merkle/simple_proof.go
+++ b/crypto/merkle/simple_proof.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"

+	"github.com/tendermint/tendermint/crypto/tmhash"
 	cmn "github.com/tendermint/tendermint/libs/common"
 )

@@ -66,8 +67,7 @@ func SimpleProofsFromMap(m map[string][]byte) (rootHash []byte, proofs map[strin

 // Verify that the SimpleProof proves the root hash.
 // Check sp.Index/sp.Total manually if needed
-func (sp *SimpleProof) Verify(rootHash []byte, leaf []byte) error {
-	leafHash := leafHash(leaf)
+func (sp *SimpleProof) Verify(rootHash []byte, leafHash []byte) error {
 	if sp.Total < 0 {
 		return errors.New("Proof total must be positive")
 	}
@@ -128,19 +128,19 @@ func computeHashFromAunts(index int, total int, leafHash []byte, innerHashes [][
 		if len(innerHashes) == 0 {
 			return nil
 		}
-		numLeft := getSplitPoint(total)
+		numLeft := (total + 1) / 2
 		if index < numLeft {
 			leftHash := computeHashFromAunts(index, numLeft, leafHash, innerHashes[:len(innerHashes)-1])
 			if leftHash == nil {
 				return nil
 			}
-			return innerHash(leftHash, innerHashes[len(innerHashes)-1])
+			return simpleHashFromTwoHashes(leftHash, innerHashes[len(innerHashes)-1])
 		}
 		rightHash := computeHashFromAunts(index-numLeft, total-numLeft, leafHash, innerHashes[:len(innerHashes)-1])
 		if rightHash == nil {
 			return nil
 		}
-		return innerHash(innerHashes[len(innerHashes)-1], rightHash)
+		return simpleHashFromTwoHashes(innerHashes[len(innerHashes)-1], rightHash)
 	}
 }

@@ -182,13 +182,12 @@ func trailsFromByteSlices(items [][]byte) (trails []*SimpleProofNode, root *Simp
 	case 0:
 		return nil, nil
 	case 1:
-		trail := &SimpleProofNode{leafHash(items[0]), nil, nil, nil}
+		trail := &SimpleProofNode{tmhash.Sum(items[0]), nil, nil, nil}
 		return []*SimpleProofNode{trail}, trail
 	default:
-		k := getSplitPoint(len(items))
-		lefts, leftRoot := trailsFromByteSlices(items[:k])
-		rights, rightRoot := trailsFromByteSlices(items[k:])
-		rootHash := innerHash(leftRoot.Hash, rightRoot.Hash)
+		lefts, leftRoot := trailsFromByteSlices(items[:(len(items)+1)/2])
+		rights, rightRoot := trailsFromByteSlices(items[(len(items)+1)/2:])
+		rootHash := simpleHashFromTwoHashes(leftRoot.Hash, rightRoot.Hash)
 		root := &SimpleProofNode{rootHash, nil, nil, nil}
 		leftRoot.Parent = root
 		leftRoot.Right = rightRoot
--- a/crypto/merkle/simple_tree.go
+++ b/crypto/merkle/simple_tree.go
@@ -1,9 +1,23 @@
 package merkle

 import (
-	"math/bits"
+	"github.com/tendermint/tendermint/crypto/tmhash"
 )

+// simpleHashFromTwoHashes is the basic operation of the Merkle tree: Hash(left | right).
+func simpleHashFromTwoHashes(left, right []byte) []byte {
+	var hasher = tmhash.New()
+	err := encodeByteSlice(hasher, left)
+	if err != nil {
+		panic(err)
+	}
+	err = encodeByteSlice(hasher, right)
+	if err != nil {
+		panic(err)
+	}
+	return hasher.Sum(nil)
+}
+
 // SimpleHashFromByteSlices computes a Merkle tree where the leaves are the byte slice,
 // in the provided order.
 func SimpleHashFromByteSlices(items [][]byte) []byte {
@@ -11,12 +25,11 @@ func SimpleHashFromByteSlices(items [][]byte) []byte {
 	case 0:
 		return nil
 	case 1:
-		return leafHash(items[0])
+		return tmhash.Sum(items[0])
 	default:
-		k := getSplitPoint(len(items))
-		left := SimpleHashFromByteSlices(items[:k])
-		right := SimpleHashFromByteSlices(items[k:])
-		return innerHash(left, right)
+		left := SimpleHashFromByteSlices(items[:(len(items)+1)/2])
+		right := SimpleHashFromByteSlices(items[(len(items)+1)/2:])
+		return simpleHashFromTwoHashes(left, right)
 	}
 }

@@ -31,17 +44,3 @@ func SimpleHashFromMap(m map[string][]byte) []byte {
 	}
 	return sm.Hash()
 }
-
-// getSplitPoint returns the largest power of 2 less than length
-func getSplitPoint(length int) int {
-	if length < 1 {
-		panic("Trying to split a tree with size < 1")
-	}
-	uLength := uint(length)
-	bitlen := bits.Len(uLength)
-	k := 1 << uint(bitlen-1)
-	if k == length {
-		k >>= 1
-	}
-	return k
-}
--- a/crypto/merkle/simple_tree_test.go
+++ b/crypto/merkle/simple_tree_test.go
@@ -34,6 +34,7 @@ func TestSimpleProof(t *testing.T) {

 	// For each item, check the trail.
 	for i, item := range items {
+		itemHash := tmhash.Sum(item)
 		proof := proofs[i]

 		// Check total/index
@@ -42,53 +43,30 @@ func TestSimpleProof(t *testing.T) {
 		require.Equal(t, proof.Total, total, "Unmatched totals: %d vs %d", proof.Total, total)

 		// Verify success
-		err := proof.Verify(rootHash, item)
-		require.NoError(t, err, "Verification failed: %v.", err)
+		err := proof.Verify(rootHash, itemHash)
+		require.NoError(t, err, "Verificatior failed: %v.", err)

 		// Trail too long should make it fail
 		origAunts := proof.Aunts
 		proof.Aunts = append(proof.Aunts, cmn.RandBytes(32))
-		err = proof.Verify(rootHash, item)
+		err = proof.Verify(rootHash, itemHash)
 		require.Error(t, err, "Expected verification to fail for wrong trail length")

 		proof.Aunts = origAunts

 		// Trail too short should make it fail
 		proof.Aunts = proof.Aunts[0 : len(proof.Aunts)-1]
-		err = proof.Verify(rootHash, item)
+		err = proof.Verify(rootHash, itemHash)
 		require.Error(t, err, "Expected verification to fail for wrong trail length")

 		proof.Aunts = origAunts

 		// Mutating the itemHash should make it fail.
-		err = proof.Verify(rootHash, MutateByteSlice(item))
+		err = proof.Verify(rootHash, MutateByteSlice(itemHash))
 		require.Error(t, err, "Expected verification to fail for mutated leaf hash")

 		// Mutating the rootHash should make it fail.
-		err = proof.Verify(MutateByteSlice(rootHash), item)
+		err = proof.Verify(MutateByteSlice(rootHash), itemHash)
 		require.Error(t, err, "Expected verification to fail for mutated root hash")
 	}
 }
-
-func Test_getSplitPoint(t *testing.T) {
-	tests := []struct {
-		length int
-		want   int
-	}{
-		{1, 0},
-		{2, 1},
-		{3, 2},
-		{4, 2},
-		{5, 4},
-		{10, 8},
-		{20, 16},
-		{100, 64},
-		{255, 128},
-		{256, 128},
-		{257, 256},
-	}
-	for _, tt := range tests {
-		got := getSplitPoint(tt.length)
-		require.Equal(t, tt.want, got, "getSplitPoint(%d) = %v, want %v", tt.length, got, tt.want)
-	}
-}
--- a/crypto/merkle/wire.go
+++ b/crypto/merkle/wire.go
@@ -1,7 +1,7 @@
 package merkle

 import (
-	amino "github.com/tendermint/go-amino"
+	"github.com/tendermint/go-amino"
 )

 var cdc *amino.Codec
--- a/crypto/multisig/threshold_pubkey.go
+++ b/crypto/multisig/threshold_pubkey.go
@@ -2,6 +2,7 @@ package multisig

 import (
 	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/crypto/tmhash"
 )

 // PubKeyMultisigThreshold implements a K of N threshold multisig.
@@ -10,7 +11,7 @@ type PubKeyMultisigThreshold struct {
 	PubKeys []crypto.PubKey `json:"pubkeys"`
 }

-var _ crypto.PubKey = PubKeyMultisigThreshold{}
+var _ crypto.PubKey = &PubKeyMultisigThreshold{}

 // NewPubKeyMultisigThreshold returns a new PubKeyMultisigThreshold.
 // Panics if len(pubkeys) < k or 0 >= k.
@@ -21,7 +22,7 @@ func NewPubKeyMultisigThreshold(k int, pubkeys []crypto.PubKey) crypto.PubKey {
 	if len(pubkeys) < k {
 		panic("threshold k of n multisignature: len(pubkeys) < k")
 	}
-	return PubKeyMultisigThreshold{uint(k), pubkeys}
+	return &PubKeyMultisigThreshold{uint(k), pubkeys}
 }

 // VerifyBytes expects sig to be an amino encoded version of a MultiSignature.
@@ -30,8 +31,8 @@ func NewPubKeyMultisigThreshold(k int, pubkeys []crypto.PubKey) crypto.PubKey {
 // and all signatures are valid. (Not just k of the signatures)
 // The multisig uses a bitarray, so multiple signatures for the same key is not
 // a concern.
-func (pk PubKeyMultisigThreshold) VerifyBytes(msg []byte, marshalledSig []byte) bool {
-	var sig Multisignature
+func (pk *PubKeyMultisigThreshold) VerifyBytes(msg []byte, marshalledSig []byte) bool {
+	var sig *Multisignature
 	err := cdc.UnmarshalBinaryBare(marshalledSig, &sig)
 	if err != nil {
 		return false
@@ -63,19 +64,19 @@ func (pk PubKeyMultisigThreshold) VerifyBytes(msg []byte, marshalledSig []byte)
 }

 // Bytes returns the amino encoded version of the PubKeyMultisigThreshold
-func (pk PubKeyMultisigThreshold) Bytes() []byte {
+func (pk *PubKeyMultisigThreshold) Bytes() []byte {
 	return cdc.MustMarshalBinaryBare(pk)
 }

 // Address returns tmhash(PubKeyMultisigThreshold.Bytes())
-func (pk PubKeyMultisigThreshold) Address() crypto.Address {
-	return crypto.AddressHash(pk.Bytes())
+func (pk *PubKeyMultisigThreshold) Address() crypto.Address {
+	return crypto.Address(tmhash.Sum(pk.Bytes()))
 }

 // Equals returns true iff pk and other both have the same number of keys, and
 // all constituent keys are the same, and in the same order.
-func (pk PubKeyMultisigThreshold) Equals(other crypto.PubKey) bool {
-	otherKey, sameType := other.(PubKeyMultisigThreshold)
+func (pk *PubKeyMultisigThreshold) Equals(other crypto.PubKey) bool {
+	otherKey, sameType := other.(*PubKeyMultisigThreshold)
 	if !sameType {
 		return false
 	}
--- a/crypto/multisig/threshold_pubkey_test.go
+++ b/crypto/multisig/threshold_pubkey_test.go
@@ -82,7 +82,7 @@ func TestMultiSigPubKeyEquality(t *testing.T) {
 	msg := []byte{1, 2, 3, 4}
 	pubkeys, _ := generatePubKeysAndSignatures(5, msg)
 	multisigKey := NewPubKeyMultisigThreshold(2, pubkeys)
-	var unmarshalledMultisig PubKeyMultisigThreshold
+	var unmarshalledMultisig *PubKeyMultisigThreshold
 	cdc.MustUnmarshalBinaryBare(multisigKey.Bytes(), &unmarshalledMultisig)
 	require.True(t, multisigKey.Equals(unmarshalledMultisig))

@@ -95,29 +95,6 @@ func TestMultiSigPubKeyEquality(t *testing.T) {
 	require.False(t, multisigKey.Equals(multisigKey2))
 }

-func TestAddress(t *testing.T) {
-	msg := []byte{1, 2, 3, 4}
-	pubkeys, _ := generatePubKeysAndSignatures(5, msg)
-	multisigKey := NewPubKeyMultisigThreshold(2, pubkeys)
-	require.Len(t, multisigKey.Address().Bytes(), 20)
-}
-
-func TestPubKeyMultisigThresholdAminoToIface(t *testing.T) {
-	msg := []byte{1, 2, 3, 4}
-	pubkeys, _ := generatePubKeysAndSignatures(5, msg)
-	multisigKey := NewPubKeyMultisigThreshold(2, pubkeys)
-
-	ab, err := cdc.MarshalBinaryLengthPrefixed(multisigKey)
-	require.NoError(t, err)
-	// like other crypto.Pubkey implementations (e.g. ed25519.PubKeyEd25519),
-	// PubKeyMultisigThreshold should be deserializable into a crypto.PubKey:
-	var pubKey crypto.PubKey
-	err = cdc.UnmarshalBinaryLengthPrefixed(ab, &pubKey)
-	require.NoError(t, err)
-
-	require.Equal(t, multisigKey, pubKey)
-}
-
 func generatePubKeysAndSignatures(n int, msg []byte) (pubkeys []crypto.PubKey, signatures [][]byte) {
 	pubkeys = make([]crypto.PubKey, n)
 	signatures = make([][]byte, n)
--- a/crypto/multisig/wire.go
+++ b/crypto/multisig/wire.go
@@ -20,7 +20,7 @@ func init() {
 	cdc.RegisterConcrete(PubKeyMultisigThreshold{},
 		PubKeyMultisigThresholdAminoRoute, nil)
 	cdc.RegisterConcrete(ed25519.PubKeyEd25519{},
-		ed25519.PubKeyAminoName, nil)
+		ed25519.PubKeyAminoRoute, nil)
 	cdc.RegisterConcrete(secp256k1.PubKeySecp256k1{},
-		secp256k1.PubKeyAminoName, nil)
+		secp256k1.PubKeyAminoRoute, nil)
 }
--- a/crypto/random.go
+++ b/crypto/random.go
@@ -1,11 +1,42 @@
 package crypto

 import (
+	"crypto/cipher"
 	crand "crypto/rand"
+	"crypto/sha256"
 	"encoding/hex"
 	"io"
+	"sync"
+
+	"golang.org/x/crypto/chacha20poly1305"
 )

+// NOTE: This is ignored for now until we have time
+// to properly review the MixEntropy function - https://github.com/tendermint/tendermint/issues/2099.
+//
+// The randomness here is derived from xoring a chacha20 keystream with
+// output from crypto/rand's OS Entropy Reader. (Due to fears of the OS'
+// entropy being backdoored)
+//
+// For forward secrecy of produced randomness, the internal chacha key is hashed
+// and thereby rotated after each call.
+var gRandInfo *randInfo
+
+func init() {
+	gRandInfo = &randInfo{}
+
+	// TODO: uncomment after reviewing MixEntropy -
+	// https://github.com/tendermint/tendermint/issues/2099
+	// gRandInfo.MixEntropy(randBytes(32)) // Init
+}
+
+// WARNING: This function needs review - https://github.com/tendermint/tendermint/issues/2099.
+// Mix additional bytes of randomness, e.g. from hardware, user-input, etc.
+// It is OK to call it multiple times.  It does not diminish security.
+func MixEntropy(seedBytes []byte) {
+	gRandInfo.MixEntropy(seedBytes)
+}
+
 // This only uses the OS's randomness
 func randBytes(numBytes int) []byte {
 	b := make([]byte, numBytes)
@@ -21,6 +52,19 @@ func CRandBytes(numBytes int) []byte {
 	return randBytes(numBytes)
 }

+/* TODO: uncomment after reviewing MixEntropy - https://github.com/tendermint/tendermint/issues/2099
+// This uses the OS and the Seed(s).
+func CRandBytes(numBytes int) []byte {
+	return randBytes(numBytes)
+		b := make([]byte, numBytes)
+		_, err := gRandInfo.Read(b)
+		if err != nil {
+			panic(err)
+		}
+		return b
+}
+*/
+
 // CRandHex returns a hex encoded string that's floor(numDigits/2) * 2 long.
 //
 // Note: CRandHex(24) gives 96 bits of randomness that
@@ -33,3 +77,63 @@ func CRandHex(numDigits int) string {
 func CReader() io.Reader {
 	return crand.Reader
 }
+
+/* TODO: uncomment after reviewing MixEntropy - https://github.com/tendermint/tendermint/issues/2099
+// Returns a crand.Reader mixed with user-supplied entropy
+func CReader() io.Reader {
+	return gRandInfo
+}
+*/
+
+//--------------------------------------------------------------------------------
+
+type randInfo struct {
+	mtx       sync.Mutex
+	seedBytes [chacha20poly1305.KeySize]byte
+	chacha    cipher.AEAD
+	reader    io.Reader
+}
+
+// You can call this as many times as you'd like.
+// XXX/TODO: review - https://github.com/tendermint/tendermint/issues/2099
+func (ri *randInfo) MixEntropy(seedBytes []byte) {
+	ri.mtx.Lock()
+	defer ri.mtx.Unlock()
+	// Make new ri.seedBytes using passed seedBytes and current ri.seedBytes:
+	// ri.seedBytes = sha256( seedBytes || ri.seedBytes )
+	h := sha256.New()
+	h.Write(seedBytes)
+	h.Write(ri.seedBytes[:])
+	hashBytes := h.Sum(nil)
+	copy(ri.seedBytes[:], hashBytes)
+	chacha, err := chacha20poly1305.New(ri.seedBytes[:])
+	if err != nil {
+		panic("Initializing chacha20 failed")
+	}
+	ri.chacha = chacha
+	// Create new reader
+	ri.reader = &cipher.StreamReader{S: ri, R: crand.Reader}
+}
+
+func (ri *randInfo) XORKeyStream(dst, src []byte) {
+	// nonce being 0 is safe due to never re-using a key.
+	emptyNonce := make([]byte, 12)
+	tmpDst := ri.chacha.Seal([]byte{}, emptyNonce, src, []byte{0})
+	// this removes the poly1305 tag as well, since chacha is a stream cipher
+	// and we truncate at input length.
+	copy(dst, tmpDst[:len(src)])
+	// hash seedBytes for forward secrecy, and initialize new chacha instance
+	newSeed := sha256.Sum256(ri.seedBytes[:])
+	chacha, err := chacha20poly1305.New(newSeed[:])
+	if err != nil {
+		panic("Initializing chacha20 failed")
+	}
+	ri.chacha = chacha
+}
+
+func (ri *randInfo) Read(b []byte) (n int, err error) {
+	ri.mtx.Lock()
+	n, err = ri.reader.Read(b)
+	ri.mtx.Unlock()
+	return
+}
--- a/crypto/secp256k1/secp256k1.go
+++ b/crypto/secp256k1/secp256k1.go
@@ -6,21 +6,18 @@ import (
 	"crypto/subtle"
 	"fmt"
 	"io"
-	"math/big"
-
-	"golang.org/x/crypto/ripemd160"
-
-	secp256k1 "github.com/btcsuite/btcd/btcec"

+	secp256k1 "github.com/tendermint/btcd/btcec"
 	amino "github.com/tendermint/go-amino"
+	"golang.org/x/crypto/ripemd160" // forked to github.com/tendermint/crypto

 	"github.com/tendermint/tendermint/crypto"
 )

 //-------------------------------------
 const (
-	PrivKeyAminoName = "tendermint/PrivKeySecp256k1"
-	PubKeyAminoName  = "tendermint/PubKeySecp256k1"
+	PrivKeyAminoRoute = "tendermint/PrivKeySecp256k1"
+	PubKeyAminoRoute  = "tendermint/PubKeySecp256k1"
 )

 var cdc = amino.NewCodec()
@@ -28,11 +25,11 @@ var cdc = amino.NewCodec()
 func init() {
 	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
 	cdc.RegisterConcrete(PubKeySecp256k1{},
-		PubKeyAminoName, nil)
+		PubKeyAminoRoute, nil)

 	cdc.RegisterInterface((*crypto.PrivKey)(nil), nil)
 	cdc.RegisterConcrete(PrivKeySecp256k1{},
-		PrivKeyAminoName, nil)
+		PrivKeyAminoRoute, nil)
 }

 //-------------------------------------
@@ -47,6 +44,16 @@ func (privKey PrivKeySecp256k1) Bytes() []byte {
 	return cdc.MustMarshalBinaryBare(privKey)
 }

+// Sign creates an ECDSA signature on curve Secp256k1, using SHA256 on the msg.
+func (privKey PrivKeySecp256k1) Sign(msg []byte) ([]byte, error) {
+	priv, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey[:])
+	sig, err := priv.Sign(crypto.Sha256(msg))
+	if err != nil {
+		return nil, err
+	}
+	return sig.Serialize(), nil
+}
+
 // PubKey performs the point-scalar multiplication from the privKey on the
 // generator point to get the pubkey.
 func (privKey PrivKeySecp256k1) PubKey() crypto.PubKey {
@@ -66,61 +73,32 @@ func (privKey PrivKeySecp256k1) Equals(other crypto.PrivKey) bool {
 }

 // GenPrivKey generates a new ECDSA private key on curve secp256k1 private key.
-// It uses OS randomness to generate the private key.
+// It uses OS randomness in conjunction with the current global random seed
+// in tendermint/libs/common to generate the private key.
 func GenPrivKey() PrivKeySecp256k1 {
 	return genPrivKey(crypto.CReader())
 }

 // genPrivKey generates a new secp256k1 private key using the provided reader.
 func genPrivKey(rand io.Reader) PrivKeySecp256k1 {
-	var privKeyBytes [32]byte
-	d := new(big.Int)
-	for {
-		privKeyBytes = [32]byte{}
-		_, err := io.ReadFull(rand, privKeyBytes[:])
-		if err != nil {
-			panic(err)
-		}
-
-		d.SetBytes(privKeyBytes[:])
-		// break if we found a valid point (i.e. > 0 and < N == curverOrder)
-		isValidFieldElement := 0 < d.Sign() && d.Cmp(secp256k1.S256().N) < 0
-		if isValidFieldElement {
-			break
-		}
+	privKeyBytes := [32]byte{}
+	_, err := io.ReadFull(rand, privKeyBytes[:])
+	if err != nil {
+		panic(err)
 	}
-
+	// crypto.CRandBytes is guaranteed to be 32 bytes long, so it can be
+	// casted to PrivKeySecp256k1.
 	return PrivKeySecp256k1(privKeyBytes)
 }

-var one = new(big.Int).SetInt64(1)
-
 // GenPrivKeySecp256k1 hashes the secret with SHA2, and uses
 // that 32 byte output to create the private key.
-//
-// It makes sure the private key is a valid field element by setting:
-//
-// c = sha256(secret)
-// k = (c mod (n − 1)) + 1, where n = curve order.
-//
 // NOTE: secret should be the output of a KDF like bcrypt,
 // if it's derived from user input.
 func GenPrivKeySecp256k1(secret []byte) PrivKeySecp256k1 {
-	secHash := sha256.Sum256(secret)
-	// to guarantee that we have a valid field element, we use the approach of:
-	// "Suite B Implementer’s Guide to FIPS 186-3", A.2.1
-	// https://apps.nsa.gov/iaarchive/library/ia-guidance/ia-solutions-for-classified/algorithm-guidance/suite-b-implementers-guide-to-fips-186-3-ecdsa.cfm
-	// see also https://github.com/golang/go/blob/0380c9ad38843d523d9c9804fe300cb7edd7cd3c/src/crypto/ecdsa/ecdsa.go#L89-L101
-	fe := new(big.Int).SetBytes(secHash[:])
-	n := new(big.Int).Sub(secp256k1.S256().N, one)
-	fe.Mod(fe, n)
-	fe.Add(fe, one)
-
-	feB := fe.Bytes()
-	var privKey32 [32]byte
-	// copy feB over to fixed 32 byte privKey32 and pad (if necessary)
-	copy(privKey32[32-len(feB):32], feB)
-
+	privKey32 := sha256.Sum256(secret)
+	// sha256.Sum256() is guaranteed to be 32 bytes long, so it can be
+	// casted to PrivKeySecp256k1.
 	return PrivKeySecp256k1(privKey32)
 }

@@ -159,6 +137,20 @@ func (pubKey PubKeySecp256k1) Bytes() []byte {
 	return bz
 }

+func (pubKey PubKeySecp256k1) VerifyBytes(msg []byte, sig []byte) bool {
+	pub, err := secp256k1.ParsePubKey(pubKey[:], secp256k1.S256())
+	if err != nil {
+		return false
+	}
+	parsedSig, err := secp256k1.ParseSignature(sig[:], secp256k1.S256())
+	if err != nil {
+		return false
+	}
+	// Underlying library ensures that this signature is in canonical form, to
+	// prevent Secp256k1 malleability from altering the sign of the s term.
+	return parsedSig.Verify(crypto.Sha256(msg), pub)
+}
+
 func (pubKey PubKeySecp256k1) String() string {
 	return fmt.Sprintf("PubKeySecp256k1{%X}", pubKey[:])
 }
--- a/crypto/secp256k1/secp256k1_cgo.go
+++ b/crypto/secp256k1/secp256k1_cgo.go
@@ -1,24 +0,0 @@
-// +build libsecp256k1
-
-package secp256k1
-
-import (
-	"github.com/ethereum/go-ethereum/crypto/secp256k1"
-
-	"github.com/tendermint/tendermint/crypto"
-)
-
-// Sign creates an ECDSA signature on curve Secp256k1, using SHA256 on the msg.
-func (privKey PrivKeySecp256k1) Sign(msg []byte) ([]byte, error) {
-	rsv, err := secp256k1.Sign(crypto.Sha256(msg), privKey[:])
-	if err != nil {
-		return nil, err
-	}
-	// we do not need v  in r||s||v:
-	rs := rsv[:len(rsv)-1]
-	return rs, nil
-}
-
-func (pubKey PubKeySecp256k1) VerifyBytes(msg []byte, sig []byte) bool {
-	return secp256k1.VerifySignature(pubKey[:], crypto.Sha256(msg), sig)
-}
--- a/crypto/secp256k1/secp256k1_cgo_test.go
+++ b/crypto/secp256k1/secp256k1_cgo_test.go
@@ -1,39 +0,0 @@
-// +build libsecp256k1
-
-package secp256k1
-
-import (
-	"github.com/magiconair/properties/assert"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestPrivKeySecp256k1SignVerify(t *testing.T) {
-	msg := []byte("A.1.2 ECC Key Pair Generation by Testing Candidates")
-	priv := GenPrivKey()
-	tests := []struct {
-		name             string
-		privKey          PrivKeySecp256k1
-		wantSignErr      bool
-		wantVerifyPasses bool
-	}{
-		{name: "valid sign-verify round", privKey: priv, wantSignErr: false, wantVerifyPasses: true},
-		{name: "invalid private key", privKey: [32]byte{}, wantSignErr: true, wantVerifyPasses: false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := tt.privKey.Sign(msg)
-			if tt.wantSignErr {
-				require.Error(t, err)
-				t.Logf("Got error: %s", err)
-				return
-			}
-			require.NoError(t, err)
-			require.NotNil(t, got)
-
-			pub := tt.privKey.PubKey()
-			assert.Equal(t, tt.wantVerifyPasses, pub.VerifyBytes(msg, got))
-		})
-	}
-}
--- a/crypto/secp256k1/secp256k1_internal_test.go
+++ b/crypto/secp256k1/secp256k1_internal_test.go
@@ -1,45 +0,0 @@
-package secp256k1
-
-import (
-	"bytes"
-	"math/big"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	underlyingSecp256k1 "github.com/btcsuite/btcd/btcec"
-)
-
-func Test_genPrivKey(t *testing.T) {
-
-	empty := make([]byte, 32)
-	oneB := big.NewInt(1).Bytes()
-	onePadded := make([]byte, 32)
-	copy(onePadded[32-len(oneB):32], oneB)
-	t.Logf("one padded: %v, len=%v", onePadded, len(onePadded))
-
-	validOne := append(empty, onePadded...)
-	tests := []struct {
-		name        string
-		notSoRand   []byte
-		shouldPanic bool
-	}{
-		{"empty bytes (panics because 1st 32 bytes are zero and 0 is not a valid field element)", empty, true},
-		{"curve order: N", underlyingSecp256k1.S256().N.Bytes(), true},
-		{"valid because 0 < 1 < N", validOne, false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if tt.shouldPanic {
-				require.Panics(t, func() {
-					genPrivKey(bytes.NewReader(tt.notSoRand))
-				})
-				return
-			}
-			got := genPrivKey(bytes.NewReader(tt.notSoRand))
-			fe := new(big.Int).SetBytes(got[:])
-			require.True(t, fe.Cmp(underlyingSecp256k1.S256().N) < 0)
-			require.True(t, fe.Sign() > 0)
-		})
-	}
-}
--- a/crypto/secp256k1/secp256k1_nocgo.go
+++ b/crypto/secp256k1/secp256k1_nocgo.go
@@ -1,70 +0,0 @@
-// +build !libsecp256k1
-
-package secp256k1
-
-import (
-	"math/big"
-
-	secp256k1 "github.com/btcsuite/btcd/btcec"
-
-	"github.com/tendermint/tendermint/crypto"
-)
-
-// used to reject malleable signatures
-// see:
-//  - https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/signature_nocgo.go#L90-L93
-//  - https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/crypto.go#L39
-var secp256k1halfN = new(big.Int).Rsh(secp256k1.S256().N, 1)
-
-// Sign creates an ECDSA signature on curve Secp256k1, using SHA256 on the msg.
-// The returned signature will be of the form R || S (in lower-S form).
-func (privKey PrivKeySecp256k1) Sign(msg []byte) ([]byte, error) {
-	priv, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey[:])
-	sig, err := priv.Sign(crypto.Sha256(msg))
-	if err != nil {
-		return nil, err
-	}
-	sigBytes := serializeSig(sig)
-	return sigBytes, nil
-}
-
-// VerifyBytes verifies a signature of the form R || S.
-// It rejects signatures which are not in lower-S form.
-func (pubKey PubKeySecp256k1) VerifyBytes(msg []byte, sigStr []byte) bool {
-	if len(sigStr) != 64 {
-		return false
-	}
-	pub, err := secp256k1.ParsePubKey(pubKey[:], secp256k1.S256())
-	if err != nil {
-		return false
-	}
-	// parse the signature:
-	signature := signatureFromBytes(sigStr)
-	// Reject malleable signatures. libsecp256k1 does this check but btcec doesn't.
-	// see: https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/signature_nocgo.go#L90-L93
-	if signature.S.Cmp(secp256k1halfN) > 0 {
-		return false
-	}
-	return signature.Verify(crypto.Sha256(msg), pub)
-}
-
-// Read Signature struct from R || S. Caller needs to ensure
-// that len(sigStr) == 64.
-func signatureFromBytes(sigStr []byte) *secp256k1.Signature {
-	return &secp256k1.Signature{
-		R: new(big.Int).SetBytes(sigStr[:32]),
-		S: new(big.Int).SetBytes(sigStr[32:64]),
-	}
-}
-
-// Serialize signature to R || S.
-// R, S are padded to 32 bytes respectively.
-func serializeSig(sig *secp256k1.Signature) []byte {
-	rBytes := sig.R.Bytes()
-	sBytes := sig.S.Bytes()
-	sigBytes := make([]byte, 64)
-	// 0 pad the byte arrays from the left if they aren't big enough.
-	copy(sigBytes[32-len(rBytes):32], rBytes)
-	copy(sigBytes[64-len(sBytes):64], sBytes)
-	return sigBytes
-}
--- a/crypto/secp256k1/secp256k1_nocgo_test.go
+++ b/crypto/secp256k1/secp256k1_nocgo_test.go
@@ -1,38 +0,0 @@
-// +build !libsecp256k1
-
-package secp256k1
-
-import (
-	"testing"
-
-	secp256k1 "github.com/btcsuite/btcd/btcec"
-	"github.com/stretchr/testify/require"
-)
-
-// Ensure that signature verification works, and that
-// non-canonical signatures fail.
-// Note: run with CGO_ENABLED=0 or go test -tags !cgo.
-func TestSignatureVerificationAndRejectUpperS(t *testing.T) {
-	msg := []byte("We have lingered long enough on the shores of the cosmic ocean.")
-	for i := 0; i < 500; i++ {
-		priv := GenPrivKey()
-		sigStr, err := priv.Sign(msg)
-		require.NoError(t, err)
-		sig := signatureFromBytes(sigStr)
-		require.False(t, sig.S.Cmp(secp256k1halfN) > 0)
-
-		pub := priv.PubKey()
-		require.True(t, pub.VerifyBytes(msg, sigStr))
-
-		// malleate:
-		sig.S.Sub(secp256k1.S256().CurveParams.N, sig.S)
-		require.True(t, sig.S.Cmp(secp256k1halfN) > 0)
-		malSigStr := serializeSig(sig)
-
-		require.False(t, pub.VerifyBytes(msg, malSigStr),
-			"VerifyBytes incorrect with malleated & invalid S. sig=%v, key=%v",
-			sig,
-			priv,
-		)
-	}
-}
--- a/crypto/secp256k1/secpk256k1_test.go
+++ b/crypto/secp256k1/secpk256k1_test.go
@@ -2,7 +2,6 @@ package secp256k1_test

 import (
 	"encoding/hex"
-	"math/big"
 	"testing"

 	"github.com/btcsuite/btcutil/base58"
@@ -12,7 +11,7 @@ import (
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/secp256k1"

-	underlyingSecp256k1 "github.com/btcsuite/btcd/btcec"
+	underlyingSecp256k1 "github.com/tendermint/btcd/btcec"
 )

 type keyData struct {
@@ -85,28 +84,3 @@ func TestSecp256k1LoadPrivkeyAndSerializeIsIdentity(t *testing.T) {
 		require.Equal(t, privKeyBytes[:], serializedBytes)
 	}
 }
-
-func TestGenPrivKeySecp256k1(t *testing.T) {
-	// curve oder N
-	N := underlyingSecp256k1.S256().N
-	tests := []struct {
-		name   string
-		secret []byte
-	}{
-		{"empty secret", []byte{}},
-		{"some long secret", []byte("We live in a society exquisitely dependent on science and technology, in which hardly anyone knows anything about science and technology.")},
-		{"another seed used in cosmos tests #1", []byte{0}},
-		{"another seed used in cosmos tests #2", []byte("mySecret")},
-		{"another seed used in cosmos tests #3", []byte("")},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotPrivKey := secp256k1.GenPrivKeySecp256k1(tt.secret)
-			require.NotNil(t, gotPrivKey)
-			// interpret as a big.Int and make sure it is a valid field element:
-			fe := new(big.Int).SetBytes(gotPrivKey[:])
-			require.True(t, fe.Cmp(N) < 0)
-			require.True(t, fe.Sign() > 0)
-		})
-	}
-}
--- a/crypto/xchacha20poly1305/xchachapoly.go
+++ b/crypto/xchacha20poly1305/xchachapoly.go
@@ -8,7 +8,7 @@ import (
 	"errors"
 	"fmt"

-	"golang.org/x/crypto/chacha20poly1305"
+	"golang.org/x/crypto/chacha20poly1305" // forked to github.com/tendermint/crypto
 )

 // Implements crypto.AEAD
--- a/crypto/xsalsa20symmetric/symmetric.go
+++ b/crypto/xsalsa20symmetric/symmetric.go
@@ -4,7 +4,7 @@ import (
 	"errors"
 	"fmt"

-	"golang.org/x/crypto/nacl/secretbox"
+	"golang.org/x/crypto/nacl/secretbox" // forked to github.com/tendermint/crypto

 	"github.com/tendermint/tendermint/crypto"
 	cmn "github.com/tendermint/tendermint/libs/common"
@@ -17,6 +17,7 @@ const secretLen = 32

 // secret must be 32 bytes long. Use something like Sha256(Bcrypt(passphrase))
 // The ciphertext is (secretbox.Overhead + 24) bytes longer than the plaintext.
+// NOTE: call crypto.MixEntropy() first.
 func EncryptSymmetric(plaintext []byte, secret []byte) (ciphertext []byte) {
 	if len(secret) != secretLen {
 		cmn.PanicSanity(fmt.Sprintf("Secret must be 32 bytes long, got len %v", len(secret)))
--- a/crypto/xsalsa20symmetric/symmetric_test.go
+++ b/crypto/xsalsa20symmetric/symmetric_test.go
@@ -6,13 +6,15 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"

-	"golang.org/x/crypto/bcrypt"
+	"golang.org/x/crypto/bcrypt" // forked to github.com/tendermint/crypto

 	"github.com/tendermint/tendermint/crypto"
 )

 func TestSimple(t *testing.T) {

+	crypto.MixEntropy([]byte("someentropy"))
+
 	plaintext := []byte("sometext")
 	secret := []byte("somesecretoflengththirtytwo===32")
 	ciphertext := EncryptSymmetric(plaintext, secret)
@@ -24,9 +26,13 @@ func TestSimple(t *testing.T) {

 func TestSimpleWithKDF(t *testing.T) {

+	crypto.MixEntropy([]byte("someentropy"))
+
 	plaintext := []byte("sometext")
 	secretPass := []byte("somesecret")
-	secret, err := bcrypt.GenerateFromPassword(secretPass, 12)
+	salt := []byte("somesaltsomesalt") // len 16
+	// NOTE: we use a fork of x/crypto so we can inject our own randomness for salt
+	secret, err := bcrypt.GenerateFromPassword(salt, secretPass, 12)
 	if err != nil {
 		t.Error(err)
 	}
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -8,21 +8,13 @@ module.exports = {
    lineNumbers: true
  },
  themeConfig: {
-    repo: "tendermint/tendermint",
-    editLinks: true,
-    docsDir: "docs",
-    docsBranch: "develop",
-    editLinkText: 'Edit this page on Github',
    lastUpdated: true,
    algolia: {
      apiKey: '59f0e2deb984aa9cdf2b3a5fd24ac501',
      indexName: 'tendermint',
      debug: false
    },
-    nav: [
-      { text: "Back to Tendermint", link: "https://tendermint.com" },
-      { text: "RPC", link: "https://tendermint.com/rpc/" }
-    ],
+    nav: [{ text: "Back to Tendermint", link: "https://tendermint.com" }],
    sidebar: [
      {
        title: "Introduction",
@@ -34,20 +26,6 @@ module.exports = {
          "/introduction/what-is-tendermint"
        ]
      },
-      {
-        title: "Apps",
-        collapsable: false,
-        children: [
-          "/app-dev/getting-started",
-          "/app-dev/abci-cli",
-          "/app-dev/app-architecture",
-          "/app-dev/app-development",
-          "/app-dev/subscribing-to-events-via-websocket",
-          "/app-dev/indexing-transactions",
-          "/app-dev/abci-spec",
-          "/app-dev/ecosystem"
-        ]
-      },
      {
        title: "Tendermint Core",
        collapsable: false,
@@ -66,6 +44,15 @@ module.exports = {
          "/tendermint-core/validators"
        ]
      },
+      {
+        title: "Tools",
+        collapsable: false,
+        children:  [
+	  "/tools/",
+	  "/tools/benchmarking",
+	  "/tools/monitoring"
+	]
+      },
      {
        title: "Networks",
        collapsable: false,
@@ -76,13 +63,17 @@ module.exports = {
        ]
      },
      {
-        title: "Tools",
+        title: "Apps",
        collapsable: false,
-        children:  [
-          "/tools/",
-          "/tools/benchmarking",
-          "/tools/monitoring",
-          "/tools/remote-signer-validation"
+        children: [
+          "/app-dev/getting-started",
+          "/app-dev/abci-cli",
+          "/app-dev/app-architecture",
+          "/app-dev/app-development",
+          "/app-dev/subscribing-to-events-via-websocket",
+          "/app-dev/indexing-transactions",
+          "/app-dev/abci-spec",
+          "/app-dev/ecosystem"
        ]
      },
      {
--- a/docs/DOCS_README.md
+++ b/docs/DOCS_README.md
@@ -12,10 +12,10 @@ respectively.

 ## How It Works

-There is a CircleCI job listening for changes in the `/docs` directory, on both
+There is a Jenkins job listening for changes in the `/docs` directory, on both
 the  `master` and `develop` branches. Any updates to files in this directory
 on those branches will automatically trigger a website deployment. Under the hood,
-the private website repository has a `make build-docs` target consumed by a CircleCI job in that repo.
+a private website repository has make targets consumed by a standard Jenkins task.

 ## README

@@ -93,10 +93,6 @@ python -m SimpleHTTPServer 8080

 then navigate to localhost:8080 in your browser.

-## Search
-
-We are using [Algolia](https://www.algolia.com) to power full-text search. This uses a public API search-only key in the `config.js` as well as a [tendermint.json](https://github.com/algolia/docsearch-configs/blob/master/configs/tendermint.json) configuration file that we can update with PRs.
-
 ## Consistency

 Because the build processes are identical (as is the information contained herein), this file should be kept in sync as
--- a/docs/app-dev/app-architecture.md
+++ b/docs/app-dev/app-architecture.md
@@ -45,6 +45,6 @@ Tendermint.
 See the following for more extensive documentation:

 - [Interchain Standard for the Light-Client REST API](https://github.com/cosmos/cosmos-sdk/pull/1028)
- [Tendermint RPC Docs](https://tendermint.com/rpc/)
+- [Tendermint RPC Docs](https://tendermint.github.io/slate/)
 - [Tendermint in Production](../tendermint-core/running-in-production.md)
 - [ABCI spec](./abci-spec.md)
--- a/docs/app-dev/ecosystem.json
+++ b/docs/app-dev/ecosystem.json
@@ -63,13 +63,6 @@
      "author": "Zach Balder",
      "description": "Public service reporting and tracking"
    },
-    {
-      "name": "ParadigmCore",
-      "url": "https://github.com/ParadigmFoundation/ParadigmCore",
-      "language": "TypeScript",
-      "author": "Paradigm Labs",
-      "description": "Reference implementation of the Paradigm Protocol, and OrderStream network client."
-    },
    {
      "name": "Passchain",
      "url": "https://github.com/trusch/passchain",
--- a/docs/app-dev/indexing-transactions.md
+++ b/docs/app-dev/indexing-transactions.md
@@ -78,7 +78,7 @@ endpoint:
 curl "localhost:26657/tx_search?query=\"account.name='igor'\"&prove=true"
 ```

-Check out [API docs](https://tendermint.com/rpc/#txsearch)
+Check out [API docs](https://tendermint.github.io/slate/?shell#txsearch)
 for more information on query syntax and other options.

 ## Subscribing to transactions
@@ -97,5 +97,5 @@ by providing a query to `/subscribe` RPC endpoint.
 }
 ```

-Check out [API docs](https://tendermint.com/rpc/#subscribe) for
+Check out [API docs](https://tendermint.github.io/slate/#subscribe) for
 more information on query syntax and other options.
--- a/docs/architecture/adr-020-block-size.md
+++ b/docs/architecture/adr-020-block-size.md
@@ -7,7 +7,6 @@
 28-08-2018: Third version after Ethan's comments
 30-08-2018: AminoOverheadForBlock => MaxAminoOverheadForBlock
 31-08-2018: Bounding evidence and chain ID
-13-01-2019: Add section on MaxBytes vs MaxDataBytes

 ## Context

@@ -21,32 +20,6 @@ We should just remove MaxTxs all together and stick with MaxBytes, and have a
 But we can't just reap BlockSize.MaxBytes, since MaxBytes is for the entire block,
 not for the txs inside the block. There's extra amino overhead + the actual
 headers on top of the actual transactions + evidence + last commit.
-We could also consider using a MaxDataBytes instead of or in addition to MaxBytes.
-
-## MaxBytes vs MaxDataBytes
-
-The [PR #3045](https://github.com/tendermint/tendermint/pull/3045) suggested
-additional clarity/justification was necessary here, wither respect to the use
-of MaxDataBytes in addition to, or instead of, MaxBytes.
-
-MaxBytes provides a clear limit on the total size of a block that requires no
-additional calculation if you want to use it to bound resource usage, and there
-has been considerable discussions about optimizing tendermint around 1MB blocks.
-Regardless, we need some maximum on the size of a block so we can avoid
-unmarshalling blocks that are too big during the consensus, and it seems more
-straightforward to provide a single fixed number for this rather than a
-computation of "MaxDataBytes + everything else you need to make room for
-(signatures, evidence, header)". MaxBytes provides a simple bound so we can
-always say "blocks are less than X MB".
-
-Having both MaxBytes and MaxDataBytes feels like unnecessary complexity. It's
-not particularly surprising for MaxBytes to imply the maximum size of the
-entire block (not just txs), one just has to know that a block includes header,
-txs, evidence, votes. For more fine grained control over the txs included in the
-block, there is the MaxGas. In practice, the MaxGas may be expected to do most of
-the tx throttling, and the MaxBytes to just serve as an upper bound on the total
-size. Applications can use MaxGas as a MaxDataBytes by just taking the gas for
-every tx to be its size in bytes.

 ## Proposed solution

@@ -88,7 +61,7 @@ MaxXXX stayed the same.

 ## Status

-Accepted.
+Proposed.

 ## Consequences

--- a/docs/architecture/adr-030-consensus-refactor.md
+++ b/docs/architecture/adr-030-consensus-refactor.md
@@ -126,312 +126,6 @@ func TestConsensusXXX(t *testing.T) {
 }
 ```

-
-## Consensus Executor
-
-## Consensus Core
-
-```go
-type Event interface{}
-
-type EventNewHeight struct {
-    Height           int64
-    ValidatorId      int
-}
-
-type EventNewRound HeightAndRound
-
-type EventProposal struct {
-    Height           int64
-    Round            int
-    Timestamp        Time
-    BlockID          BlockID
-    POLRound         int
-    Sender           int   
-}
-
-type Majority23PrevotesBlock struct {
-    Height           int64
-    Round            int
-    BlockID          BlockID
-}
-
-type Majority23PrecommitBlock struct {
-    Height           int64
-    Round            int
-    BlockID          BlockID
-}
-
-type HeightAndRound struct {
-    Height           int64
-    Round            int
-}
-
-type Majority23PrevotesAny HeightAndRound
-type Majority23PrecommitAny HeightAndRound
-type TimeoutPropose HeightAndRound
-type TimeoutPrevotes HeightAndRound
-type TimeoutPrecommit HeightAndRound
-
-
-type Message interface{}
-
-type MessageProposal struct {
-    Height           int64
-    Round            int
-    BlockID          BlockID
-    POLRound         int
-}
-
-type VoteType int
-
-const (
-	VoteTypeUnknown VoteType = iota
-	Prevote
-	Precommit
-)
-
-
-type MessageVote struct {
-    Height           int64
-    Round            int
-    BlockID          BlockID
-    Type             VoteType
-}
-
-
-type MessageDecision struct {
-    Height           int64
-    Round            int
-    BlockID          BlockID
-}
-
-type TriggerTimeout struct {
-    Height           int64
-    Round            int
-    Duration         Duration
-}
-
-
-type RoundStep int
-
-const (
-	RoundStepUnknown RoundStep = iota
-	RoundStepPropose       
-	RoundStepPrevote
-	RoundStepPrecommit
-	RoundStepCommit
-)
-
-type State struct {
-	Height           int64
-	Round            int
-	Step             RoundStep
-	LockedValue      BlockID
-	LockedRound      int
-	ValidValue       BlockID
-	ValidRound       int
-	ValidatorId      int
-	ValidatorSetSize int
-}
-
-func proposer(height int64, round int) int {}
-func getValue() BlockID {}
-
-func Consensus(event Event, state State) (State, Message, TriggerTimeout) {
-    msg = nil
-    timeout = nil
-	switch event := event.(type) {
-    	case EventNewHeight:
-    		if event.Height > state.Height {
-    		    state.Height = event.Height
-    		    state.Round = -1
-    		    state.Step = RoundStepPropose
-    		    state.LockedValue = nil
-    		    state.LockedRound = -1
-    		    state.ValidValue = nil
-    		    state.ValidRound = -1
-    		    state.ValidatorId = event.ValidatorId
-    		} 
-    	    return state, msg, timeout
-    	
-    	case EventNewRound:
-    		if event.Height == state.Height and event.Round > state.Round {
-               state.Round = eventRound
-               state.Step = RoundStepPropose
-               if proposer(state.Height, state.Round) == state.ValidatorId {
-                   proposal = state.ValidValue
-                   if proposal == nil {
-                   	    proposal = getValue()
-                   }
-                   msg =  MessageProposal { state.Height, state.Round, proposal, state.ValidRound }
-               }
-               timeout = TriggerTimeout { state.Height, state.Round, timeoutPropose(state.Round) }
-            }
-    	    return state, msg, timeout
-    	
-    	case EventProposal:
-    		if event.Height == state.Height and event.Round == state.Round and 
-    	       event.Sender == proposal(state.Height, state.Round) and state.Step == RoundStepPropose { 
-    	       	if event.POLRound >= state.LockedRound or event.BlockID == state.BlockID or state.LockedRound == -1 {
-    	       		msg = MessageVote { state.Height, state.Round, event.BlockID, Prevote }
-    	       	}
-    	       	state.Step = RoundStepPrevote
-            }
-    	    return state, msg, timeout
-    	
-    	case TimeoutPropose:
-    		if event.Height == state.Height and event.Round == state.Round and state.Step == RoundStepPropose {
-    		    msg = MessageVote { state.Height, state.Round, nil, Prevote }
-    			state.Step = RoundStepPrevote
-            }
-    	    return state, msg, timeout
-    	
-    	case Majority23PrevotesBlock:
-    		if event.Height == state.Height and event.Round == state.Round and state.Step >= RoundStepPrevote and event.Round > state.ValidRound {
-    		    state.ValidRound = event.Round
-    		    state.ValidValue = event.BlockID
-    		    if state.Step == RoundStepPrevote {
-    		    	state.LockedRound = event.Round
-    		    	state.LockedValue = event.BlockID
-    		    	msg = MessageVote { state.Height, state.Round, event.BlockID, Precommit }
-    		    	state.Step = RoundStepPrecommit
-    		    }
-            }
-    	    return state, msg, timeout
-    	
-    	case Majority23PrevotesAny:
-    		if event.Height == state.Height and event.Round == state.Round and state.Step == RoundStepPrevote {
-    			timeout = TriggerTimeout { state.Height, state.Round, timeoutPrevote(state.Round) }
-    		}
-    	    return state, msg, timeout
-    	
-    	case TimeoutPrevote:
-    		if event.Height == state.Height and event.Round == state.Round and state.Step == RoundStepPrevote {
-    			msg = MessageVote { state.Height, state.Round, nil, Precommit }
-    			state.Step = RoundStepPrecommit
-    		}
-    	    return state, msg, timeout
-    	
-    	case Majority23PrecommitBlock:
-    		if event.Height == state.Height {
-    		    state.Step = RoundStepCommit
-    		    state.LockedValue = event.BlockID
-    		}
-    	    return state, msg, timeout
-    		
-    	case Majority23PrecommitAny:
-    		if event.Height == state.Height and event.Round == state.Round {
-    			timeout = TriggerTimeout { state.Height, state.Round, timeoutPrecommit(state.Round) }
-    		}
-    	    return state, msg, timeout
-    	
-    	case TimeoutPrecommit:
-            if event.Height == state.Height and event.Round == state.Round {
-            	state.Round = state.Round + 1
-            }
-    	    return state, msg, timeout
-	}
-}	
-
-func ConsensusExecutor() {
-	proposal = nil
-	votes = HeightVoteSet { Height: 1 }
-	state = State {
-		Height:       1
-		Round:        0          
-		Step:         RoundStepPropose
-		LockedValue:  nil
-		LockedRound:  -1
-		ValidValue:   nil
-		ValidRound:   -1
-	}
-	
-	event = EventNewHeight {1, id}
-	state, msg, timeout = Consensus(event, state)
-	
-	event = EventNewRound {state.Height, 0}
-	state, msg, timeout = Consensus(event, state)
-	
-	if msg != nil {
-		send msg
-	}
-	
-	if timeout != nil {
-		trigger timeout
-	}
-	
-	for {
-		select {
-		    case message := <- msgCh:
-		    	switch msg := message.(type) {
-		    	    case MessageProposal:
-		    	        
-		    	    case MessageVote:	
-		    	    	if msg.Height == state.Height {
-		    	    		newVote = votes.AddVote(msg)
-		    	    		if newVote {
-		    	    			switch msg.Type {
-                                	case Prevote:
-                                		prevotes = votes.Prevotes(msg.Round)
-                                		if prevotes.WeakCertificate() and msg.Round > state.Round {
-                                			event = EventNewRound { msg.Height, msg.Round }
-                                			state, msg, timeout = Consensus(event, state)
-                                			state = handleStateChange(state, msg, timeout)
-                                		}	
-                                		
-                                		if blockID, ok = prevotes.TwoThirdsMajority(); ok and blockID != nil {
-                                		    if msg.Round == state.Round and hasBlock(blockID) {
-                                		    	event = Majority23PrevotesBlock { msg.Height, msg.Round, blockID }
-                                		    	state, msg, timeout = Consensus(event, state)
-                                		    	state = handleStateChange(state, msg, timeout)
-                                		    } 
-                                		    if proposal != nil and proposal.POLRound == msg.Round and hasBlock(blockID) {
-                                		        event = EventProposal {
-                                                        Height: state.Height
-                                                        Round:  state.Round
-                                                        BlockID: blockID
-                                                        POLRound: proposal.POLRound
-                                                        Sender: message.Sender
-                                		        }
-                                		        state, msg, timeout = Consensus(event, state)
-                                		        state = handleStateChange(state, msg, timeout)
-                                		    }
-                                		}
-                                		
-                                		if prevotes.HasTwoThirdsAny() and msg.Round == state.Round {
-                                			event = Majority23PrevotesAny { msg.Height, msg.Round, blockID }
-                                			state, msg, timeout = Consensus(event, state)
-                                            state = handleStateChange(state, msg, timeout)
-                                		}
-                                		
-                                	case Precommit:	
-                                		
-		    	    		    }
-		    	    	    }
-		    	        }
-		    case timeout := <- timeoutCh:
-		    
-		    case block := <- blockCh:	
-		    	
-		}
-	}
-}
-	
-func handleStateChange(state, msg, timeout) State {
-	if state.Step == Commit {
-		state = ExecuteBlock(state.LockedValue)
-	}	
-	if msg != nil {
-		send msg
-	}	
-	if timeout != nil {
-		trigger timeout
-	}	
-}
-
-```
-
 ### Implementation roadmap

 * implement proposed implementation
--- a/docs/architecture/adr-033-pubsub.md
+++ b/docs/architecture/adr-033-pubsub.md
@@ -6,16 +6,10 @@ Author: Anton Kaliaev (@melekes)

 02-10-2018: Initial draft

-16-01-2019: Second version based on our conversation with Jae
-
-17-01-2019: Third version explaining how new design solves current issues
-
-25-01-2019: Fourth version to treat buffered and unbuffered channels differently
-
 ## 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
+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.

@@ -46,19 +40,9 @@ 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 publish msg in a new goroutine every time.
+delivery order will be A -> B), we can't use goroutines.

-We can also have a goroutine per subscriber, although we'd need to be careful
-with the number of subscribers. It's more difficult to implement as well +
-unclear if we'll benefit from it (cause we'd be forced to create N additional
-channels to distribute msg to these goroutines).
-
-### Non-blocking send
-
-There is also a question whenever we should have a non-blocking send.
-Currently, sends are blocking, so publishing to one client can block on
-publishing to another. This means a slow or unresponsive client can halt the
-system. Instead, we can use a non-blocking send:
+There is also a question whenever we should have a non-blocking send:

 ```go
 for each subscriber {
@@ -72,14 +56,15 @@ for each subscriber {
 ```

 This fixes the "slow client problem", but there is no way for a slow client to
-know if it had missed a message. We could return a second channel and close it
-to indicate subscription termination. On the other hand, if we're going to
-stick with blocking send, **devs must always ensure subscriber's handling code
-does not block**, which is a hard task to put on their shoulders.
+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

@@ -91,137 +76,36 @@ 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 and return a channel.
+can make capacity an argument.

 ## Decision

-### MsgAndTags
+Change Subscribe() function to return out channel:

-Use a `MsgAndTags` struct on the subscription channel to indicate what tags the
-msg matched.
+```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) {
 ```

-### Subscription Struct
-
-
-Change `Subscribe()` function to return a `Subscription` struct:
-
-```go
-type Subscription struct {
-  // private fields
-}
-
-func (s *Subscription) Out() <-chan MsgAndTags
-func (s *Subscription) Cancelled() <-chan struct{}
-func (s *Subscription) Err() error
-```
-
-`Out()` returns a channel onto which messages and tags are published.
-`Unsubscribe`/`UnsubscribeAll` does not close the channel to avoid clients from
-receiving a nil message.
-
-`Cancelled()` returns a channel that's closed when the subscription is terminated
-and supposed to be used in a select statement.
-
-If the channel returned by `Cancelled()` is not closed yet, `Err()` returns nil.
-If the channel is closed, `Err()` returns a non-nil error explaining why:
-`ErrUnsubscribed` if the subscriber choose to unsubscribe,
-`ErrOutOfCapacity` if the subscriber is not pulling messages fast enough and the channel returned by `Out()` became full.
-After `Err()` returns a non-nil error, successive calls to `Err() return the same error.
-
-```go
-subscription, err := pubsub.Subscribe(...)
-if err != nil {
-  // ...
-}
-for {
-select {
-  case msgAndTags <- subscription.Out():
-    // ...
-  case <-subscription.Cancelled():
-    return subscription.Err()
-}
-```
-
-### Capacity and Subscriptions
-
-Make the `Out()` channel buffered (with capacity 1) by default. In most cases, we want to
-terminate the slow subscriber. Only in rare cases, we want to block the pubsub
-(e.g. when debugging consensus). This should lower the chances of the pubsub
-being frozen.
-
-```go
-// outCap can be used to set capacity of Out channel
-// (1 by default, must be greater than 0).
-Subscribe(ctx context.Context, clientID string, query Query, outCap... int) (Subscription, error) {
-```
-
-Use a different function for an unbuffered channel:
-
-```go
-// Subscription uses an unbuffered channel. Publishing will block.
-SubscribeUnbuffered(ctx context.Context, clientID string, query Query) (Subscription, error) {
-```
-
-SubscribeUnbuffered should not be exposed to users.
-
-### Blocking/Nonblocking
-
-The publisher should treat these kinds of channels separately.
-It should block on unbuffered channels (for use with internal consensus events
-in the consensus tests) and not block on the buffered ones. If a client is too
-slow to keep up with it's messages, it's subscription is terminated:
-
-for each subscription {
-    out := subscription.outChan
-    if cap(out) == 0 {
-        // block on unbuffered channel
-        out <- msg
-    } else {
-        // don't block on buffered channels
-        select {
-            case out <- msg:
-            default:
-                // set the error, notify on the cancel chan
-                subscription.err = fmt.Errorf("client is too slow for msg)
-                close(subscription.cancelChan)
-
-                // ... unsubscribe and close out
-        }
-    }
-}
-
-### How this new design solves the current issues?
-
-[#951] ([#1880]):
-
-Because of non-blocking send, situation where we'll deadlock is not possible
-anymore. If the client stops reading messages, it will be removed.
-
-[#1879]:
-
-MsgAndTags is used now instead of a plain message.
-
-### Future problems and their possible solutions
-
-[#2826]
-
-One question I am still pondering about: how to prevent pubsub from slowing
-down consensus. We can increase the pubsub queue size (which is 0 now). Also,
-it's probably a good idea to limit the total number of subscribers.
-
-This can be made automatically. Say we set queue size to 1000 and, when it's >=
-80% full, refuse new subscriptions.
-
 ## Status

 In review
@@ -232,16 +116,7 @@ In review

 - more idiomatic interface
 - subscribers know what tags msg was published with
- subscribers aware of the reason their subscription was cancelled

 ### Negative

- (since v1) no concurrency when it comes to publishing messages
-
 ### Neutral
-
-
-[#951]: https://github.com/tendermint/tendermint/issues/951
-[#1879]: https://github.com/tendermint/tendermint/issues/1879
-[#1880]: https://github.com/tendermint/tendermint/issues/1880
-[#2826]: https://github.com/tendermint/tendermint/issues/2826
--- a/docs/networks/docker-compose.md
+++ b/docs/networks/docker-compose.md
@@ -1,17 +1,20 @@
 # Docker Compose

-With Docker Compose, you can spin up local testnets with a single command.
+With Docker Compose, we can spin up local testnets in a single command:
+
+```
+make localnet-start
+```

 ## Requirements

-1. [Install tendermint](/docs/introduction/install.md)
-2. [Install docker](https://docs.docker.com/engine/installation/)
-3. [Install docker-compose](https://docs.docker.com/compose/install/)
+- [Install tendermint](/docs/install.md)
+- [Install docker](https://docs.docker.com/engine/installation/)
+- [Install docker-compose](https://docs.docker.com/compose/install/)

 ## Build

-Build the `tendermint` binary and, optionally, the `tendermint/localnode`
-docker image.
+Build the `tendermint` binary and the `tendermint/localnode` docker image.

 Note the binary will be mounted into the container so it can be updated without
 rebuilding the image.
@@ -22,10 +25,11 @@ cd $GOPATH/src/github.com/tendermint/tendermint
 # Build the linux binary in ./build
 make build-linux

-# (optionally) Build tendermint/localnode image
+# Build tendermint/localnode image
 make build-docker-localnode
 ```

+
 ## Run a testnet

 To start a 4 node testnet run:
@@ -34,13 +38,9 @@ To start a 4 node testnet run:
 make localnet-start
 ```

-The nodes bind their RPC servers to ports 26657, 26660, 26662, and 26664 on the
-host.
-
+The nodes bind their RPC servers to ports 26657, 26660, 26662, and 26664 on the host.
 This file creates a 4-node network using the localnode image.
-
-The nodes of the network expose their P2P and RPC endpoints to the host machine
-on ports 26656-26657, 26659-26660, 26661-26662, and 26663-26664 respectively.
+The nodes of the network expose their P2P and RPC endpoints to the host machine on ports 26656-26657, 26659-26660, 26661-26662, and 26663-26664 respectively.

 To update the binary, just rebuild it and restart the nodes:

@@ -52,112 +52,34 @@ make localnet-start

 ## Configuration

-The `make localnet-start` creates files for a 4-node testnet in `./build` by
-calling the `tendermint testnet` command.
+The `make localnet-start` creates files for a 4-node testnet in `./build` by calling the `tendermint testnet` command.

-The `./build` directory is mounted to the `/tendermint` mount point to attach
-the binary and config files to the container.
+The `./build` directory is mounted to the `/tendermint` mount point to attach the binary and config files to the container.

-To change the number of validators / non-validators change the `localnet-start` Makefile target:
-
-```
-localnet-start: localnet-stop
-	@if ! [ -f build/node0/config/genesis.json ]; then docker run --rm -v $(CURDIR)/build:/tendermint:Z tendermint/localnode testnet --v 5 --n 3 --o . --populate-persistent-peers --starting-ip-address 192.167.10.2 ; fi
-	docker-compose up
-```
-
-The command now will generate config files for 5 validators and 3
-non-validators network.
-
-Before running it, don't forget to cleanup the old files:
+For instance, to create a single node testnet:

 ```
 cd $GOPATH/src/github.com/tendermint/tendermint

 # Clear the build folder
-rm -rf ./build/node*
-```
+rm -rf ./build

-## Configuring abci containers 
+# Build binary
+make build-linux

-To use your own abci applications with 4-node setup edit the [docker-compose.yaml](https://github.com/tendermint/tendermint/blob/develop/docker-compose.yml) file and add image to your abci application.
+# Create configuration
+docker run -e LOG="stdout" -v `pwd`/build:/tendermint tendermint/localnode testnet --o . --v 1
+
+#Run the node
+docker run -v `pwd`/build:/tendermint tendermint/localnode

 ```
- abci0:
-    container_name: abci0
-    image: "abci-image"
-    build:
-      context: .
-      dockerfile: abci.Dockerfile
-    command: <insert command to run your abci application>
-    networks:
-      localnet:
-        ipv4_address: 192.167.10.6
-
-  abci1:
-    container_name: abci1
-    image: "abci-image"
-    build:
-      context: .
-      dockerfile: abci.Dockerfile
-    command: <insert command to run your abci application>
-    networks:
-      localnet:
-        ipv4_address: 192.167.10.7
-
-  abci2:
-    container_name: abci2
-    image: "abci-image"
-    build:
-      context: .
-      dockerfile: abci.Dockerfile
-    command: <insert command to run your abci application>
-    networks:
-      localnet:
-        ipv4_address: 192.167.10.8
-
-  abci3:
-    container_name: abci3
-    image: "abci-image"
-    build:
-      context: .
-      dockerfile: abci.Dockerfile
-    command: <insert command to run your abci application>
-    networks:
-      localnet:
-        ipv4_address: 192.167.10.9
-
-```
-
-Override the [command](https://github.com/tendermint/tendermint/blob/master/networks/local/localnode/Dockerfile#L12) in each node to connect to it's abci. 
-
-```
-  node0:
-    container_name: node0
-    image: "tendermint/localnode"
-    ports:
-      - "26656-26657:26656-26657"
-    environment:
-      - ID=0
-      - LOG=$${LOG:-tendermint.log}
-    volumes:
-      - ./build:/tendermint:Z
-    command: node --proxy_app=tcp://abci0:26658
-    networks:
-      localnet:
-        ipv4_address: 192.167.10.2
-```
-
-Similarly do for node1, node2 and node3 then [run testnet](https://github.com/tendermint/tendermint/blob/master/docs/networks/docker-compose.md#run-a-testnet)

 ## Logging

-Log is saved under the attached volume, in the `tendermint.log` file. If the
-`LOG` environment variable is set to `stdout` at start, the log is not saved,
-but printed on the screen.
+Log is saved under the attached volume, in the `tendermint.log` file. If the `LOG` environment variable is set to `stdout` at start, the log is not saved, but printed on the screen.

 ## Special binaries

-If you have multiple binaries with different names, you can specify which one
-to run with the `BINARY` environment variable. The path of the binary is relative
-to the attached volume.
+If you have multiple binaries with different names, you can specify which one to run with the BINARY environment variable. The path of the binary is relative to the attached volume.
+
--- a/docs/package-lock.json
+++ b/docs/package-lock.json
--- a/docs/package.json
+++ b/docs/package.json
@@ -0,0 +1,40 @@
+{
+  "dependencies": {
+    "prettier": "^1.13.7",
+    "remark-cli": "^5.0.0",
+    "remark-lint-no-dead-urls": "^0.3.0",
+    "remark-lint-write-good": "^1.0.3",
+    "textlint": "^10.2.1",
+    "textlint-rule-stop-words": "^1.0.3"
+  },
+  "name": "tendermint",
+  "description": "Tendermint Core Documentation",
+  "version": "0.0.1",
+  "main": "README.md",
+  "devDependencies": {},
+  "scripts": {
+    "lint:json": "prettier \"**/*.json\" --write",
+    "lint:md": "prettier \"**/*.md\" --write && remark . && textlint \"md/**\"",
+    "lint": "yarn lint:json && yarn lint:md"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tendermint/tendermint.git"
+  },
+  "keywords": [
+    "tendermint",
+    "blockchain"
+  ],
+  "author": "Tendermint",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/tendermint/tendermint/issues"
+  },
+  "homepage": "https://tendermint.com/docs/",
+  "remarkConfig": {
+    "plugins": [
+      "remark-lint-no-dead-urls",
+      "remark-lint-write-good"
+    ]
+  }
+}
--- a/docs/spec/abci/apps.md
+++ b/docs/spec/abci/apps.md
@@ -166,15 +166,6 @@ the tags will be hashed into the next block header.
 The application may set the validator set during InitChain, and update it during
 EndBlock.

-Note that the maximum total power of the validator set is bounded by
-`MaxTotalVotingPower = MaxInt64 / 8`. Applications are responsible for ensuring
-they do not make changes to the validator set that cause it to exceed this
-limit.
-
-Additionally, applications must ensure that a single set of updates does not contain any duplicates -
-a given public key can only appear in an update once. If an update includes
-duplicates, the block execution will fail irrecoverably.
-
 ### InitChain

 ResponseInitChain can return a list of validators.
@@ -215,7 +206,6 @@ following rules:
  - if the validator does not already exist, it will be added to the validator
    set with the given power
  - if the validator does already exist, its power will be adjusted to the given power
- the total power of the new validator set must not exceed MaxTotalVotingPower

 Note the updates returned in block `H` will only take effect at block `H+2`.

@@ -417,22 +407,21 @@ If `storeBlockHeight == stateBlockHeight && appBlockHeight < storeBlockHeight`,
 replay all blocks in full from `appBlockHeight` to `storeBlockHeight`.
 This happens if we completed processing the block, but the app forgot its height.

-If `storeBlockHeight == stateBlockHeight && appBlockHeight == storeBlockHeight`, we're done.
+If `storeBlockHeight == stateBlockHeight && appBlockHeight == storeBlockHeight`, we're done
 This happens if we crashed at an opportune spot.

 If `storeBlockHeight == stateBlockHeight+1`
 This happens if we started processing the block but didn't finish.

-If `appBlockHeight < stateBlockHeight`
-    replay all blocks in full from `appBlockHeight` to `storeBlockHeight-1`,
-    and replay the block at `storeBlockHeight` using the WAL.
-This happens if the app forgot the last block it committed.
+    If `appBlockHeight < stateBlockHeight`
+    	replay all blocks in full from `appBlockHeight` to `storeBlockHeight-1`,
+    	and replay the block at `storeBlockHeight` using the WAL.
+    This happens if the app forgot the last block it committed.

-If `appBlockHeight == stateBlockHeight`,
-    replay the last block (storeBlockHeight) in full.
-This happens if we crashed before the app finished Commit
-
-If `appBlockHeight == storeBlockHeight`
-    update the state using the saved ABCI responses but dont run the block against the real app.
-This happens if we crashed after the app finished Commit but before Tendermint saved the state.
+    If `appBlockHeight == stateBlockHeight`,
+    	replay the last block (storeBlockHeight) in full.
+    This happens if we crashed before the app finished Commit

+    If appBlockHeight == storeBlockHeight {
+    	update the state using the saved ABCI responses but dont run the block against the real app.
+    This happens if we crashed after the app finished Commit but before Tendermint saved the state.
--- a/docs/spec/blockchain/blockchain.md
+++ b/docs/spec/blockchain/blockchain.md
@@ -51,7 +51,7 @@ type Header struct {

 	// hashes of block data
 	LastCommitHash []byte // commit from validators from the last block
-	DataHash       []byte // MerkleRoot of transaction hashes
+	DataHash       []byte // Merkle root of transactions

 	// hashes from the app output from the prev block
 	ValidatorsHash     []byte // validators for the current block
@@ -83,27 +83,25 @@ type Version struct {
 ## BlockID

 The `BlockID` contains two distinct Merkle roots of the block.
-The first, used as the block's main hash, is the MerkleRoot
-of all the fields in the header (ie. `MerkleRoot(header)`.
-The second, used for secure gossipping of the block during consensus,
-is the MerkleRoot of the complete serialized block
-cut into parts (ie. `MerkleRoot(MakeParts(block))`).
-The `BlockID` includes these two hashes, as well as the number of
-parts (ie. `len(MakeParts(block))`)
+The first, used as the block's main hash, is the Merkle root
+of all the fields in the header. The second, used for secure gossipping of
+the block during consensus, is the Merkle root of the complete serialized block
+cut into parts. The `BlockID` includes these two hashes, as well as the number of
+parts.

 ```go
 type BlockID struct {
    Hash []byte
-    PartsHeader PartSetHeader
+    Parts PartsHeader
 }

-type PartSetHeader struct {
-    Total int32
+type PartsHeader struct {
    Hash []byte
+    Total int32
 }
 ```

-See [MerkleRoot](/docs/spec/blockchain/encoding.md#MerkleRoot) for details.
+TODO: link to details of merkle sums.

 ## Time

@@ -111,6 +109,10 @@ Tendermint uses the
 [Google.Protobuf.WellKnownTypes.Timestamp](https://developers.google.com/protocol-buffers/docs/reference/csharp/class/google/protobuf/well-known-types/timestamp)
 format, which uses two integers, one for Seconds and for Nanoseconds.

+NOTE: there is currently a small divergence between Tendermint and the
+Google.Protobuf.WellKnownTypes.Timestamp that should be resolved. See [this
+issue](https://github.com/tendermint/go-amino/issues/223) for details.
+
 ## Data

 Data is just a wrapper for a list of transactions, where transactions are
@@ -144,12 +146,12 @@ The vote includes information about the validator signing it.

 ```go
 type Vote struct {
-	Type             byte
+	Type             SignedMsgType  // byte
 	Height           int64
 	Round            int
+	Timestamp        time.Time
 	BlockID          BlockID
-	Timestamp        Time
-	ValidatorAddress []byte
+	ValidatorAddress Address
 	ValidatorIndex   int
 	Signature        []byte
 }
@@ -162,8 +164,8 @@ a _precommit_ has `vote.Type == 2`.
 ## Signature

 Signatures in Tendermint are raw bytes representing the underlying signature.
-
-See the [signature spec](/docs/spec/blockchain/encoding.md#key-types) for more.
+The only signature scheme currently supported for Tendermint validators is
+ED25519. The signature is the raw 64-byte ED25519 signature.

 ## EvidenceData

@@ -190,8 +192,6 @@ type DuplicateVoteEvidence struct {
 }
 ```

-See the [pubkey spec](/docs/spec/blockchain/encoding.md#key-types) for more.
-
 ## Validation

 Here we describe the validation rules for every element in a block.
@@ -209,7 +209,7 @@ the current version of the `state` corresponds to the state
 after executing transactions from the `prevBlock`.
 Elements of an object are accessed as expected,
 ie. `block.Header`.
-See the [definition of `State`](/docs/spec/blockchain/state.md).
+See [here](https://github.com/tendermint/tendermint/blob/master/docs/spec/blockchain/state.md) for the definition of `state`.

 ### Header

@@ -230,7 +230,7 @@ The block version must match the state version.
 len(block.ChainID) < 50
 ```

-ChainID must be less than 50 bytes.
+ChainID must be maximum 50 UTF-8 symbols.

 ### Height

@@ -288,25 +288,28 @@ The first block has `block.Header.TotalTxs = block.Header.NumberTxs`.
 LastBlockID is the previous block's BlockID:

 ```go
-prevBlockParts := MakeParts(prevBlock)
+prevBlockParts := MakeParts(prevBlock, state.LastConsensusParams.BlockGossip.BlockPartSize)
 block.Header.LastBlockID == BlockID {
-    Hash: MerkleRoot(prevBlock.Header),
+    Hash: SimpleMerkleRoot(prevBlock.Header),
    PartsHeader{
-        Hash: MerkleRoot(prevBlockParts),
+        Hash: SimpleMerkleRoot(prevBlockParts),
        Total: len(prevBlockParts),
    },
 }
 ```

+Note: it depends on the ConsensusParams,
+which are held in the `state` and may be updated by the application.
+
 The first block has `block.Header.LastBlockID == BlockID{}`.

 ### LastCommitHash

 ```go
-block.Header.LastCommitHash == MerkleRoot(block.LastCommit.Precommits)
+block.Header.LastCommitHash == SimpleMerkleRoot(block.LastCommit)
 ```

-MerkleRoot of the votes included in the block.
+Simple Merkle root of the votes included in the block.
 These are the votes that committed the previous block.

 The first block has `block.Header.LastCommitHash == []byte{}`
@@ -314,42 +317,37 @@ The first block has `block.Header.LastCommitHash == []byte{}`
 ### DataHash

 ```go
-block.Header.DataHash == MerkleRoot(Hashes(block.Txs.Txs))
+block.Header.DataHash == SimpleMerkleRoot(block.Txs.Txs)
 ```

-MerkleRoot of the hashes of transactions included in the block.
-
-Note the transactions are hashed before being included in the Merkle tree,
-so the leaves of the Merkle tree are the hashes, not the transactions
-themselves. This is because transaction hashes are regularly used as identifiers for
-transactions.
+Simple Merkle root of the transactions included in the block.

 ### ValidatorsHash

 ```go
-block.ValidatorsHash == MerkleRoot(state.Validators)
+block.ValidatorsHash == SimpleMerkleRoot(state.Validators)
 ```

-MerkleRoot of the current validator set that is committing the block.
+Simple Merkle root of the current validator set that is committing the block.
 This can be used to validate the `LastCommit` included in the next block.

 ### NextValidatorsHash

 ```go
-block.NextValidatorsHash == MerkleRoot(state.NextValidators)
+block.NextValidatorsHash == SimpleMerkleRoot(state.NextValidators)
 ```

-MerkleRoot of the next validator set that will be the validator set that commits the next block.
+Simple Merkle root of the next validator set that will be the validator set that commits the next block.
 This is included so that the current validator set gets a chance to sign the
 next validator sets Merkle root.

-### ConsensusHash
+### ConsensusParamsHash

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

-Hash of the amino-encoding of a subset of the consensus parameters.
+Hash of the amino-encoded consensus parameters.

 ### AppHash

@@ -364,20 +362,20 @@ The first block has `block.Header.AppHash == []byte{}`.
 ### LastResultsHash

 ```go
-block.ResultsHash == MerkleRoot(state.LastResults)
+block.ResultsHash == SimpleMerkleRoot(state.LastResults)
 ```

-MerkleRoot of the results of the transactions in the previous block.
+Simple Merkle root of the results of the transactions in the previous block.

 The first block has `block.Header.ResultsHash == []byte{}`.

 ## EvidenceHash

 ```go
-block.EvidenceHash == MerkleRoot(block.Evidence)
+block.EvidenceHash == SimpleMerkleRoot(block.Evidence)
 ```

-MerkleRoot of the evidence of Byzantine behaviour included in this block.
+Simple Merkle root of the evidence of Byzantine behaviour included in this block.

 ### ProposerAddress

--- a/docs/spec/blockchain/encoding.md
+++ b/docs/spec/blockchain/encoding.md
@@ -30,12 +30,6 @@ For example, the byte-array `[0xA, 0xB]` would be encoded as `0x020A0B`,
 while a byte-array containing 300 entires beginning with `[0xA, 0xB, ...]` would
 be encoded as `0xAC020A0B...` where `0xAC02` is the UVarint encoding of 300.

-## Hashing
-
-Tendermint uses `SHA256` as its hash function.
-Objects are always Amino encoded before being hashed.
-So `SHA256(obj)` is short for `SHA256(AminoEncode(obj))`.
-
 ## Public Key Cryptography

 Tendermint uses Amino to distinguish between different types of private keys,
@@ -74,27 +68,23 @@ For example, the 33-byte (or 0x21-byte in hex) Secp256k1 pubkey
   would be encoded as
   `EB5AE98721020BD40F225A57ED383B440CF073BC5539D0341F5767D2BF2D78406D00475A2EE9`

-### Key Types
+### Addresses

-Each type specifies it's own pubkey, address, and signature format.
+Addresses for each public key types are computed as follows:

 #### Ed25519

-TODO: pubkey
-
-The address is the first 20-bytes of the SHA256 hash of the raw 32-byte public key:
+First 20-bytes of the SHA256 hash of the raw 32-byte public key:

 ```
 address = SHA256(pubkey)[:20]
 ```

-The signature is the raw 64-byte ED25519 signature.
+NOTE: before v0.22.0, this was the RIPEMD160 of the Amino encoded public key.

 #### Secp256k1

-TODO: pubkey
-
-The address is the RIPEMD160 hash of the SHA256 hash of the OpenSSL compressed public key:
+RIPEMD160 hash of the SHA256 hash of the OpenSSL compressed public key:

 ```
 address = RIPEMD160(SHA256(pubkey))
@@ -102,21 +92,12 @@ address = RIPEMD160(SHA256(pubkey))

 This is the same as Bitcoin.

-The signature is the 64-byte concatenation of ECDSA `r` and `s` (ie. `r || s`),
-where `s` is lexicographically less than its inverse, to prevent malleability.
-This is like Ethereum, but without the extra byte for pubkey recovery, since
-Tendermint assumes the pubkey is always provided anyway.
-
-#### Multisig
-
-TODO
-
 ## Other Common Types

 ### BitArray

-The BitArray is used in some consensus messages to represent votes received from
-validators, or parts received in a block. It is represented
+The BitArray is used in block headers and some consensus messages to signal
+whether or not something was done by each validator. BitArray is represented
 with a struct containing the number of bits (`Bits`) and the bit-array itself
 encoded in base64 (`Elems`).

@@ -138,27 +119,24 @@ representing `1` and `0`. Ie. the BitArray `10110` would be JSON encoded as
 Part is used to break up blocks into pieces that can be gossiped in parallel
 and securely verified using a Merkle tree of the parts.

-Part contains the index of the part (`Index`), the actual
-underlying data of the part (`Bytes`), and a Merkle proof that the part is contained in
-the set (`Proof`).
+Part contains the index of the part in the larger set (`Index`), the actual
+underlying data of the part (`Bytes`), and a simple Merkle proof that the part is contained in
+the larger set (`Proof`).

 ```go
 type Part struct {
    Index int
-    Bytes []byte
-    Proof SimpleProof
+    Bytes byte[]
+    Proof byte[]
 }
 ```

-See details of SimpleProof, below.
-
 ### MakeParts

 Encode an object using Amino and slice it into parts.
-Tendermint uses a part size of 65536 bytes.

 ```go
-func MakeParts(block Block) []Part
+func MakeParts(obj interface{}, partSize int) []Part
 ```

 ## Merkle Trees
@@ -166,17 +144,12 @@ func MakeParts(block Block) []Part
 For an overview of Merkle trees, see
 [wikipedia](https://en.wikipedia.org/wiki/Merkle_tree)

-We use the RFC 6962 specification of a merkle tree, with sha256 as the hash function.
-Merkle trees are used throughout Tendermint to compute a cryptographic digest of a data structure.
-The differences between RFC 6962 and the simplest form a merkle tree are that:
+A Simple Tree is a simple compact binary tree for a static list of items. Simple Merkle trees are used in numerous places in Tendermint to compute a cryptographic digest of a data structure. In a Simple Tree, the transactions and validation signatures of a block are hashed using this simple merkle tree logic.

-1) leaf nodes and inner nodes have different hashes.
-   This is for "second pre-image resistance", to prevent the proof to an inner node being valid as the proof of a leaf.
-   The leaf nodes are `SHA256(0x00 || leaf_data)`, and inner nodes are `SHA256(0x01 || left_hash || right_hash)`.
-
-2) When the number of items isn't a power of two, the left half of the tree is as big as it could be.
-   (The smallest power of two less than the number of items) This allows new leaves to be added with less
-   recomputation. For example:
+If the number of items is not a power of two, the tree will not be full
+and some leaf nodes will be at different levels. Simple Tree tries to
+keep both sides of the tree the same size, but the left side may be one
+greater, for example:

 ```
   Simple Tree with 6 items           Simple Tree with 7 items
@@ -190,79 +163,68 @@ The differences between RFC 6962 and the simplest form a merkle tree are that:
     / \             / \                / \             / \
    /   \           /   \              /   \           /   \
   /     \         /     \            /     \         /     \
-  *       *       h4     h5          *       *       *       h6
- / \     / \                        / \     / \     / \
-h0  h1  h2 h3                      h0  h1  h2  h3  h4  h5
+  *       h2      *       h5         *       *       *       h6
+ / \             / \                / \     / \     / \
+h0  h1          h3  h4             h0  h1  h2  h3  h4  h5
 ```

-### MerkleRoot
+Tendermint always uses the `TMHASH` hash function, which is equivalent to
+SHA256:

-The function `MerkleRoot` is a simple recursive function defined as follows:
+```
+func TMHASH(bz []byte) []byte {
+    return SHA256(bz)
+}
+```
+
+### Simple Merkle Root
+
+The function `SimpleMerkleRoot` is a simple recursive function defined as follows:

 ```go
-// SHA256(0x00 || leaf)
-func leafHash(leaf []byte) []byte {
-	return tmhash.Sum(append(0x00, leaf...))
+func SimpleMerkleRoot(hashes [][]byte) []byte{
+    switch len(hashes) {
+    case 0:
+        return nil
+    case 1:
+        return hashes[0]
+    default:
+        left := SimpleMerkleRoot(hashes[:(len(hashes)+1)/2])
+        right := SimpleMerkleRoot(hashes[(len(hashes)+1)/2:])
+        return SimpleConcatHash(left, right)
+    }
 }

-// SHA256(0x01 || left || right)
-func innerHash(left []byte, right []byte) []byte {
-	return tmhash.Sum(append(0x01, append(left, right...)...))
-}
-
-// largest power of 2 less than k
-func getSplitPoint(k int) { ... }
-
-func MerkleRoot(items [][]byte) []byte{
-	switch len(items) {
-	case 0:
-		return nil
-	case 1:
-		return leafHash(leafs[0])
-	default:
-		k := getSplitPoint(len(items))
-		left := MerkleRoot(items[:k])
-		right := MerkleRoot(items[k:])
-		return innerHash(left, right)
-	}
+func SimpleConcatHash(left, right []byte) []byte{
+    left = encodeByteSlice(left)
+    right = encodeByteSlice(right)
+    return TMHASH(append(left, right))
 }
 ```

-Note: `MerkleRoot` operates on items which are arbitrary byte arrays, not
-necessarily hashes. For items which need to be hashed first, we introduce the
-`Hashes` function:
+Note that the leaves are Amino encoded as byte-arrays (ie. simple Uvarint length
+prefix) before being concatenated together and hashed.

-```
-func Hashes(items [][]byte) [][]byte {
-    return SHA256 of each item
-}
-```
-
-Note: we will abuse notion and invoke `MerkleRoot` with arguments of type `struct` or type `[]struct`.
-For `struct` arguments, we compute a `[][]byte` containing the amino encoding of each
+Note: we will abuse notion and invoke `SimpleMerkleRoot` with arguments of type `struct` or type `[]struct`.
+For `struct` arguments, we compute a `[][]byte` containing the hash of each
 field in the struct, in the same order the fields appear in the struct.
-For `[]struct` arguments, we compute a `[][]byte` by amino encoding the individual `struct` elements.
+For `[]struct` arguments, we compute a `[][]byte` by hashing the individual `struct` elements.

 ### Simple Merkle Proof

-Proof that a leaf is in a Merkle tree is composed as follows:
+Proof that a leaf is in a Merkle tree consists of a simple structure:

-```golang
+```
 type SimpleProof struct {
-        Total int
-        Index int
-        LeafHash []byte
        Aunts [][]byte
 }
 ```

-Which is verified as follows:
+Which is verified using the following:

-```golang
-func (proof SimpleProof) Verify(rootHash []byte, leaf []byte) bool {
-	assert(proof.LeafHash, leafHash(leaf)
-
-	computedHash := computeHashFromAunts(proof.Index, proof.Total, proof.LeafHash, proof.Aunts)
+```
+func (proof SimpleProof) Verify(index, total int, leafHash, rootHash []byte) bool {
+	computedHash := computeHashFromAunts(index, total, leafHash, proof.Aunts)
    return computedHash == rootHash
 }

@@ -276,18 +238,26 @@ func computeHashFromAunts(index, total int, leafHash []byte, innerHashes [][]byt

 	assert(len(innerHashes) > 0)

-	numLeft := getSplitPoint(total) // largest power of 2 less than total
+	numLeft := (total + 1) / 2
 	if index < numLeft {
 		leftHash := computeHashFromAunts(index, numLeft, leafHash, innerHashes[:len(innerHashes)-1])
 		assert(leftHash != nil)
-		return innerHash(leftHash, innerHashes[len(innerHashes)-1])
+		return SimpleHashFromTwoHashes(leftHash, innerHashes[len(innerHashes)-1])
 	}
 	rightHash := computeHashFromAunts(index-numLeft, total-numLeft, leafHash, innerHashes[:len(innerHashes)-1])
 	assert(rightHash != nil)
-	return innerHash(innerHashes[len(innerHashes)-1], rightHash)
+	return SimpleHashFromTwoHashes(innerHashes[len(innerHashes)-1], rightHash)
 }
 ```

+### Simple Tree with Dictionaries
+
+The Simple Tree is used to merkelize a list of items, so to merkelize a
+(short) dictionary of key-value pairs, encode the dictionary as an
+ordered list of `KVPair` structs. The block hash is such a hash
+derived from all the fields of the block `Header`. The state hash is
+similarly derived.
+
 ### IAVL+ Tree

 Because Tendermint only uses a Simple Merkle Tree, application developers are expect to use their own Merkle tree in their applications. For example, the IAVL+ Tree - an immutable self-balancing binary tree for persisting application state is used by the [Cosmos SDK](https://github.com/cosmos/cosmos-sdk/blob/develop/docs/sdk/core/multistore.md)
@@ -331,14 +301,12 @@ type CanonicalVote struct {
 	Type      byte
 	Height    int64            `binary:"fixed64"`
 	Round     int64            `binary:"fixed64"`
-	BlockID   CanonicalBlockID
 	Timestamp time.Time
+	BlockID   CanonicalBlockID
 	ChainID   string
 }
 ```

 The field ordering and the fixed sized encoding for the first three fields is optimized to ease parsing of SignBytes
 in HSMs. It creates fixed offsets for relevant fields that need to be read in this context.
-For more details, see the [signing spec](/docs/spec/consensus/signing.md).
-Also, see the motivating discussion in
-[#1622](https://github.com/tendermint/tendermint/issues/1622).
+See [#1622](https://github.com/tendermint/tendermint/issues/1622) for more details.
--- a/docs/spec/blockchain/state.md
+++ b/docs/spec/blockchain/state.md
@@ -60,7 +60,7 @@ When hashing the Validator struct, the address is not included,
 because it is redundant with 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 MerkleRoot.
+so that there is a canonical order for computing the SimpleMerkleRoot.

 We also define a `TotalVotingPower` function, to return the total voting power:

@@ -78,8 +78,6 @@ 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.
-When hashed, only a subset of the params are included, to allow the params to
-evolve without breaking the header.

 ```go
 type ConsensusParams struct {
@@ -88,18 +86,6 @@ type ConsensusParams struct {
 	Validator
 }

-type hashedParams struct {
-    BlockMaxBytes int64
-    BlockMaxGas   int64
-}
-
-func (params ConsensusParams) Hash() []byte {
-    SHA256(hashedParams{
-        BlockMaxBytes: params.BlockSize.MaxBytes,
-        BlockMaxGas: params.BlockSize.MaxGas,
-    })
-}
-
 type BlockSize struct {
 	MaxBytes        int64
 	MaxGas          int64
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ismail Khoffi	1ee32d3089	playing with show validator cmd and experimenting with spawning new sessions / connections if the connection is lost	2018-12-13 12:26:11 +01:00
Ismail Khoffi	8a993c6486	merge develop and update changelog pending	2018-12-12 14:19:15 +01:00
Ismail Khoffi	3547ce2516	Rework PR to memoize public key on init: - split PubKeyMsg into PubKeyRequest / PubKeyResponse like other msgs - NewRemoteSignerClient sends a pubkey request (once), return this err OnStart() - NewRemoteSignerClient returns an error if retrieving the pubkey fails - remove GetAddress from PrivValidator interface - GetPublicKey doesn't err but returns memoized public key from init - fix tests	2018-12-12 13:59:40 +01:00
Ismail Khoffi	3d5e06ff7c	Anton's suggested changes	2018-12-10 11:19:02 +01:00
Ismail Khoffi	e33f256359	fix unused import	2018-12-09 13:03:06 +01:00
Ismail Khoffi	5c09275691	wrap error in remote signer only	2018-12-07 12:17:49 +01:00
Ismail Khoffi	094699f9bc	only use "github.com/pkg/errors" to avoid aliasing	2018-12-07 11:52:40 +01:00
Ismail Khoffi	c8ab062ce9	Merge branch 'develop' into 2926_dont_panic	2018-12-07 11:32:28 +01:00
Ismail Khoffi	1765eb2cd2	more review comments: - consistently wrap error - add changelog entry	2018-12-07 11:31:14 +01:00
Ismail Khoffi	df20323cd2	a few uncaught asserts replaced with require	2018-12-03 12:08:20 +01:00
Ismail Khoffi	f17c04c892	more review comments: require instead assert & wrap errors	2018-12-03 12:03:50 +01:00
Ismail Khoffi	50ac191f9d	Address more review comments: require instead assert & wrap errors	2018-12-01 12:26:40 +01:00
Ismail Khoffi	977a138b1f	Review comments: wrap errors	2018-12-01 12:08:57 +01:00
Anton Kaliaev	1c6ed0e7d0	Review comments: @melekes suggestions use require instead of assert Co-Authored-By: Liamsi <Ismail.Khoffi@gmail.com>	2018-12-01 11:59:36 +01:00
Anton Kaliaev	80c464c9b4	Review comments: @melekes suggestions require instead of assert Co-Authored-By: Liamsi <Ismail.Khoffi@gmail.com>	2018-12-01 11:59:11 +01:00
Anton Kaliaev	5233ac154f	Review comments: @melekes suggestions require instead of assert Co-Authored-By: Liamsi <Ismail.Khoffi@gmail.com>	2018-12-01 11:58:56 +01:00
Anton Kaliaev	db04ff4896	Review comments: @melekes suggestions require instead of assert Co-Authored-By: Liamsi <Ismail.Khoffi@gmail.com>	2018-12-01 11:58:40 +01:00
Anton Kaliaev	394edc9230	Review comments: @melekes suggestions require instead of assert Co-Authored-By: Liamsi <Ismail.Khoffi@gmail.com>	2018-12-01 11:58:25 +01:00
Anton Kaliaev	1fa463ecab	Review comments: @melekes suggestions require instead of assert Co-Authored-By: Liamsi <Ismail.Khoffi@gmail.com>	2018-12-01 11:58:00 +01:00
Anton Kaliaev	d79d2093ff	Review comments: @melekes suggestions require instead of assert Co-Authored-By: Liamsi <Ismail.Khoffi@gmail.com>	2018-12-01 11:57:39 +01:00
Anton Kaliaev	78b7a41319	Review comments: @melekes suggestions Co-Authored-By: Liamsi <Ismail.Khoffi@gmail.com>	2018-12-01 11:57:20 +01:00
Ismail Khoffi	417c30b9c1	PrivValidator.GetAddress() and PrivValidator.GetPublicKey() return an error instead of panic	2018-11-29 18:52:19 +01:00