Merge branch 'develop' into fix-persistent-first

2018-04-28 00:34:03 -04:00 · 2018-04-28 00:34:03 -04:00 · fa66694f2e
parent 5d8767e656 d92def4b60
commit fa66694f2e
274 changed files with 8609 additions and 5346 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@ -130,19 +130,6 @@ jobs:
          paths:
            - "profiles/*"

-  test_libs:
-    <<: *defaults
-    steps:
-      - attach_workspace:
-          at: /tmp/workspace
-      - restore_cache:
-          key: v1-pkg-cache
-      - restore_cache:
-          key: v1-tree-{{ .Environment.CIRCLE_SHA1 }}
-      - run:
-          name: Run tests
-          command: bash test/test_libs.sh
-
  test_persistence:
    <<: *defaults
    steps:
@ -205,14 +192,6 @@ workflows:
      - test_cover:
          requires:
            - setup_dependencies
-      - test_libs:
-          filters:
-            branches:
-              only:
-                - develop
-                - master
-          requires:
-            - setup_dependencies
      - test_persistence:
          requires:
            - setup_abci
--- a/.gitignore
+++ b/.gitignore
@ -17,6 +17,7 @@ test/logs
 coverage.txt
 docs/_build
 docs/tools
+docs/abci-spec.rst
 *.log

 scripts/wal2json/wal2json
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -7,7 +7,6 @@ BREAKING CHANGES:
 - Upgrade consensus for more real-time use of evidence

 FEATURES:
- Peer reputation management
 - Use the chain as its own CA for nodes and validators
 - Tooling to run multiple blockchains/apps, possibly in a single process
 - State syncing (without transaction replay)
@ -26,10 +25,82 @@ BUG FIXES:
 - Graceful handling/recovery for violations of safety, or liveness
 - Fix reconnect to persistent peer when first dial fails

+## 0.19.1 (April 27th, 2018)
+
+Note this release includes some small breaking changes in the RPC and one in the
+config that are really bug fixes. v0.19.1 will work with existing chains, and make Tendermint
+easier to use and debug. With <3
+
+BREAKING (MINOR)
+
+- [config] Removed `wal_light` setting. If you really needed this, let us know
+
+FEATURES:
+
+- [networks] moved in tooling from devops repo: terraform and ansible scripts for deploying testnets !
+- [cmd] Added `gen_node_key` command
+
+BUG FIXES
+
+Some of these are breaking in the RPC response, but they're really bugs!
+
+- [spec] Document address format and pubkey encoding pre and post Amino
+- [rpc] Lower case JSON field names
+- [rpc] Fix missing entries, improve, and lower case the fields in `/dump_consensus_state`
+- [rpc] Fix NodeInfo.Channels format to hex
+- [rpc] Add Validator address to `/status`
+- [rpc] Fix `prove` in ABCIQuery
+- [cmd] MarshalJSONIndent on init
+
+## 0.19.0 (April 13th, 2018)
+
+BREAKING:
+- [cmd] improved `testnet` command; now it can fill in `persistent_peers` for you in the config file and much more (see `tendermint testnet --help` for details)
+- [cmd] `show_node_id` now returns an error if there is no node key
+- [rpc]: changed the output format for the `/status` endpoint (see https://godoc.org/github.com/tendermint/tendermint/rpc/core#Status)
+
+Upgrade from go-wire to go-amino. This is a sweeping change that breaks everything that is
+serialized to disk or over the network.
+
+See github.com/tendermint/go-amino for details on the new format.
+
+See `scripts/wire2amino.go` for a tool to upgrade
+genesis/priv_validator/node_key JSON files.
+
+FEATURES
+
+- [test] docker-compose for local testnet setup (thanks Greg!)
+
+## 0.18.0 (April 6th, 2018)
+
+BREAKING:
+
+- [types] Merkle tree uses different encoding for varints (see tmlibs v0.8.0)
+- [types] ValidtorSet.GetByAddress returns -1 if no validator found
+- [p2p] require all addresses come with an ID no matter what
+- [rpc] Listening address must contain tcp:// or unix:// prefix
+
+FEATURES:
+
+- [rpc] StartHTTPAndTLSServer (not used yet)
+- [rpc] Include validator's voting power in `/status`
+- [rpc] `/tx` and `/tx_search` responses now include the transaction hash
+- [rpc] Include peer NodeIDs in `/net_info`
+
+IMPROVEMENTS:
+- [config] trim whitespace from elements of lists (like `persistent_peers`)
+- [rpc] `/tx_search` results are sorted by height
+- [p2p] do not try to connect to ourselves (ok, maybe only once)
+- [p2p] seeds respond with a bias towards good peers
+
+BUG FIXES:
+- [rpc] fix subscribing using an abci.ResponseDeliverTx tag
+- [rpc] fix tx_indexers matchRange
+- [rpc] fix unsubscribing (see tmlibs v0.8.0)
+
 ## 0.17.1 (March 27th, 2018)

 BUG FIXES:
-
 - [types] Actually support `app_state` in genesis as `AppStateJSON`

 ## 0.17.0 (March 27th, 2018)
--- a/DOCKER/.gitignore
+++ b/DOCKER/.gitignore
@ -0,0 +1 @@
+tendermint
--- a/DOCKER/Dockerfile
+++ b/DOCKER/Dockerfile
@ -1,45 +1,39 @@
-FROM alpine:3.6
+FROM alpine:3.7
+MAINTAINER Greg Szabo <greg@tendermint.com>

-# This is the release of tendermint to pull in.
-ENV TM_VERSION 0.15.0
-ENV TM_SHA256SUM 71cc271c67eca506ca492c8b90b090132f104bf5dbfe0af2702a50886e88de17
-
-# Tendermint will be looking for genesis file in /tendermint (unless you change
-# `genesis_file` in config.toml). You can put your config.toml and private
-# validator file into /tendermint.
+# 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
+# private validator file into /tendermint/config.
 #
 # The /tendermint/data dir is used by tendermint to store state.
-ENV DATA_ROOT /tendermint
-ENV TMHOME $DATA_ROOT
-
-# Set user right away for determinism
-RUN addgroup tmuser && \
-    adduser -S -G tmuser tmuser
-
-# Create directory for persistence and give our user ownership
-RUN mkdir -p $DATA_ROOT && \
-    chown -R tmuser:tmuser $DATA_ROOT
+ENV TMHOME /tendermint

+# OS environment setup
+# Set user right away for determinism, create directory for persistence and give our user ownership
 # jq and curl used for extracting `pub_key` from private validator while
 # deploying tendermint with Kubernetes. It is nice to have bash so the users
 # could execute bash commands.
-RUN apk add --no-cache bash curl jq
+RUN apk update && \
+    apk upgrade && \
+    apk --no-cache add curl jq bash && \
+    addgroup tmuser && \
+    adduser -S -G tmuser tmuser -h "$TMHOME"

-RUN apk add --no-cache openssl && \
-    wget https://s3-us-west-2.amazonaws.com/tendermint/binaries/tendermint/v${TM_VERSION}/tendermint_${TM_VERSION}_linux_amd64.zip && \
-    echo "${TM_SHA256SUM}  tendermint_${TM_VERSION}_linux_amd64.zip" | sha256sum -c && \
-    unzip -d /bin tendermint_${TM_VERSION}_linux_amd64.zip && \
-    apk del openssl && \
-    rm -f tendermint_${TM_VERSION}_linux_amd64.zip
+# Run the container with tmuser by default. (UID=100, GID=1000)
+USER tmuser

 # Expose the data directory as a volume since there's mutable state in there
-VOLUME $DATA_ROOT
+VOLUME [ $TMHOME ]

-# p2p port
-EXPOSE 46656
-# rpc port
-EXPOSE 46657
+WORKDIR $TMHOME

-ENTRYPOINT ["tendermint"]
+# p2p and rpc port
+EXPOSE 46656 46657

+ENTRYPOINT ["/usr/bin/tendermint"]
 CMD ["node", "--moniker=`hostname`"]
+STOPSIGNAL SIGTERM
+
+ARG BINARY=tendermint
+COPY $BINARY /usr/bin/tendermint
+
--- a/DOCKER/Dockerfile.develop
+++ b/DOCKER/Dockerfile.develop
@ -1,4 +1,4 @@
-FROM alpine:3.6
+FROM alpine:3.7

 ENV DATA_ROOT /tendermint
 ENV TMHOME $DATA_ROOT
--- a/DOCKER/README.md
+++ b/DOCKER/README.md
@ -1,6 +1,7 @@
 # Supported tags and respective `Dockerfile` links

- `0.15.0`, `latest` [(Dockerfile)](https://github.com/tendermint/tendermint/blob/170777300ea92dc21a8aec1abc16cb51812513a4/DOCKER/Dockerfile)
+- `0.17.1`, `latest` [(Dockerfile)](https://github.com/tendermint/tendermint/blob/208ac32fa266657bd6c304e84ec828aa252bb0b8/DOCKER/Dockerfile)
+- `0.15.0` [(Dockerfile)](https://github.com/tendermint/tendermint/blob/170777300ea92dc21a8aec1abc16cb51812513a4/DOCKER/Dockerfile)
 - `0.13.0` [(Dockerfile)](https://github.com/tendermint/tendermint/blob/a28b3fff49dce2fb31f90abb2fc693834e0029c2/DOCKER/Dockerfile)
 - `0.12.1` [(Dockerfile)](https://github.com/tendermint/tendermint/blob/457c688346b565e90735431619ca3ca597ef9007/DOCKER/Dockerfile)
 - `0.12.0` [(Dockerfile)](https://github.com/tendermint/tendermint/blob/70d8afa6e952e24c573ece345560a5971bf2cc0e/DOCKER/Dockerfile)
--- a/Gopkg.lock
+++ b/Gopkg.lock
@ -5,7 +5,7 @@
  branch = "master"
  name = "github.com/btcsuite/btcd"
  packages = ["btcec"]
-  revision = "2be2f12b358dc57d70b8f501b00be450192efbc3"
+  revision = "675abc5df3c5531bc741b56a765e35623459da6d"

 [[projects]]
  name = "github.com/davecgh/go-spew"
@ -105,7 +105,7 @@
    "json/scanner",
    "json/token"
  ]
-  revision = "f40e974e75af4e271d97ce0fc917af5898ae7bda"
+  revision = "ef8a98b0bbce4a65b5aa4c368430a80ddc533168"

 [[projects]]
  name = "github.com/inconshreveable/mousetrap"
@ -159,7 +159,7 @@
  branch = "master"
  name = "github.com/rcrowley/go-metrics"
  packages = ["."]
-  revision = "8732c616f52954686704c8645fe1a9d59e9df7c1"
+  revision = "d932a24a8ccb8fcadc993e5c6c58f93dac168294"

 [[projects]]
  name = "github.com/spf13/afero"
@ -167,8 +167,8 @@
    ".",
    "mem"
  ]
-  revision = "bb8f1927f2a9d3ab41c9340aa034f6b803f4359c"
-  version = "v1.0.2"
+  revision = "63644898a8da0bc22138abf860edaf5277b6102e"
+  version = "v1.1.0"

 [[projects]]
  name = "github.com/spf13/cast"
@ -179,8 +179,8 @@
 [[projects]]
  name = "github.com/spf13/cobra"
  packages = ["."]
-  revision = "7b2c5ac9fc04fc5efafb60700713d4fa609b777b"
-  version = "v0.0.1"
+  revision = "a1f051bc3eba734da4772d60e2d677f47cf93ef4"
+  version = "v0.0.2"

 [[projects]]
  branch = "master"
@ -191,8 +191,8 @@
 [[projects]]
  name = "github.com/spf13/pflag"
  packages = ["."]
-  revision = "e57e3eeb33f795204c1ca35f56c44f83227c6e66"
-  version = "v1.0.0"
+  revision = "583c0c0531f06d5278b7d917446061adc344b5cd"
+  version = "v1.0.1"

 [[projects]]
  name = "github.com/spf13/viper"
@ -226,7 +226,7 @@
    "leveldb/table",
    "leveldb/util"
  ]
-  revision = "169b1b37be738edb2813dab48c97a549bcf99bb5"
+  revision = "714f901b98fdb3aa954b4193d8cbd64a28d80cad"

 [[projects]]
  name = "github.com/tendermint/abci"
@ -238,8 +238,8 @@
    "server",
    "types"
  ]
-  revision = "46686763ba8ea595ede16530ed4a40fb38f49f94"
-  version = "v0.10.2"
+  revision = "78a8905690ef54f9d57e3b2b0ee7ad3a04ef3f1f"
+  version = "v0.10.3"

 [[projects]]
  branch = "master"
@ -251,20 +251,22 @@
  ]
  revision = "d8387025d2b9d158cf4efb07e7ebf814bcce2057"

+[[projects]]
+  name = "github.com/tendermint/go-amino"
+  packages = ["."]
+  revision = "3668c02a8feace009f80754a5e5a8541e5d7b996"
+  version = "0.9.8"
+
 [[projects]]
  name = "github.com/tendermint/go-crypto"
  packages = ["."]
-  revision = "c3e19f3ea26f5c3357e0bcbb799b0761ef923755"
-  version = "v0.5.0"
+  revision = "915416979bf70efa4bcbf1c6cd5d64c5fff9fc19"
+  version = "v0.6.2"

 [[projects]]
  name = "github.com/tendermint/go-wire"
-  packages = [
-    ".",
-    "data"
-  ]
+  packages = ["."]
  revision = "fa721242b042ecd4c6ed1a934ee740db4f74e45c"
-  source = "github.com/tendermint/go-amino"
  version = "v0.7.3"

 [[projects]]
@ -283,8 +285,8 @@
    "pubsub/query",
    "test"
  ]
-  revision = "24da7009c3d8c019b40ba4287495749e3160caca"
-  version = "v0.7.1"
+  revision = "d94e312673e16a11ea55d742cefb3e331228f898"
+  version = "v0.8.2"

 [[projects]]
  branch = "master"
@ -299,13 +301,14 @@
    "ripemd160",
    "salsa20/salsa"
  ]
-  revision = "88942b9c40a4c9d203b82b3731787b672d6e809b"
+  revision = "b49d69b5da943f7ef3c9cf91c8777c1f78a0cc3c"

 [[projects]]
  branch = "master"
  name = "golang.org/x/net"
  packages = [
    "context",
+    "http/httpguts",
    "http2",
    "http2/hpack",
    "idna",
@ -313,13 +316,13 @@
    "lex/httplex",
    "trace"
  ]
-  revision = "6078986fec03a1dcc236c34816c71b0e05018fda"
+  revision = "5f9ae10d9af5b1c89ae6904293b14b064d4ada23"

 [[projects]]
  branch = "master"
  name = "golang.org/x/sys"
  packages = ["unix"]
-  revision = "91ee8cde435411ca3f1cd365e8f20131aed4d0a1"
+  revision = "bb9c189858d91f42db229b04d45a4c3d23a7662a"

 [[projects]]
  name = "golang.org/x/text"
@ -346,7 +349,7 @@
  branch = "master"
  name = "google.golang.org/genproto"
  packages = ["googleapis/rpc/status"]
-  revision = "f8c8703595236ae70fdf8789ecb656ea0bcdcf46"
+  revision = "7fd901a49ba6a7f87732eb344f6e3c5b19d1b200"

 [[projects]]
  name = "google.golang.org/grpc"
@ -375,12 +378,12 @@
 [[projects]]
  name = "gopkg.in/yaml.v2"
  packages = ["."]
-  revision = "7f97868eec74b32b0982dd158a51a446d1da7eb5"
-  version = "v2.1.1"
+  revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
+  version = "v2.2.1"

 [solve-meta]
  analyzer-name = "dep"
  analyzer-version = 1
-  inputs-digest = "4dca5dbd2d280d093d7c8fc423606ab86d6ad1b241b076a7716c2093b5a09231"
+  inputs-digest = "94cb2543199b0f4b6e9ac0e5b6469bdb77391da1c9f79f5b9792d7af936008ff"
  solver-name = "gps-cdcl"
  solver-version = 1
--- a/Gopkg.toml
+++ b/Gopkg.toml
@ -26,12 +26,12 @@


 [[constraint]]
-  branch = "master"
  name = "github.com/ebuchman/fail-test"
+  branch = "master"

 [[constraint]]
-  branch = "master"
  name = "github.com/fortytw2/leaktest"
+  branch = "master"

 [[constraint]]
  name = "github.com/go-kit/kit"
@ -54,8 +54,8 @@
  version = "~0.8.0"

 [[constraint]]
-  branch = "master"
  name = "github.com/rcrowley/go-metrics"
+  branch = "master"

 [[constraint]]
  name = "github.com/spf13/cobra"
@ -71,20 +71,19 @@

 [[constraint]]
  name = "github.com/tendermint/abci"
-  version = "~0.10.2"
+  version = "~0.10.3"

 [[constraint]]
  name = "github.com/tendermint/go-crypto"
-  version = "~0.5.0"
+  version = "~0.6.2"

 [[constraint]]
-  name = "github.com/tendermint/go-wire"
-  source = "github.com/tendermint/go-amino"
-  version = "~0.7.3"
+  name = "github.com/tendermint/go-amino"
+  version = "~0.9.7"

 [[constraint]]
  name = "github.com/tendermint/tmlibs"
-  version = "~0.7.1"
+  version = "~0.8.2-rc0"

 [[constraint]]
  name = "google.golang.org/grpc"
--- a/58
+++ b/58
@ -14,13 +14,13 @@ check: check_tools ensure_deps
 ### Build

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

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

 install:
-	go install $(BUILD_FLAGS) -tags '$(BUILD_TAGS)' ./cmd/tendermint
+	CGO_ENABLED=0 go install $(BUILD_FLAGS) -tags '$(BUILD_TAGS)' ./cmd/tendermint

 ########################################
 ### Distribution
@ -119,11 +119,6 @@ test_integrations:
 	make test_persistence
 	make test_p2p

-test_libs:
-	# checkout every github.com/tendermint dir and run its tests
-	# NOTE: on release-* or master branches only (set by Jenkins)
-	docker run --name run_libs -t tester bash test/test_libs.sh
-
 test_release:
 	@go test -tags release $(PACKAGES)

@ -183,7 +178,52 @@ metalinter_all:
 	@echo "--> Running linter (all)"
 	gometalinter.v2 --vendor --deadline=600s --enable-all --disable=lll ./...

+###########################################################
+### Docker image
+
+build-docker:
+	cp build/tendermint DOCKER/tendermint
+	docker build --label=tendermint --tag="tendermint/tendermint" DOCKER
+	rm -rf DOCKER/tendermint
+
+###########################################################
+### Local testnet using docker
+
+# Build linux binary on other platforms
+build-linux:
+	GOOS=linux GOARCH=amd64 $(MAKE) build
+
+# Run a 4-node testnet locally
+localnet-start:
+	@if ! [ -f build/node0/config/genesis.json ]; then docker run --rm -v $(CURDIR)/build:/tendermint:Z tendermint/localnode testnet --v 4 --o . --populate-persistent-peers --starting-ip-address 192.167.10.2 ; fi
+	docker-compose up
+
+# Stop testnet
+localnet-stop:
+	docker-compose down
+
+###########################################################
+### Remote full-nodes (sentry) using terraform and ansible
+
+# Server management
+sentry-start:
+	@if [ -z "$(DO_API_TOKEN)" ]; then echo "DO_API_TOKEN environment variable not set." ; false ; fi
+	@if ! [ -f $(HOME)/.ssh/id_rsa.pub ]; then ssh-keygen ; fi
+	cd networks/remote/terraform && terraform init && terraform apply -var DO_API_TOKEN="$(DO_API_TOKEN)" -var SSH_KEY_FILE="$(HOME)/.ssh/id_rsa.pub"
+	@if ! [ -f $(CURDIR)/build/node0/config/genesis.json ]; then docker run --rm -v $(CURDIR)/build:/tendermint:Z tendermint/localnode testnet --v 0 --n 4 --o . ; fi
+	cd networks/remote/ansible && ANSIBLE_HOST_KEY_CHECKING=False ansible-playbook -i inventory/digital_ocean.py -l sentrynet install.yml
+	@echo "Next step: Add your validator setup in the genesis.json and config.tml files and run \"make server-config\". (Public key of validator, chain ID, peer IP and node ID.)"
+
+# Configuration management
+sentry-config:
+	cd networks/remote/ansible && ansible-playbook -i inventory/digital_ocean.py -l sentrynet config.yml -e BINARY=$(CURDIR)/build/tendermint -e CONFIGDIR=$(CURDIR)/build
+
+sentry-stop:
+	@if [ -z "$(DO_API_TOKEN)" ]; then echo "DO_API_TOKEN environment variable not set." ; false ; fi
+	cd networks/remote/terraform && terraform destroy -var DO_API_TOKEN="$(DO_API_TOKEN)" -var SSH_KEY_FILE="$(HOME)/.ssh/id_rsa.pub"
+
 # 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 dist install check_tools get_tools update_tools get_vendor_deps draw_deps test_cover test_apps test_persistence test_p2p test test_race test_libs test_integrations test_release test100 vagrant_test fmt
+.PHONY: check build build_race dist install check_tools get_tools update_tools get_vendor_deps draw_deps test_cover test_apps test_persistence test_p2p test test_race test_integrations test_release test100 vagrant_test fmt build-linux localnet-start localnet-stop build-docker sentry-start sentry-config sentry-stop
+
--- a/README.md
+++ b/README.md
@ -24,7 +24,9 @@ _NOTE: This is alpha software. Please contact us if you intend to run it in prod
 Tendermint Core is Byzantine Fault Tolerant (BFT) middleware that takes a state transition machine - written in any programming language -
 and securely replicates it on many machines.

-For more information, from introduction to install to application development, [Read The Docs](https://tendermint.readthedocs.io/en/master/).
+For more information, from introduction to installation and application development, [Read The Docs](https://tendermint.readthedocs.io/en/master/).
+
+For protocol details, see [the specification](./docs/specification/new-spec).

 ## Minimum requirements

@ -46,7 +48,8 @@ For more details (or if it fails), [read the docs](https://tendermint.readthedoc

 ### Tendermint Core

-All resources involving the use of, building application on, or developing for, tendermint, can be found at [Read The Docs](https://tendermint.readthedocs.io/en/master/). Additional information about some - and eventually all - of the sub-projects below, can be found at Read The Docs.
+To use Tendermint, build apps on it, or develop it, [Read The Docs](https://tendermint.readthedocs.io/en/master/).
+Additional information about some - and eventually all - of the sub-projects below, can be found at Read The Docs.

 ### Sub-projects

@ -61,8 +64,8 @@ All resources involving the use of, building application on, or developing for,

 ### Applications

-* [Ethermint](http://github.com/tendermint/ethermint); Ethereum on Tendermint
 * [Cosmos SDK](http://github.com/cosmos/cosmos-sdk); a cryptocurrency application framework
+* [Ethermint](http://github.com/tendermint/ethermint); Ethereum on Tendermint
 * [Many more](https://tendermint.readthedocs.io/en/master/ecosystem.html#abci-applications)

 ### More
--- a/benchmarks/codec_test.go
+++ b/benchmarks/codec_test.go
@ -4,8 +4,8 @@ import (
 	"testing"
 	"time"

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

 	proto "github.com/tendermint/tendermint/benchmarks/proto"
 	"github.com/tendermint/tendermint/p2p"
@ -14,26 +14,35 @@ import (

 func BenchmarkEncodeStatusWire(b *testing.B) {
 	b.StopTimer()
-	pubKey := crypto.GenPrivKeyEd25519().PubKey()
+	cdc := amino.NewCodec()
+	ctypes.RegisterAmino(cdc)
+	nodeKey := p2p.NodeKey{PrivKey: crypto.GenPrivKeyEd25519()}
 	status := &ctypes.ResultStatus{
 		NodeInfo: p2p.NodeInfo{
-			PubKey:     pubKey,
+			ID:         nodeKey.ID(),
 			Moniker:    "SOMENAME",
 			Network:    "SOMENAME",
 			ListenAddr: "SOMEADDR",
 			Version:    "SOMEVER",
 			Other:      []string{"SOMESTRING", "OTHERSTRING"},
 		},
-		PubKey:            pubKey,
-		LatestBlockHash:   []byte("SOMEBYTES"),
-		LatestBlockHeight: 123,
-		LatestBlockTime:   time.Unix(0, 1234),
+		SyncInfo: ctypes.SyncInfo{
+			LatestBlockHash:   []byte("SOMEBYTES"),
+			LatestBlockHeight: 123,
+			LatestBlockTime:   time.Unix(0, 1234),
+		},
+		ValidatorInfo: ctypes.ValidatorInfo{
+			PubKey:            nodeKey.PubKey(),
+		},
 	}
 	b.StartTimer()

 	counter := 0
 	for i := 0; i < b.N; i++ {
-		jsonBytes := wire.JSONBytes(status)
+		jsonBytes, err := cdc.MarshalJSON(status)
+		if err != nil {
+			panic(err)
+		}
 		counter += len(jsonBytes)
 	}

@ -41,9 +50,11 @@ func BenchmarkEncodeStatusWire(b *testing.B) {

 func BenchmarkEncodeNodeInfoWire(b *testing.B) {
 	b.StopTimer()
-	pubKey := crypto.GenPrivKeyEd25519().PubKey()
+	cdc := amino.NewCodec()
+	ctypes.RegisterAmino(cdc)
+	nodeKey := p2p.NodeKey{PrivKey: crypto.GenPrivKeyEd25519()}
 	nodeInfo := p2p.NodeInfo{
-		PubKey:     pubKey,
+		ID:         nodeKey.ID(),
 		Moniker:    "SOMENAME",
 		Network:    "SOMENAME",
 		ListenAddr: "SOMEADDR",
@ -54,16 +65,21 @@ func BenchmarkEncodeNodeInfoWire(b *testing.B) {

 	counter := 0
 	for i := 0; i < b.N; i++ {
-		jsonBytes := wire.JSONBytes(nodeInfo)
+		jsonBytes, err := cdc.MarshalJSON(nodeInfo)
+		if err != nil {
+			panic(err)
+		}
 		counter += len(jsonBytes)
 	}
 }

 func BenchmarkEncodeNodeInfoBinary(b *testing.B) {
 	b.StopTimer()
-	pubKey := crypto.GenPrivKeyEd25519().PubKey()
+	cdc := amino.NewCodec()
+	ctypes.RegisterAmino(cdc)
+	nodeKey := p2p.NodeKey{PrivKey: crypto.GenPrivKeyEd25519()}
 	nodeInfo := p2p.NodeInfo{
-		PubKey:     pubKey,
+		ID:         nodeKey.ID(),
 		Moniker:    "SOMENAME",
 		Network:    "SOMENAME",
 		ListenAddr: "SOMEADDR",
@ -74,7 +90,7 @@ func BenchmarkEncodeNodeInfoBinary(b *testing.B) {

 	counter := 0
 	for i := 0; i < b.N; i++ {
-		jsonBytes := wire.BinaryBytes(nodeInfo)
+		jsonBytes := cdc.MustMarshalBinaryBare(nodeInfo)
 		counter += len(jsonBytes)
 	}

@ -82,15 +98,20 @@ func BenchmarkEncodeNodeInfoBinary(b *testing.B) {

 func BenchmarkEncodeNodeInfoProto(b *testing.B) {
 	b.StopTimer()
-	pubKey := crypto.GenPrivKeyEd25519().PubKey().Unwrap().(crypto.PubKeyEd25519)
-	pubKey2 := &proto.PubKey{Ed25519: &proto.PubKeyEd25519{Bytes: pubKey[:]}}
+	nodeKey := p2p.NodeKey{PrivKey: crypto.GenPrivKeyEd25519()}
+	nodeID := string(nodeKey.ID())
+	someName := "SOMENAME"
+	someAddr := "SOMEADDR"
+	someVer := "SOMEVER"
+	someString := "SOMESTRING"
+	otherString := "OTHERSTRING"
 	nodeInfo := proto.NodeInfo{
-		PubKey:     pubKey2,
-		Moniker:    "SOMENAME",
-		Network:    "SOMENAME",
-		ListenAddr: "SOMEADDR",
-		Version:    "SOMEVER",
-		Other:      []string{"SOMESTRING", "OTHERSTRING"},
+		Id:         &proto.ID{Id: &nodeID},
+		Moniker:    &someName,
+		Network:    &someName,
+		ListenAddr: &someAddr,
+		Version:    &someVer,
+		Other:      []string{someString, otherString},
 	}
 	b.StartTimer()

--- a/benchmarks/proto/test.pb.go
+++ b/benchmarks/proto/test.pb.go
--- a/benchmarks/proto/test.proto
+++ b/benchmarks/proto/test.proto
@ -7,7 +7,7 @@ message ResultStatus {
 }

 message NodeInfo {
-  required PubKey pubKey = 1;
+  required ID id = 1;
  required string moniker = 2;
  required string network = 3;
  required string remoteAddr = 4;
@ -16,6 +16,10 @@ message NodeInfo {
  repeated string other = 7;
 }

+message ID {
+  required string id = 1;
+}
+
 message PubKey {
  optional PubKeyEd25519 ed25519 = 1;
 }
--- a/blockchain/reactor.go
+++ b/blockchain/reactor.go
@ -1,21 +1,16 @@
 package blockchain

 import (
-	"bytes"
-	"errors"
 	"fmt"
 	"reflect"
-	"sync"
 	"time"

-	wire "github.com/tendermint/go-wire"
-
-	cmn "github.com/tendermint/tmlibs/common"
-	"github.com/tendermint/tmlibs/log"
-
+	"github.com/tendermint/go-amino"
 	"github.com/tendermint/tendermint/p2p"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
+	cmn "github.com/tendermint/tmlibs/common"
+	"github.com/tendermint/tmlibs/log"
 )

 const (
@ -31,6 +26,13 @@ const (
 	statusUpdateIntervalSeconds = 10
 	// check if we should switch to consensus reactor
 	switchToConsensusIntervalSeconds = 1
+
+	// NOTE: keep up to date with bcBlockResponseMessage
+	bcBlockResponseMessagePrefixSize   = 4
+	bcBlockResponseMessageFieldKeySize = 1
+	maxMsgSize                         = types.MaxBlockSizeBytes +
+		bcBlockResponseMessagePrefixSize +
+		bcBlockResponseMessageFieldKeySize
 )

 type consensusReactor interface {
@ -52,9 +54,6 @@ func (e peerError) Error() string {
 type BlockchainReactor struct {
 	p2p.BaseReactor

-	mtx    sync.Mutex
-	params types.ConsensusParams
-
 	// immutable
 	initialState sm.State

@ -87,7 +86,6 @@ func NewBlockchainReactor(state sm.State, blockExec *sm.BlockExecutor, store *Bl
 	)

 	bcR := &BlockchainReactor{
-		params:       state.ConsensusParams,
 		initialState: state,
 		blockExec:    blockExec,
 		store:        store,
@ -131,17 +129,19 @@ func (bcR *BlockchainReactor) OnStop() {
 func (bcR *BlockchainReactor) GetChannels() []*p2p.ChannelDescriptor {
 	return []*p2p.ChannelDescriptor{
 		{
-			ID:                BlockchainChannel,
-			Priority:          10,
-			SendQueueCapacity: 1000,
+			ID:                  BlockchainChannel,
+			Priority:            10,
+			SendQueueCapacity:   1000,
+			RecvBufferCapacity:  50 * 4096,
+			RecvMessageCapacity: maxMsgSize,
 		},
 	}
 }

 // AddPeer implements Reactor by sending our state to peer.
 func (bcR *BlockchainReactor) AddPeer(peer p2p.Peer) {
-	if !peer.Send(BlockchainChannel,
-		struct{ BlockchainMessage }{&bcStatusResponseMessage{bcR.store.Height()}}) {
+	msgBytes := cdc.MustMarshalBinaryBare(&bcStatusResponseMessage{bcR.store.Height()})
+	if !peer.Send(BlockchainChannel, msgBytes) {
 		// doing nothing, will try later in `poolRoutine`
 	}
 	// peer is added to the pool once we receive the first
@ -162,20 +162,19 @@ func (bcR *BlockchainReactor) respondToPeer(msg *bcBlockRequestMessage,

 	block := bcR.store.LoadBlock(msg.Height)
 	if block != nil {
-		msg := &bcBlockResponseMessage{Block: block}
-		return src.TrySend(BlockchainChannel, struct{ BlockchainMessage }{msg})
+		msgBytes := cdc.MustMarshalBinaryBare(&bcBlockResponseMessage{Block: block})
+		return src.TrySend(BlockchainChannel, msgBytes)
 	}

 	bcR.Logger.Info("Peer asking for a block we don't have", "src", src, "height", msg.Height)

-	return src.TrySend(BlockchainChannel, struct{ BlockchainMessage }{
-		&bcNoBlockResponseMessage{Height: msg.Height},
-	})
+	msgBytes := cdc.MustMarshalBinaryBare(&bcNoBlockResponseMessage{Height: msg.Height})
+	return src.TrySend(BlockchainChannel, msgBytes)
 }

 // Receive implements Reactor by handling 4 types of messages (look below).
 func (bcR *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
-	_, msg, err := DecodeMessage(msgBytes, bcR.maxMsgSize())
+	msg, err := DecodeMessage(msgBytes)
 	if err != nil {
 		bcR.Logger.Error("Error decoding message", "src", src, "chId", chID, "msg", msg, "err", err, "bytes", msgBytes)
 		bcR.Switch.StopPeerForError(src, err)
@ -194,8 +193,8 @@ func (bcR *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)
 		bcR.pool.AddBlock(src.ID(), msg.Block, len(msgBytes))
 	case *bcStatusRequestMessage:
 		// Send peer our state.
-		queued := src.TrySend(BlockchainChannel,
-			struct{ BlockchainMessage }{&bcStatusResponseMessage{bcR.store.Height()}})
+		msgBytes := cdc.MustMarshalBinaryBare(&bcStatusResponseMessage{bcR.store.Height()})
+		queued := src.TrySend(BlockchainChannel, msgBytes)
 		if !queued {
 			// sorry
 		}
@ -207,21 +206,6 @@ func (bcR *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)
 	}
 }

-// maxMsgSize returns the maximum allowable size of a
-// message on the blockchain reactor.
-func (bcR *BlockchainReactor) maxMsgSize() int {
-	bcR.mtx.Lock()
-	defer bcR.mtx.Unlock()
-	return bcR.params.BlockSize.MaxBytes + 2
-}
-
-// updateConsensusParams updates the internal consensus params
-func (bcR *BlockchainReactor) updateConsensusParams(params types.ConsensusParams) {
-	bcR.mtx.Lock()
-	defer bcR.mtx.Unlock()
-	bcR.params = params
-}
-
 // Handle messages from the poolReactor telling the reactor what to do.
 // NOTE: Don't sleep in the FOR_LOOP or otherwise slow it down!
 // (Except for the SYNC_LOOP, which is the primary purpose and must be synchronous.)
@ -247,8 +231,8 @@ FOR_LOOP:
 			if peer == nil {
 				continue FOR_LOOP // Peer has since been disconnected.
 			}
-			msg := &bcBlockRequestMessage{request.Height}
-			queued := peer.TrySend(BlockchainChannel, struct{ BlockchainMessage }{msg})
+			msgBytes := cdc.MustMarshalBinaryBare(&bcBlockRequestMessage{request.Height})
+			queued := peer.TrySend(BlockchainChannel, msgBytes)
 			if !queued {
 				// We couldn't make the request, send-queue full.
 				// The pool handles timeouts, just let it go.
@ -321,9 +305,6 @@ FOR_LOOP:
 					}
 					blocksSynced++

-					// update the consensus params
-					bcR.updateConsensusParams(state.ConsensusParams)
-
 					if blocksSynced%100 == 0 {
 						lastRate = 0.9*lastRate + 0.1*(100/time.Since(lastHundred).Seconds())
 						bcR.Logger.Info("Fast Sync Rate", "height", bcR.pool.height,
@ -341,43 +322,36 @@ FOR_LOOP:

 // BroadcastStatusRequest broadcasts `BlockStore` height.
 func (bcR *BlockchainReactor) BroadcastStatusRequest() error {
-	bcR.Switch.Broadcast(BlockchainChannel,
-		struct{ BlockchainMessage }{&bcStatusRequestMessage{bcR.store.Height()}})
+	msgBytes := cdc.MustMarshalBinaryBare(&bcStatusRequestMessage{bcR.store.Height()})
+	bcR.Switch.Broadcast(BlockchainChannel, msgBytes)
 	return nil
 }

 //-----------------------------------------------------------------------------
 // Messages

-const (
-	msgTypeBlockRequest    = byte(0x10)
-	msgTypeBlockResponse   = byte(0x11)
-	msgTypeNoBlockResponse = byte(0x12)
-	msgTypeStatusResponse  = byte(0x20)
-	msgTypeStatusRequest   = byte(0x21)
-)
-
 // BlockchainMessage is a generic message for this reactor.
 type BlockchainMessage interface{}

-var _ = wire.RegisterInterface(
-	struct{ BlockchainMessage }{},
-	wire.ConcreteType{&bcBlockRequestMessage{}, msgTypeBlockRequest},
-	wire.ConcreteType{&bcBlockResponseMessage{}, msgTypeBlockResponse},
-	wire.ConcreteType{&bcNoBlockResponseMessage{}, msgTypeNoBlockResponse},
-	wire.ConcreteType{&bcStatusResponseMessage{}, msgTypeStatusResponse},
-	wire.ConcreteType{&bcStatusRequestMessage{}, msgTypeStatusRequest},
-)
+func RegisterBlockchainMessages(cdc *amino.Codec) {
+	cdc.RegisterInterface((*BlockchainMessage)(nil), nil)
+	cdc.RegisterConcrete(&bcBlockRequestMessage{}, "tendermint/mempool/BlockRequest", nil)
+	cdc.RegisterConcrete(&bcBlockResponseMessage{}, "tendermint/mempool/BlockResponse", nil)
+	cdc.RegisterConcrete(&bcNoBlockResponseMessage{}, "tendermint/mempool/NoBlockResponse", nil)
+	cdc.RegisterConcrete(&bcStatusResponseMessage{}, "tendermint/mempool/StatusResponse", nil)
+	cdc.RegisterConcrete(&bcStatusRequestMessage{}, "tendermint/mempool/StatusRequest", nil)
+}

 // DecodeMessage decodes BlockchainMessage.
 // TODO: ensure that bz is completely read.
-func DecodeMessage(bz []byte, maxSize int) (msgType byte, msg BlockchainMessage, err error) {
-	msgType = bz[0]
-	n := int(0)
-	r := bytes.NewReader(bz)
-	msg = wire.ReadBinary(struct{ BlockchainMessage }{}, r, maxSize, &n, &err).(struct{ BlockchainMessage }).BlockchainMessage
-	if err != nil && n != len(bz) {
-		err = errors.New("DecodeMessage() had bytes left over")
+func DecodeMessage(bz []byte) (msg BlockchainMessage, err error) {
+	if len(bz) > maxMsgSize {
+		return msg, fmt.Errorf("Msg exceeds max size (%d > %d)",
+			len(bz), maxMsgSize)
+	}
+	err = cdc.UnmarshalBinaryBare(bz, &msg)
+	if err != nil {
+		err = cmn.ErrorWrap(err, "DecodeMessage() had bytes left over")
 	}
 	return
 }
@ -402,7 +376,6 @@ func (brm *bcNoBlockResponseMessage) String() string {

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

-// NOTE: keep up-to-date with maxBlockchainResponseSize
 type bcBlockResponseMessage struct {
 	Block *types.Block
 }
--- a/blockchain/reactor_test.go
+++ b/blockchain/reactor_test.go
@ -3,8 +3,6 @@ package blockchain
 import (
 	"testing"

-	wire "github.com/tendermint/go-wire"
-
 	cmn "github.com/tendermint/tmlibs/common"
 	dbm "github.com/tendermint/tmlibs/db"
 	"github.com/tendermint/tmlibs/log"
@ -18,8 +16,15 @@ import (

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

@ -76,10 +81,9 @@ func TestNoBlockResponse(t *testing.T) {
 	// wait for our response to be received on the peer
 	for _, tt := range tests {
 		reqBlockMsg := &bcBlockRequestMessage{tt.height}
-		reqBlockBytes := wire.BinaryBytes(struct{ BlockchainMessage }{reqBlockMsg})
+		reqBlockBytes := cdc.MustMarshalBinaryBare(reqBlockMsg)
 		bcr.Receive(chID, peer, reqBlockBytes)
-		value := peer.lastValue()
-		msg := value.(struct{ BlockchainMessage }).BlockchainMessage
+		msg := peer.lastBlockchainMessage()

 		if tt.existent {
 			if blockMsg, ok := msg.(*bcBlockResponseMessage); !ok {
@ -173,26 +177,30 @@ func newbcrTestPeer(id p2p.ID) *bcrTestPeer {
 	return bcr
 }

-func (tp *bcrTestPeer) lastValue() interface{} { return <-tp.ch }
+func (tp *bcrTestPeer) lastBlockchainMessage() interface{} { return <-tp.ch }

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

-func (tp *bcrTestPeer) Send(chID byte, data interface{}) bool { return tp.TrySend(chID, data) }
-func (tp *bcrTestPeer) NodeInfo() p2p.NodeInfo                { return p2p.NodeInfo{} }
-func (tp *bcrTestPeer) Status() p2p.ConnectionStatus          { return p2p.ConnectionStatus{} }
-func (tp *bcrTestPeer) ID() p2p.ID                            { return tp.id }
-func (tp *bcrTestPeer) IsOutbound() bool                      { return false }
-func (tp *bcrTestPeer) IsPersistent() bool                    { return true }
-func (tp *bcrTestPeer) Get(s string) interface{}              { return s }
-func (tp *bcrTestPeer) Set(string, interface{})               {}
+func (tp *bcrTestPeer) Send(chID byte, msgBytes []byte) bool { return tp.TrySend(chID, msgBytes) }
+func (tp *bcrTestPeer) NodeInfo() p2p.NodeInfo               { return p2p.NodeInfo{} }
+func (tp *bcrTestPeer) Status() p2p.ConnectionStatus         { return p2p.ConnectionStatus{} }
+func (tp *bcrTestPeer) ID() p2p.ID                           { return tp.id }
+func (tp *bcrTestPeer) IsOutbound() bool                     { return false }
+func (tp *bcrTestPeer) IsPersistent() bool                   { return true }
+func (tp *bcrTestPeer) Get(s string) interface{}             { return s }
+func (tp *bcrTestPeer) Set(string, interface{})              {}
--- a/blockchain/store.go
+++ b/blockchain/store.go
@ -1,14 +1,9 @@
 package blockchain

 import (
-	"bytes"
-	"encoding/json"
 	"fmt"
-	"io"
 	"sync"

-	wire "github.com/tendermint/go-wire"
-
 	cmn "github.com/tendermint/tmlibs/common"
 	dbm "github.com/tendermint/tmlibs/db"

@ -54,38 +49,25 @@ func (bs *BlockStore) Height() int64 {
 	return bs.height
 }

-// GetReader returns the value associated with the given key wrapped in an io.Reader.
-// If no value is found, it returns nil.
-// It's mainly for use with wire.ReadBinary.
-func (bs *BlockStore) GetReader(key []byte) io.Reader {
-	bytez := bs.db.Get(key)
-	if bytez == nil {
-		return nil
-	}
-	return bytes.NewReader(bytez)
-}
-
 // LoadBlock returns the block with the given height.
 // If no block is found for that height, it returns nil.
 func (bs *BlockStore) LoadBlock(height int64) *types.Block {
-	var n int
-	var err error
-	r := bs.GetReader(calcBlockMetaKey(height))
-	if r == nil {
+	var blockMeta = bs.LoadBlockMeta(height)
+	if blockMeta == nil {
 		return nil
 	}
-	blockMeta := wire.ReadBinary(&types.BlockMeta{}, r, 0, &n, &err).(*types.BlockMeta)
-	if err != nil {
-		panic(fmt.Sprintf("Error reading block meta: %v", err))
-	}
-	bytez := []byte{}
+
+	var block = new(types.Block)
+	buf := []byte{}
 	for i := 0; i < blockMeta.BlockID.PartsHeader.Total; i++ {
 		part := bs.LoadBlockPart(height, i)
-		bytez = append(bytez, part.Bytes...)
+		buf = append(buf, part.Bytes...)
 	}
-	block := wire.ReadBinary(&types.Block{}, bytes.NewReader(bytez), 0, &n, &err).(*types.Block)
+	err := cdc.UnmarshalBinary(buf, block)
 	if err != nil {
-		panic(fmt.Sprintf("Error reading block: %v", err))
+		// NOTE: The existence of meta should imply the existence of the
+		// block. So, make sure meta is only saved after blocks are saved.
+		panic(cmn.ErrorWrap(err, "Error reading block"))
 	}
 	return block
 }
@ -94,15 +76,14 @@ func (bs *BlockStore) LoadBlock(height int64) *types.Block {
 // from the block at the given height.
 // If no part is found for the given height and index, it returns nil.
 func (bs *BlockStore) LoadBlockPart(height int64, index int) *types.Part {
-	var n int
-	var err error
-	r := bs.GetReader(calcBlockPartKey(height, index))
-	if r == nil {
+	var part = new(types.Part)
+	bz := bs.db.Get(calcBlockPartKey(height, index))
+	if len(bz) == 0 {
 		return nil
 	}
-	part := wire.ReadBinary(&types.Part{}, r, 0, &n, &err).(*types.Part)
+	err := cdc.UnmarshalBinaryBare(bz, part)
 	if err != nil {
-		panic(fmt.Sprintf("Error reading block part: %v", err))
+		panic(cmn.ErrorWrap(err, "Error reading block part"))
 	}
 	return part
 }
@ -110,15 +91,14 @@ func (bs *BlockStore) LoadBlockPart(height int64, index int) *types.Part {
 // LoadBlockMeta returns the BlockMeta for the given height.
 // If no block is found for the given height, it returns nil.
 func (bs *BlockStore) LoadBlockMeta(height int64) *types.BlockMeta {
-	var n int
-	var err error
-	r := bs.GetReader(calcBlockMetaKey(height))
-	if r == nil {
+	var blockMeta = new(types.BlockMeta)
+	bz := bs.db.Get(calcBlockMetaKey(height))
+	if len(bz) == 0 {
 		return nil
 	}
-	blockMeta := wire.ReadBinary(&types.BlockMeta{}, r, 0, &n, &err).(*types.BlockMeta)
+	err := cdc.UnmarshalBinaryBare(bz, blockMeta)
 	if err != nil {
-		panic(fmt.Sprintf("Error reading block meta: %v", err))
+		panic(cmn.ErrorWrap(err, "Error reading block meta"))
 	}
 	return blockMeta
 }
@ -128,15 +108,14 @@ func (bs *BlockStore) LoadBlockMeta(height int64) *types.BlockMeta {
 // and it comes from the block.LastCommit for `height+1`.
 // If no commit is found for the given height, it returns nil.
 func (bs *BlockStore) LoadBlockCommit(height int64) *types.Commit {
-	var n int
-	var err error
-	r := bs.GetReader(calcBlockCommitKey(height))
-	if r == nil {
+	var commit = new(types.Commit)
+	bz := bs.db.Get(calcBlockCommitKey(height))
+	if len(bz) == 0 {
 		return nil
 	}
-	commit := wire.ReadBinary(&types.Commit{}, r, 0, &n, &err).(*types.Commit)
+	err := cdc.UnmarshalBinaryBare(bz, commit)
 	if err != nil {
-		panic(fmt.Sprintf("Error reading commit: %v", err))
+		panic(cmn.ErrorWrap(err, "Error reading block commit"))
 	}
 	return commit
 }
@ -145,15 +124,14 @@ func (bs *BlockStore) LoadBlockCommit(height int64) *types.Commit {
 // This is useful when we've seen a commit, but there has not yet been
 // a new block at `height + 1` that includes this commit in its block.LastCommit.
 func (bs *BlockStore) LoadSeenCommit(height int64) *types.Commit {
-	var n int
-	var err error
-	r := bs.GetReader(calcSeenCommitKey(height))
-	if r == nil {
+	var commit = new(types.Commit)
+	bz := bs.db.Get(calcSeenCommitKey(height))
+	if len(bz) == 0 {
 		return nil
 	}
-	commit := wire.ReadBinary(&types.Commit{}, r, 0, &n, &err).(*types.Commit)
+	err := cdc.UnmarshalBinaryBare(bz, commit)
 	if err != nil {
-		panic(fmt.Sprintf("Error reading commit: %v", err))
+		panic(cmn.ErrorWrap(err, "Error reading block seen commit"))
 	}
 	return commit
 }
@ -178,21 +156,22 @@ func (bs *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, s

 	// Save block meta
 	blockMeta := types.NewBlockMeta(block, blockParts)
-	metaBytes := wire.BinaryBytes(blockMeta)
+	metaBytes := cdc.MustMarshalBinaryBare(blockMeta)
 	bs.db.Set(calcBlockMetaKey(height), metaBytes)

 	// Save block parts
 	for i := 0; i < blockParts.Total(); i++ {
-		bs.saveBlockPart(height, i, blockParts.GetPart(i))
+		part := blockParts.GetPart(i)
+		bs.saveBlockPart(height, i, part)
 	}

 	// Save block commit (duplicate and separate from the Block)
-	blockCommitBytes := wire.BinaryBytes(block.LastCommit)
+	blockCommitBytes := cdc.MustMarshalBinaryBare(block.LastCommit)
 	bs.db.Set(calcBlockCommitKey(height-1), blockCommitBytes)

 	// Save seen commit (seen +2/3 precommits for block)
 	// NOTE: we can delete this at a later height
-	seenCommitBytes := wire.BinaryBytes(seenCommit)
+	seenCommitBytes := cdc.MustMarshalBinaryBare(seenCommit)
 	bs.db.Set(calcSeenCommitKey(height), seenCommitBytes)

 	// Save new BlockStoreStateJSON descriptor
@ -211,7 +190,7 @@ func (bs *BlockStore) saveBlockPart(height int64, index int, part *types.Part) {
 	if height != bs.Height()+1 {
 		cmn.PanicSanity(cmn.Fmt("BlockStore can only save contiguous blocks. Wanted %v, got %v", bs.Height()+1, height))
 	}
-	partBytes := wire.BinaryBytes(part)
+	partBytes := cdc.MustMarshalBinaryBare(part)
 	bs.db.Set(calcBlockPartKey(height, index), partBytes)
 }

@ -238,12 +217,12 @@ func calcSeenCommitKey(height int64) []byte {
 var blockStoreKey = []byte("blockStore")

 type BlockStoreStateJSON struct {
-	Height int64
+	Height int64 `json:"height"`
 }

 // Save persists the blockStore state to the database as JSON.
 func (bsj BlockStoreStateJSON) Save(db dbm.DB) {
-	bytes, err := json.Marshal(bsj)
+	bytes, err := cdc.MarshalJSON(bsj)
 	if err != nil {
 		cmn.PanicSanity(cmn.Fmt("Could not marshal state bytes: %v", err))
 	}
@ -260,7 +239,7 @@ func LoadBlockStoreStateJSON(db dbm.DB) BlockStoreStateJSON {
 		}
 	}
 	bsj := BlockStoreStateJSON{}
-	err := json.Unmarshal(bytes, &bsj)
+	err := cdc.UnmarshalJSON(bytes, &bsj)
 	if err != nil {
 		panic(fmt.Sprintf("Could not unmarshal bytes: %X", bytes))
 	}
--- a/blockchain/store_test.go
+++ b/blockchain/store_test.go
@ -3,7 +3,6 @@ package blockchain
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
 	"runtime/debug"
 	"strings"
 	"testing"
@ -11,9 +10,6 @@ import (

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-
-	wire "github.com/tendermint/go-wire"
-
 	"github.com/tendermint/tmlibs/db"
 	"github.com/tendermint/tmlibs/log"

@ -35,7 +31,7 @@ func TestNewBlockStore(t *testing.T) {
 	db := db.NewMemDB()
 	db.Set(blockStoreKey, []byte(`{"height": 10000}`))
 	bs := NewBlockStore(db)
-	assert.Equal(t, bs.Height(), int64(10000), "failed to properly parse blockstore")
+	require.Equal(t, int64(10000), bs.Height(), "failed to properly parse blockstore")

 	panicCausers := []struct {
 		data    []byte
@ -61,38 +57,6 @@ func TestNewBlockStore(t *testing.T) {
 	assert.Equal(t, bs.Height(), int64(0), "expecting nil bytes to be unmarshaled alright")
 }

-func TestBlockStoreGetReader(t *testing.T) {
-	db := db.NewMemDB()
-	// Initial setup
-	db.Set([]byte("Foo"), []byte("Bar"))
-	db.Set([]byte("Foo1"), nil)
-
-	bs := NewBlockStore(db)
-
-	tests := [...]struct {
-		key  []byte
-		want []byte
-	}{
-		0: {key: []byte("Foo"), want: []byte("Bar")},
-		1: {key: []byte("KnoxNonExistent"), want: nil},
-		2: {key: []byte("Foo1"), want: []byte{}},
-	}
-
-	for i, tt := range tests {
-		r := bs.GetReader(tt.key)
-		if r == nil {
-			assert.Nil(t, tt.want, "#%d: expected a non-nil reader", i)
-			continue
-		}
-		slurp, err := ioutil.ReadAll(r)
-		if err != nil {
-			t.Errorf("#%d: unexpected Read err: %v", i, err)
-		} else {
-			assert.Equal(t, slurp, tt.want, "#%d: mismatch", i)
-		}
-	}
-}
-
 func freshBlockStore() (*BlockStore, db.DB) {
 	db := db.NewMemDB()
 	return NewBlockStore(db), db
@ -189,14 +153,14 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 			parts:             validPartSet,
 			seenCommit:        seenCommit1,
 			corruptCommitInDB: true, // Corrupt the DB's commit entry
-			wantPanic:         "rror reading commit",
+			wantPanic:         "Error reading block commit",
 		},

 		{
 			block:            newBlock(&header1, commitAtH10),
 			parts:            validPartSet,
 			seenCommit:       seenCommit1,
-			wantPanic:        "rror reading block",
+			wantPanic:        "Error reading block",
 			corruptBlockInDB: true, // Corrupt the DB's block entry
 		},

@ -215,7 +179,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 			seenCommit: seenCommit1,

 			corruptSeenCommitInDB: true,
-			wantPanic:             "rror reading commit",
+			wantPanic:             "Error reading block seen commit",
 		},

 		{
@ -305,14 +269,6 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 	}
 }

-func binarySerializeIt(v interface{}) []byte {
-	var n int
-	var err error
-	buf := new(bytes.Buffer)
-	wire.WriteBinary(v, buf, &n, &err)
-	return buf.Bytes()
-}
-
 func TestLoadBlockPart(t *testing.T) {
 	bs, db := freshBlockStore()
 	height, index := int64(10), 1
@ -334,7 +290,7 @@ func TestLoadBlockPart(t *testing.T) {
 	require.Contains(t, panicErr.Error(), "Error reading block part")

 	// 3. A good block serialized and saved to the DB should be retrievable
-	db.Set(calcBlockPartKey(height, index), binarySerializeIt(part1))
+	db.Set(calcBlockPartKey(height, index), cdc.MustMarshalBinaryBare(part1))
 	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")
@ -364,11 +320,11 @@ func TestLoadBlockMeta(t *testing.T) {

 	// 3. A good blockMeta serialized and saved to the DB should be retrievable
 	meta := &types.BlockMeta{}
-	db.Set(calcBlockMetaKey(height), binarySerializeIt(meta))
+	db.Set(calcBlockMetaKey(height), cdc.MustMarshalBinaryBare(meta))
 	gotMeta, _, panicErr := doFn(loadMeta)
 	require.Nil(t, panicErr, "an existent and proper block should not panic")
 	require.Nil(t, res, "a properly saved blockMeta should return a proper blocMeta ")
-	require.Equal(t, binarySerializeIt(meta), binarySerializeIt(gotMeta),
+	require.Equal(t, cdc.MustMarshalBinaryBare(meta), cdc.MustMarshalBinaryBare(gotMeta),
 		"expecting successful retrieval of previously saved blockMeta")
 }

@ -385,6 +341,9 @@ func TestBlockFetchAtHeight(t *testing.T) {
 	require.Equal(t, bs.Height(), block.Header.Height, "expecting the new height to be changed")

 	blockAtHeight := bs.LoadBlock(bs.Height())
+	bz1 := cdc.MustMarshalBinaryBare(block)
+	bz2 := cdc.MustMarshalBinaryBare(blockAtHeight)
+	require.Equal(t, bz1, bz2)
 	require.Equal(t, block.Hash(), blockAtHeight.Hash(),
 		"expecting a successful load of the last saved block")

--- a/blockchain/wire.go
+++ b/blockchain/wire.go
@ -0,0 +1,13 @@
+package blockchain
+
+import (
+	"github.com/tendermint/go-amino"
+	"github.com/tendermint/go-crypto"
+)
+
+var cdc = amino.NewCodec()
+
+func init() {
+	RegisterBlockchainMessages(cdc)
+	crypto.RegisterAmino(cdc)
+}
--- a/cmd/priv_val_server/main.go
+++ b/cmd/priv_val_server/main.go
@ -30,7 +30,7 @@ func main() {
 		"privPath", *privValPath,
 	)

-	privVal := priv_val.LoadPrivValidatorJSON(*privValPath)
+	privVal := priv_val.LoadFilePV(*privValPath)

 	rs := priv_val.NewRemoteSigner(
 		logger,
--- a/cmd/tendermint/commands/gen_node_key.go
+++ b/cmd/tendermint/commands/gen_node_key.go
@ -0,0 +1,32 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	"github.com/tendermint/tendermint/p2p"
+	cmn "github.com/tendermint/tmlibs/common"
+)
+
+// GenNodeKeyCmd allows the generation of a node key. It prints node's ID to
+// the standard output.
+var GenNodeKeyCmd = &cobra.Command{
+	Use:   "gen_node_key",
+	Short: "Generate a node key for this node and print its ID",
+	RunE:  genNodeKey,
+}
+
+func genNodeKey(cmd *cobra.Command, args []string) error {
+	nodeKeyFile := config.NodeKeyFile()
+	if cmn.FileExists(nodeKeyFile) {
+		return fmt.Errorf("node key at %s already exists", nodeKeyFile)
+	}
+
+	nodeKey, err := p2p.LoadOrGenNodeKey(nodeKeyFile)
+	if err != nil {
+		return err
+	}
+	fmt.Println(nodeKey.ID())
+	return nil
+}
--- a/cmd/tendermint/commands/gen_validator.go
+++ b/cmd/tendermint/commands/gen_validator.go
@ -1,12 +1,11 @@
 package commands

 import (
-	"encoding/json"
 	"fmt"

 	"github.com/spf13/cobra"

-	"github.com/tendermint/tendermint/types"
+	pvm "github.com/tendermint/tendermint/types/priv_validator"
 )

 // GenValidatorCmd allows the generation of a keypair for a
@ -18,11 +17,11 @@ var GenValidatorCmd = &cobra.Command{
 }

 func genValidator(cmd *cobra.Command, args []string) {
-	privValidator := types.GenPrivValidatorFS("")
-	privValidatorJSONBytes, err := json.MarshalIndent(privValidator, "", "\t")
+	pv := pvm.GenFilePV("")
+	jsbz, err := cdc.MarshalJSON(pv)
 	if err != nil {
 		panic(err)
 	}
 	fmt.Printf(`%v
-`, string(privValidatorJSONBytes))
+`, string(jsbz))
 }
--- a/cmd/tendermint/commands/init.go
+++ b/cmd/tendermint/commands/init.go
@ -3,7 +3,10 @@ package commands
 import (
 	"github.com/spf13/cobra"

+	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/types"
+	pvm "github.com/tendermint/tendermint/types/priv_validator"
 	cmn "github.com/tendermint/tmlibs/common"
 )

@ -11,22 +14,36 @@ import (
 var InitFilesCmd = &cobra.Command{
 	Use:   "init",
 	Short: "Initialize Tendermint",
-	Run:   initFiles,
+	RunE:  initFiles,
 }

-func initFiles(cmd *cobra.Command, args []string) {
+func initFiles(cmd *cobra.Command, args []string) error {
+	return initFilesWithConfig(config)
+}
+
+func initFilesWithConfig(config *cfg.Config) error {
 	// private validator
 	privValFile := config.PrivValidatorFile()
-	var privValidator *types.PrivValidatorFS
+	var pv *pvm.FilePV
 	if cmn.FileExists(privValFile) {
-		privValidator = types.LoadPrivValidatorFS(privValFile)
+		pv = pvm.LoadFilePV(privValFile)
 		logger.Info("Found private validator", "path", privValFile)
 	} else {
-		privValidator = types.GenPrivValidatorFS(privValFile)
-		privValidator.Save()
+		pv = pvm.GenFilePV(privValFile)
+		pv.Save()
 		logger.Info("Generated private validator", "path", privValFile)
 	}

+	nodeKeyFile := config.NodeKeyFile()
+	if cmn.FileExists(nodeKeyFile) {
+		logger.Info("Found node key", "path", nodeKeyFile)
+	} else {
+		if _, err := p2p.LoadOrGenNodeKey(nodeKeyFile); err != nil {
+			return err
+		}
+		logger.Info("Generated node key", "path", nodeKeyFile)
+	}
+
 	// genesis file
 	genFile := config.GenesisFile()
 	if cmn.FileExists(genFile) {
@ -36,13 +53,15 @@ func initFiles(cmd *cobra.Command, args []string) {
 			ChainID: cmn.Fmt("test-chain-%v", cmn.RandStr(6)),
 		}
 		genDoc.Validators = []types.GenesisValidator{{
-			PubKey: privValidator.GetPubKey(),
+			PubKey: pv.GetPubKey(),
 			Power:  10,
 		}}

 		if err := genDoc.SaveAs(genFile); err != nil {
-			panic(err)
+			return err
 		}
 		logger.Info("Generated genesis file", "path", genFile)
 	}
+
+	return nil
 }
--- a/cmd/tendermint/commands/lite.go
+++ b/cmd/tendermint/commands/lite.go
@ -34,14 +34,14 @@ var (
 )

 func init() {
-	LiteCmd.Flags().StringVar(&listenAddr, "laddr", ":8888", "Serve the proxy on the given port")
+	LiteCmd.Flags().StringVar(&listenAddr, "laddr", "tcp://localhost:8888", "Serve the proxy on the given address")
 	LiteCmd.Flags().StringVar(&nodeAddr, "node", "tcp://localhost:46657", "Connect to a Tendermint node at this address")
 	LiteCmd.Flags().StringVar(&chainID, "chain-id", "tendermint", "Specify the Tendermint chain ID")
 	LiteCmd.Flags().StringVar(&home, "home-dir", ".tendermint-lite", "Specify the home directory")
 }

 func ensureAddrHasSchemeOrDefaultToTCP(addr string) (string, error) {
-	u, err := url.Parse(nodeAddr)
+	u, err := url.Parse(addr)
 	if err != nil {
 		return "", err
 	}
--- a/cmd/tendermint/commands/probe_upnp.go
+++ b/cmd/tendermint/commands/probe_upnp.go
@ -1,7 +1,6 @@
 package commands

 import (
-	"encoding/json"
 	"fmt"

 	"github.com/spf13/cobra"
@ -22,7 +21,7 @@ func probeUpnp(cmd *cobra.Command, args []string) error {
 		fmt.Println("Probe failed: ", err)
 	} else {
 		fmt.Println("Probe success!")
-		jsonBytes, err := json.Marshal(capabilities)
+		jsonBytes, err := cdc.MarshalJSON(capabilities)
 		if err != nil {
 			return err
 		}
--- a/cmd/tendermint/commands/reset_priv_validator.go
+++ b/cmd/tendermint/commands/reset_priv_validator.go
@ -5,7 +5,7 @@ import (

 	"github.com/spf13/cobra"

-	"github.com/tendermint/tendermint/types"
+	pvm "github.com/tendermint/tendermint/types/priv_validator"
 	"github.com/tendermint/tmlibs/log"
 )

@ -27,7 +27,7 @@ var ResetPrivValidatorCmd = &cobra.Command{
 // ResetAll removes the privValidator files.
 // Exported so other CLI tools can use it.
 func ResetAll(dbDir, privValFile string, logger log.Logger) {
-	resetPrivValidatorFS(privValFile, logger)
+	resetFilePV(privValFile, logger)
 	if err := os.RemoveAll(dbDir); err != nil {
 		logger.Error("Error removing directory", "err", err)
 		return
@ -44,18 +44,18 @@ func resetAll(cmd *cobra.Command, args []string) {
 // XXX: this is totally unsafe.
 // it's only suitable for testnets.
 func resetPrivValidator(cmd *cobra.Command, args []string) {
-	resetPrivValidatorFS(config.PrivValidatorFile(), logger)
+	resetFilePV(config.PrivValidatorFile(), logger)
 }

-func resetPrivValidatorFS(privValFile string, logger log.Logger) {
+func resetFilePV(privValFile string, logger log.Logger) {
 	// Get PrivValidator
 	if _, err := os.Stat(privValFile); err == nil {
-		privValidator := types.LoadPrivValidatorFS(privValFile)
-		privValidator.Reset()
+		pv := pvm.LoadFilePV(privValFile)
+		pv.Reset()
 		logger.Info("Reset PrivValidator", "file", privValFile)
 	} else {
-		privValidator := types.GenPrivValidatorFS(privValFile)
-		privValidator.Save()
+		pv := pvm.GenFilePV(privValFile)
+		pv.Save()
 		logger.Info("Generated PrivValidator", "file", privValFile)
 	}
 }
--- a/cmd/tendermint/commands/run_node.go
+++ b/cmd/tendermint/commands/run_node.go
@ -57,9 +57,8 @@ func NewRunNodeCmd(nodeProvider nm.NodeProvider) *cobra.Command {

 			if err := n.Start(); err != nil {
 				return fmt.Errorf("Failed to start node: %v", err)
-			} else {
-				logger.Info("Started node", "nodeInfo", n.Switch().NodeInfo())
 			}
+			logger.Info("Started node", "nodeInfo", n.Switch().NodeInfo())

 			// Trap signal, run forever.
 			n.RunForever()
--- a/cmd/tendermint/commands/show_node_id.go
+++ b/cmd/tendermint/commands/show_node_id.go
@ -6,6 +6,7 @@ import (
 	"github.com/spf13/cobra"

 	"github.com/tendermint/tendermint/p2p"
+
 )

 // ShowNodeIDCmd dumps node's ID to the standard output.
@ -16,10 +17,12 @@ var ShowNodeIDCmd = &cobra.Command{
 }

 func showNodeID(cmd *cobra.Command, args []string) error {
-	nodeKey, err := p2p.LoadOrGenNodeKey(config.NodeKeyFile())
+
+	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,11 +2,9 @@ package commands

 import (
 	"fmt"
-
 	"github.com/spf13/cobra"

-	"github.com/tendermint/go-wire/data"
-	"github.com/tendermint/tendermint/types"
+	privval "github.com/tendermint/tendermint/types/priv_validator"
 )

 // ShowValidatorCmd adds capabilities for showing the validator info.
@ -17,7 +15,7 @@ var ShowValidatorCmd = &cobra.Command{
 }

 func showValidator(cmd *cobra.Command, args []string) {
-	privValidator := types.LoadOrGenPrivValidatorFS(config.PrivValidatorFile())
-	pubKeyJSONBytes, _ := data.ToJSON(privValidator.PubKey)
+	privValidator := privval.LoadOrGenFilePV(config.PrivValidatorFile())
+	pubKeyJSONBytes, _ := cdc.MarshalJSON(privValidator.GetPubKey())
 	fmt.Println(string(pubKeyJSONBytes))
 }
--- a/cmd/tendermint/commands/testnet.go
+++ b/cmd/tendermint/commands/testnet.go
@ -2,59 +2,114 @@ package commands

 import (
 	"fmt"
+	"net"
+	"os"
 	"path/filepath"
+	"strings"
 	"time"

 	"github.com/spf13/cobra"

 	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/types"
+	pvm "github.com/tendermint/tendermint/types/priv_validator"
 	cmn "github.com/tendermint/tmlibs/common"
 )

-//flags
 var (
-	nValidators int
-	dataDir     string
+	nValidators    int
+	nNonValidators int
+	outputDir      string
+	nodeDirPrefix  string
+
+	populatePersistentPeers bool
+	hostnamePrefix          string
+	startingIPAddress       string
+	p2pPort                 int
+)
+
+const (
+	nodeDirPerm = 0755
 )

 func init() {
-	TestnetFilesCmd.Flags().IntVar(&nValidators, "n", 4,
+	TestnetFilesCmd.Flags().IntVar(&nValidators, "v", 4,
 		"Number of validators to initialize the testnet with")
-	TestnetFilesCmd.Flags().StringVar(&dataDir, "dir", "mytestnet",
+	TestnetFilesCmd.Flags().IntVar(&nNonValidators, "n", 0,
+		"Number of non-validators to initialize the testnet with")
+	TestnetFilesCmd.Flags().StringVar(&outputDir, "o", "./mytestnet",
 		"Directory to store initialization data for the testnet")
+	TestnetFilesCmd.Flags().StringVar(&nodeDirPrefix, "node-dir-prefix", "node",
+		"Prefix the directory name for each node with (node results in node0, node1, ...)")
+
+	TestnetFilesCmd.Flags().BoolVar(&populatePersistentPeers, "populate-persistent-peers", true,
+		"Update config of each node with the list of persistent peers build using either hostname-prefix or starting-ip-address")
+	TestnetFilesCmd.Flags().StringVar(&hostnamePrefix, "hostname-prefix", "node",
+		"Hostname prefix (node results in persistent peers list ID0@node0:46656, ID1@node1:46656, ...)")
+	TestnetFilesCmd.Flags().StringVar(&startingIPAddress, "starting-ip-address", "",
+		"Starting IP address (192.168.0.1 results in persistent peers list ID0@192.168.0.1:46656, ID1@192.168.0.2:46656, ...)")
+	TestnetFilesCmd.Flags().IntVar(&p2pPort, "p2p-port", 46656,
+		"P2P Port")
 }

-// TestnetFilesCmd allows initialisation of files for a
-// Tendermint testnet.
+// TestnetFilesCmd allows initialisation of files for a Tendermint testnet.
 var TestnetFilesCmd = &cobra.Command{
 	Use:   "testnet",
 	Short: "Initialize files for a Tendermint testnet",
-	Run:   testnetFiles,
+	Long: `testnet will create "v" + "n" number of directories and populate each with
+necessary files (private validator, genesis, config, etc.).
+
+Note, strict routability for addresses is turned off in the config file.
+
+Optionally, it will fill in persistent_peers list in config file using either hostnames or IPs.
+
+Example:
+
+	tendermint testnet --v 4 --o ./output --populate-persistent-peers --starting-ip-address 192.168.10.2
+	`,
+	RunE: testnetFiles,
 }

-func testnetFiles(cmd *cobra.Command, args []string) {
-
+func testnetFiles(cmd *cobra.Command, args []string) error {
+	config := cfg.DefaultConfig()
 	genVals := make([]types.GenesisValidator, nValidators)
-	defaultConfig := cfg.DefaultBaseConfig()

-	// Initialize core dir and priv_validator.json's
 	for i := 0; i < nValidators; i++ {
-		mach := cmn.Fmt("mach%d", i)
-		err := initMachCoreDirectory(dataDir, mach)
+		nodeDirName := cmn.Fmt("%s%d", nodeDirPrefix, i)
+		nodeDir := filepath.Join(outputDir, nodeDirName)
+		config.SetRoot(nodeDir)
+
+		err := os.MkdirAll(filepath.Join(nodeDir, "config"), nodeDirPerm)
 		if err != nil {
-			cmn.Exit(err.Error())
+			_ = os.RemoveAll(outputDir)
+			return err
 		}
-		// Read priv_validator.json to populate vals
-		privValFile := filepath.Join(dataDir, mach, defaultConfig.PrivValidator)
-		privVal := types.LoadPrivValidatorFS(privValFile)
+
+		initFilesWithConfig(config)
+
+		pvFile := filepath.Join(nodeDir, config.BaseConfig.PrivValidator)
+		pv := pvm.LoadFilePV(pvFile)
 		genVals[i] = types.GenesisValidator{
-			PubKey: privVal.GetPubKey(),
+			PubKey: pv.GetPubKey(),
 			Power:  1,
-			Name:   mach,
+			Name:   nodeDirName,
 		}
 	}

+	for i := 0; i < nNonValidators; i++ {
+		nodeDir := filepath.Join(outputDir, cmn.Fmt("%s%d", nodeDirPrefix, i+nValidators))
+		config.SetRoot(nodeDir)
+
+		err := os.MkdirAll(filepath.Join(nodeDir, "config"), nodeDirPerm)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+
+		initFilesWithConfig(config)
+	}
+
 	// Generate genesis doc from generated validators
 	genDoc := &types.GenesisDoc{
 		GenesisTime: time.Now(),
@ -63,36 +118,66 @@ func testnetFiles(cmd *cobra.Command, args []string) {
 	}

 	// Write genesis file.
-	for i := 0; i < nValidators; i++ {
-		mach := cmn.Fmt("mach%d", i)
-		if err := genDoc.SaveAs(filepath.Join(dataDir, mach, defaultConfig.Genesis)); err != nil {
-			panic(err)
+	for i := 0; i < nValidators+nNonValidators; i++ {
+		nodeDir := filepath.Join(outputDir, cmn.Fmt("%s%d", nodeDirPrefix, i))
+		if err := genDoc.SaveAs(filepath.Join(nodeDir, config.BaseConfig.Genesis)); err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
 		}
 	}

-	fmt.Println(cmn.Fmt("Successfully initialized %v node directories", nValidators))
-}
-
-// Initialize per-machine core directory
-func initMachCoreDirectory(base, mach string) error {
-	// Create priv_validator.json file if not present
-	defaultConfig := cfg.DefaultBaseConfig()
-	dir := filepath.Join(base, mach)
-	privValPath := filepath.Join(dir, defaultConfig.PrivValidator)
-	dir = filepath.Dir(privValPath)
-	err := cmn.EnsureDir(dir, 0700)
-	if err != nil {
-		return err
+	if populatePersistentPeers {
+		err := populatePersistentPeersInConfigAndWriteIt(config)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
 	}
-	ensurePrivValidator(privValPath)
+
+	fmt.Printf("Successfully initialized %v node directories\n", nValidators+nNonValidators)
 	return nil
-
 }

-func ensurePrivValidator(file string) {
-	if cmn.FileExists(file) {
-		return
+func hostnameOrIP(i int) string {
+	if startingIPAddress != "" {
+		ip := net.ParseIP(startingIPAddress)
+		ip = ip.To4()
+		if ip == nil {
+			fmt.Printf("%v: non ipv4 address\n", startingIPAddress)
+			os.Exit(1)
+		}
+
+		for j := 0; j < i; j++ {
+			ip[3]++
+		}
+		return ip.String()
 	}
-	privValidator := types.GenPrivValidatorFS(file)
-	privValidator.Save()
+
+	return fmt.Sprintf("%s%d", hostnamePrefix, i)
+}
+
+func populatePersistentPeersInConfigAndWriteIt(config *cfg.Config) error {
+	persistentPeers := make([]string, nValidators+nNonValidators)
+	for i := 0; i < nValidators+nNonValidators; i++ {
+		nodeDir := filepath.Join(outputDir, cmn.Fmt("%s%d", nodeDirPrefix, i))
+		config.SetRoot(nodeDir)
+		nodeKey, err := p2p.LoadNodeKey(config.NodeKeyFile())
+		if err != nil {
+			return err
+		}
+		persistentPeers[i] = p2p.IDAddressString(nodeKey.ID(), fmt.Sprintf("%s:%d", hostnameOrIP(i), p2pPort))
+	}
+	persistentPeersList := strings.Join(persistentPeers, ",")
+
+	for i := 0; i < nValidators+nNonValidators; i++ {
+		nodeDir := filepath.Join(outputDir, cmn.Fmt("%s%d", nodeDirPrefix, i))
+		config.SetRoot(nodeDir)
+		config.P2P.PersistentPeers = persistentPeersList
+		config.P2P.AddrBookStrict = false
+
+		// overwrite default config
+		cfg.WriteConfigFile(filepath.Join(nodeDir, "config", "config.toml"), config)
+	}
+
+	return nil
 }
--- a/cmd/tendermint/commands/wire.go
+++ b/cmd/tendermint/commands/wire.go
@ -0,0 +1,12 @@
+package commands
+
+import (
+	"github.com/tendermint/go-amino"
+	"github.com/tendermint/go-crypto"
+)
+
+var cdc = amino.NewCodec()
+
+func init() {
+	crypto.RegisterAmino(cdc)
+}
--- a/cmd/tendermint/main.go
+++ b/cmd/tendermint/main.go
@ -25,6 +25,7 @@ func main() {
 		cmd.ShowValidatorCmd,
 		cmd.TestnetFilesCmd,
 		cmd.ShowNodeIDCmd,
+		cmd.GenNodeKeyCmd,
 		cmd.VersionCmd)

 	// NOTE:
--- a/codecov.yml
+++ b/codecov.yml
@ -16,3 +16,8 @@ comment:
  require_changes: no
  require_base: no
  require_head: yes
+
+ignore:
+  - "docs"
+  - "DOCKER"
+  - "scripts"
--- a/config/config.go
+++ b/config/config.go
@ -137,10 +137,6 @@ type BaseConfig struct {
 	DBPath string `mapstructure:"db_dir"`
 }

-func (c BaseConfig) ChainID() string {
-	return c.chainID
-}
-
 // DefaultBaseConfig returns a default base configuration for a Tendermint node
 func DefaultBaseConfig() BaseConfig {
 	return BaseConfig{
@ -161,32 +157,36 @@ func DefaultBaseConfig() BaseConfig {

 // TestBaseConfig returns a base configuration for testing a Tendermint node
 func TestBaseConfig() BaseConfig {
-	conf := DefaultBaseConfig()
-	conf.chainID = "tendermint_test"
-	conf.ProxyApp = "kvstore"
-	conf.FastSync = false
-	conf.DBBackend = "memdb"
-	return conf
+	cfg := DefaultBaseConfig()
+	cfg.chainID = "tendermint_test"
+	cfg.ProxyApp = "kvstore"
+	cfg.FastSync = false
+	cfg.DBBackend = "memdb"
+	return cfg
+}
+
+func (cfg BaseConfig) ChainID() string {
+	return cfg.chainID
 }

 // GenesisFile returns the full path to the genesis.json file
-func (b BaseConfig) GenesisFile() string {
-	return rootify(b.Genesis, b.RootDir)
+func (cfg BaseConfig) GenesisFile() string {
+	return rootify(cfg.Genesis, cfg.RootDir)
 }

 // PrivValidatorFile returns the full path to the priv_validator.json file
-func (b BaseConfig) PrivValidatorFile() string {
-	return rootify(b.PrivValidator, b.RootDir)
+func (cfg BaseConfig) PrivValidatorFile() string {
+	return rootify(cfg.PrivValidator, cfg.RootDir)
 }

 // NodeKeyFile returns the full path to the node_key.json file
-func (b BaseConfig) NodeKeyFile() string {
-	return rootify(b.NodeKey, b.RootDir)
+func (cfg BaseConfig) NodeKeyFile() string {
+	return rootify(cfg.NodeKey, cfg.RootDir)
 }

 // DBDir returns the full path to the database directory
-func (b BaseConfig) DBDir() string {
-	return rootify(b.DBPath, b.RootDir)
+func (cfg BaseConfig) DBDir() string {
+	return rootify(cfg.DBPath, cfg.RootDir)
 }

 // DefaultLogLevel returns a default log level of "error"
@ -229,11 +229,11 @@ func DefaultRPCConfig() *RPCConfig {

 // TestRPCConfig returns a configuration for testing the RPC server
 func TestRPCConfig() *RPCConfig {
-	conf := DefaultRPCConfig()
-	conf.ListenAddress = "tcp://0.0.0.0:36657"
-	conf.GRPCListenAddress = "tcp://0.0.0.0:36658"
-	conf.Unsafe = true
-	return conf
+	cfg := DefaultRPCConfig()
+	cfg.ListenAddress = "tcp://0.0.0.0:36657"
+	cfg.GRPCListenAddress = "tcp://0.0.0.0:36658"
+	cfg.Unsafe = true
+	return cfg
 }

 //-----------------------------------------------------------------------------
@ -270,7 +270,7 @@ type P2PConfig struct {
 	FlushThrottleTimeout int `mapstructure:"flush_throttle_timeout"`

 	// Maximum size of a message packet payload, in bytes
-	MaxMsgPacketPayloadSize int `mapstructure:"max_msg_packet_payload_size"`
+	MaxPacketMsgPayloadSize int `mapstructure:"max_packet_msg_payload_size"`

 	// Rate at which packets can be sent, in bytes/second
 	SendRate int64 `mapstructure:"send_rate"`
@ -302,7 +302,7 @@ func DefaultP2PConfig() *P2PConfig {
 		AddrBookStrict:          true,
 		MaxNumPeers:             50,
 		FlushThrottleTimeout:    100,
-		MaxMsgPacketPayloadSize: 1024,   // 1 kB
+		MaxPacketMsgPayloadSize: 1024,   // 1 kB
 		SendRate:                512000, // 500 kB/s
 		RecvRate:                512000, // 500 kB/s
 		PexReactor:              true,
@ -313,16 +313,16 @@ func DefaultP2PConfig() *P2PConfig {

 // TestP2PConfig returns a configuration for testing the peer-to-peer layer
 func TestP2PConfig() *P2PConfig {
-	conf := DefaultP2PConfig()
-	conf.ListenAddress = "tcp://0.0.0.0:36656"
-	conf.SkipUPNP = true
-	conf.FlushThrottleTimeout = 10
-	return conf
+	cfg := DefaultP2PConfig()
+	cfg.ListenAddress = "tcp://0.0.0.0:36656"
+	cfg.SkipUPNP = true
+	cfg.FlushThrottleTimeout = 10
+	return cfg
 }

 // AddrBookFile returns the full path to the address book
-func (p *P2PConfig) AddrBookFile() string {
-	return rootify(p.AddrBook, p.RootDir)
+func (cfg *P2PConfig) AddrBookFile() string {
+	return rootify(cfg.AddrBook, cfg.RootDir)
 }

 //-----------------------------------------------------------------------------
@ -351,14 +351,14 @@ func DefaultMempoolConfig() *MempoolConfig {

 // TestMempoolConfig returns a configuration for testing the Tendermint mempool
 func TestMempoolConfig() *MempoolConfig {
-	config := DefaultMempoolConfig()
-	config.CacheSize = 1000
-	return config
+	cfg := DefaultMempoolConfig()
+	cfg.CacheSize = 1000
+	return cfg
 }

 // WalDir returns the full path to the mempool's write-ahead log
-func (m *MempoolConfig) WalDir() string {
-	return rootify(m.WalPath, m.RootDir)
+func (cfg *MempoolConfig) WalDir() string {
+	return rootify(cfg.WalPath, cfg.RootDir)
 }

 //-----------------------------------------------------------------------------
@ -367,10 +367,9 @@ func (m *MempoolConfig) WalDir() string {
 // ConsensusConfig defines the confuguration for the Tendermint consensus service,
 // including timeouts and details about the WAL and the block structure.
 type ConsensusConfig struct {
-	RootDir  string `mapstructure:"home"`
-	WalPath  string `mapstructure:"wal_file"`
-	WalLight bool   `mapstructure:"wal_light"`
-	walFile  string // overrides WalPath if set
+	RootDir string `mapstructure:"home"`
+	WalPath string `mapstructure:"wal_file"`
+	walFile string // overrides WalPath if set

 	// All timeouts are in milliseconds
 	TimeoutPropose        int `mapstructure:"timeout_propose"`
@ -397,6 +396,43 @@ type ConsensusConfig struct {
 	PeerQueryMaj23SleepDuration int `mapstructure:"peer_query_maj23_sleep_duration"`
 }

+// DefaultConsensusConfig returns a default configuration for the consensus service
+func DefaultConsensusConfig() *ConsensusConfig {
+	return &ConsensusConfig{
+		WalPath:                     filepath.Join(defaultDataDir, "cs.wal", "wal"),
+		TimeoutPropose:              3000,
+		TimeoutProposeDelta:         500,
+		TimeoutPrevote:              1000,
+		TimeoutPrevoteDelta:         500,
+		TimeoutPrecommit:            1000,
+		TimeoutPrecommitDelta:       500,
+		TimeoutCommit:               1000,
+		SkipTimeoutCommit:           false,
+		MaxBlockSizeTxs:             10000,
+		MaxBlockSizeBytes:           1, // TODO
+		CreateEmptyBlocks:           true,
+		CreateEmptyBlocksInterval:   0,
+		PeerGossipSleepDuration:     100,
+		PeerQueryMaj23SleepDuration: 2000,
+	}
+}
+
+// TestConsensusConfig returns a configuration for testing the consensus service
+func TestConsensusConfig() *ConsensusConfig {
+	cfg := DefaultConsensusConfig()
+	cfg.TimeoutPropose = 100
+	cfg.TimeoutProposeDelta = 1
+	cfg.TimeoutPrevote = 10
+	cfg.TimeoutPrevoteDelta = 1
+	cfg.TimeoutPrecommit = 10
+	cfg.TimeoutPrecommitDelta = 1
+	cfg.TimeoutCommit = 10
+	cfg.SkipTimeoutCommit = true
+	cfg.PeerGossipSleepDuration = 5
+	cfg.PeerQueryMaj23SleepDuration = 250
+	return cfg
+}
+
 // WaitForTxs returns true if the consensus should wait for transactions before entering the propose step
 func (cfg *ConsensusConfig) WaitForTxs() bool {
 	return !cfg.CreateEmptyBlocks || cfg.CreateEmptyBlocksInterval > 0
@ -437,55 +473,17 @@ func (cfg *ConsensusConfig) PeerQueryMaj23Sleep() time.Duration {
 	return time.Duration(cfg.PeerQueryMaj23SleepDuration) * time.Millisecond
 }

-// DefaultConsensusConfig returns a default configuration for the consensus service
-func DefaultConsensusConfig() *ConsensusConfig {
-	return &ConsensusConfig{
-		WalPath:                     filepath.Join(defaultDataDir, "cs.wal", "wal"),
-		WalLight:                    false,
-		TimeoutPropose:              3000,
-		TimeoutProposeDelta:         500,
-		TimeoutPrevote:              1000,
-		TimeoutPrevoteDelta:         500,
-		TimeoutPrecommit:            1000,
-		TimeoutPrecommitDelta:       500,
-		TimeoutCommit:               1000,
-		SkipTimeoutCommit:           false,
-		MaxBlockSizeTxs:             10000,
-		MaxBlockSizeBytes:           1, // TODO
-		CreateEmptyBlocks:           true,
-		CreateEmptyBlocksInterval:   0,
-		PeerGossipSleepDuration:     100,
-		PeerQueryMaj23SleepDuration: 2000,
-	}
-}
-
-// TestConsensusConfig returns a configuration for testing the consensus service
-func TestConsensusConfig() *ConsensusConfig {
-	config := DefaultConsensusConfig()
-	config.TimeoutPropose = 100
-	config.TimeoutProposeDelta = 1
-	config.TimeoutPrevote = 10
-	config.TimeoutPrevoteDelta = 1
-	config.TimeoutPrecommit = 10
-	config.TimeoutPrecommitDelta = 1
-	config.TimeoutCommit = 10
-	config.SkipTimeoutCommit = true
-	config.PeerGossipSleepDuration = 5
-	config.PeerQueryMaj23SleepDuration = 250
-	return config
-}
-
 // WalFile returns the full path to the write-ahead log file
-func (c *ConsensusConfig) WalFile() string {
-	if c.walFile != "" {
-		return c.walFile
+func (cfg *ConsensusConfig) WalFile() string {
+	if cfg.walFile != "" {
+		return cfg.walFile
 	}
-	return rootify(c.WalPath, c.RootDir)
+	return rootify(cfg.WalPath, cfg.RootDir)
 }

 // SetWalFile sets the path to the write-ahead log file
-func (c *ConsensusConfig) SetWalFile(walFile string) {
-	c.walFile = walFile
+func (cfg *ConsensusConfig) SetWalFile(walFile string) {
+	cfg.walFile = walFile
 }

 //-----------------------------------------------------------------------------
--- a/config/toml.go
+++ b/config/toml.go
@ -37,16 +37,21 @@ func EnsureRoot(rootDir string) {

 	// Write default config file if missing.
 	if !cmn.FileExists(configFilePath) {
-		writeConfigFile(configFilePath)
+		writeDefaultConfigFile(configFilePath)
 	}
 }

 // XXX: this func should probably be called by cmd/tendermint/commands/init.go
 // alongside the writing of the genesis.json and priv_validator.json
-func writeConfigFile(configFilePath string) {
+func writeDefaultConfigFile(configFilePath string) {
+	WriteConfigFile(configFilePath, DefaultConfig())
+}
+
+// WriteConfigFile renders config using the template and writes it to configFilePath.
+func WriteConfigFile(configFilePath string, config *Config) {
 	var buffer bytes.Buffer

-	if err := configTemplate.Execute(&buffer, DefaultConfig()); err != nil {
+	if err := configTemplate.Execute(&buffer, config); err != nil {
 		panic(err)
 	}

@ -124,11 +129,11 @@ unsafe = {{ .RPC.Unsafe }}
 laddr = "{{ .P2P.ListenAddress }}"

 # Comma separated list of seed nodes to connect to
-seeds = ""
+seeds = "{{ .P2P.Seeds }}"

 # Comma separated list of nodes to keep persistent connections to
 # Do not add private peers to this list if you don't want them advertised
-persistent_peers = ""
+persistent_peers = "{{ .P2P.PersistentPeers }}"

 # Path to address book
 addr_book_file = "{{ .P2P.AddrBook }}"
@ -143,7 +148,7 @@ flush_throttle_timeout = {{ .P2P.FlushThrottleTimeout }}
 max_num_peers = {{ .P2P.MaxNumPeers }}

 # Maximum size of a message packet payload, in bytes
-max_msg_packet_payload_size = {{ .P2P.MaxMsgPacketPayloadSize }}
+max_packet_msg_payload_size = {{ .P2P.MaxPacketMsgPayloadSize }}

 # Rate at which packets can be sent, in bytes/second
 send_rate = {{ .P2P.SendRate }}
@ -178,7 +183,6 @@ wal_dir = "{{ .Mempool.WalPath }}"
 [consensus]

 wal_file = "{{ .Consensus.WalPath }}"
-wal_light = {{ .Consensus.WalLight }}

 # All timeouts are in milliseconds
 timeout_propose = {{ .Consensus.TimeoutPropose }}
@ -262,7 +266,7 @@ func ResetTestRoot(testName string) *Config {

 	// Write default config file if missing.
 	if !cmn.FileExists(configFilePath) {
-		writeConfigFile(configFilePath)
+		writeDefaultConfigFile(configFilePath)
 	}
 	if !cmn.FileExists(genesisFilePath) {
 		cmn.MustWriteFile(genesisFilePath, []byte(testGenesis), 0644)
@ -280,8 +284,8 @@ var testGenesis = `{
  "validators": [
    {
      "pub_key": {
-        "type": "ed25519",
-        "data":"3B3069C422E19688B45CBFAE7BB009FC0FA1B1EA86593519318B7214853803C8"
+        "type": "AC26791624DE60",
+        "value":"AT/+aaL1eB0477Mud9JMm8Sh8BIvOYlPGC9KkIUmFaE="
      },
      "power": 10,
      "name": ""
@ -291,14 +295,14 @@ var testGenesis = `{
 }`

 var testPrivValidator = `{
-  "address": "D028C9981F7A87F3093672BF0D5B0E2A1B3ED456",
+  "address": "849CB2C877F87A20925F35D00AE6688342D25B47",
  "pub_key": {
-    "type": "ed25519",
-    "data": "3B3069C422E19688B45CBFAE7BB009FC0FA1B1EA86593519318B7214853803C8"
+    "type": "AC26791624DE60",
+    "value": "AT/+aaL1eB0477Mud9JMm8Sh8BIvOYlPGC9KkIUmFaE="
  },
  "priv_key": {
-    "type": "ed25519",
-    "data": "27F82582AEFAE7AB151CFB01C48BB6C1A0DA78F9BDDA979A9F70A84D074EB07D3B3069C422E19688B45CBFAE7BB009FC0FA1B1EA86593519318B7214853803C8"
+    "type": "954568A3288910",
+    "value": "EVkqJO/jIXp3rkASXfh9YnyToYXRXhBr6g9cQVxPFnQBP/5povV4HTjvsy530kybxKHwEi85iU8YL0qQhSYVoQ=="
  },
  "last_height": 0,
  "last_round": 0,
--- a/consensus/byzantine_test.go
+++ b/consensus/byzantine_test.go
@ -7,7 +7,6 @@ import (
 	"time"

 	"github.com/stretchr/testify/require"
-	crypto "github.com/tendermint/go-crypto"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/types"
 	cmn "github.com/tendermint/tmlibs/common"
@ -48,7 +47,9 @@ func TestByzantine(t *testing.T) {
 	for i := 0; i < N; i++ {
 		// make first val byzantine
 		if i == 0 {
-			css[i].privValidator = NewByzantinePrivValidator(css[i].privValidator)
+			// NOTE: Now, test validators are MockPV, which by default doesn't
+			// do any safety checks.
+			css[i].privValidator.(*types.MockPV).DisableChecks()
 			css[i].decideProposal = func(j int) func(int64, int) {
 				return func(height int64, round int) {
 					byzantineDecideProposalFunc(t, height, round, css[j], switches[j])
@ -203,7 +204,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int, cs *Cons
 func sendProposalAndParts(height int64, round int, cs *ConsensusState, peer p2p.Peer, proposal *types.Proposal, blockHash []byte, parts *types.PartSet) {
 	// proposal
 	msg := &ProposalMessage{Proposal: proposal}
-	peer.Send(DataChannel, struct{ ConsensusMessage }{msg})
+	peer.Send(DataChannel, cdc.MustMarshalBinaryBare(msg))

 	// parts
 	for i := 0; i < parts.Total(); i++ {
@ -213,7 +214,7 @@ func sendProposalAndParts(height int64, round int, cs *ConsensusState, peer p2p.
 			Round:  round,  // This tells peer that this part applies to us.
 			Part:   part,
 		}
-		peer.Send(DataChannel, struct{ ConsensusMessage }{msg})
+		peer.Send(DataChannel, cdc.MustMarshalBinaryBare(msg))
 	}

 	// votes
@ -222,8 +223,8 @@ func sendProposalAndParts(height int64, round int, cs *ConsensusState, peer p2p.
 	precommit, _ := cs.signVote(types.VoteTypePrecommit, blockHash, parts.Header())
 	cs.mtx.Unlock()

-	peer.Send(VoteChannel, struct{ ConsensusMessage }{&VoteMessage{prevote}})
-	peer.Send(VoteChannel, struct{ ConsensusMessage }{&VoteMessage{precommit}})
+	peer.Send(VoteChannel, cdc.MustMarshalBinaryBare(&VoteMessage{prevote}))
+	peer.Send(VoteChannel, cdc.MustMarshalBinaryBare(&VoteMessage{precommit}))
 }

 //----------------------------------------
@ -264,47 +265,3 @@ func (br *ByzantineReactor) RemovePeer(peer p2p.Peer, reason interface{}) {
 func (br *ByzantineReactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
 	br.reactor.Receive(chID, peer, msgBytes)
 }
-
-//----------------------------------------
-// byzantine privValidator
-
-type ByzantinePrivValidator struct {
-	types.Signer
-
-	pv types.PrivValidator
-}
-
-// Return a priv validator that will sign anything
-func NewByzantinePrivValidator(pv types.PrivValidator) *ByzantinePrivValidator {
-	return &ByzantinePrivValidator{
-		Signer: pv.(*types.PrivValidatorFS).Signer,
-		pv:     pv,
-	}
-}
-
-func (privVal *ByzantinePrivValidator) GetAddress() types.Address {
-	return privVal.pv.GetAddress()
-}
-
-func (privVal *ByzantinePrivValidator) GetPubKey() crypto.PubKey {
-	return privVal.pv.GetPubKey()
-}
-
-func (privVal *ByzantinePrivValidator) SignVote(chainID string, vote *types.Vote) (err error) {
-	vote.Signature, err = privVal.Sign(vote.SignBytes(chainID))
-	return err
-}
-
-func (privVal *ByzantinePrivValidator) SignProposal(chainID string, proposal *types.Proposal) (err error) {
-	proposal.Signature, _ = privVal.Sign(proposal.SignBytes(chainID))
-	return nil
-}
-
-func (privVal *ByzantinePrivValidator) SignHeartbeat(chainID string, heartbeat *types.Heartbeat) (err error) {
-	heartbeat.Signature, _ = privVal.Sign(heartbeat.SignBytes(chainID))
-	return nil
-}
-
-func (privVal *ByzantinePrivValidator) String() string {
-	return cmn.Fmt("PrivValidator{%X}", privVal.GetAddress())
-}
--- a/consensus/common_test.go
+++ b/consensus/common_test.go
@ -21,6 +21,7 @@ import (
 	"github.com/tendermint/tendermint/p2p"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
+	pvm "github.com/tendermint/tendermint/types/priv_validator"
 	cmn "github.com/tendermint/tmlibs/common"
 	dbm "github.com/tendermint/tmlibs/db"
 	"github.com/tendermint/tmlibs/log"
@ -101,13 +102,13 @@ func signVotes(voteType byte, hash []byte, header types.PartSetHeader, vss ...*v

 func incrementHeight(vss ...*validatorStub) {
 	for _, vs := range vss {
-		vs.Height += 1
+		vs.Height++
 	}
 }

 func incrementRound(vss ...*validatorStub) {
 	for _, vs := range vss {
-		vs.Round += 1
+		vs.Round++
 	}
 }

@ -222,7 +223,7 @@ func subscribeToVoter(cs *ConsensusState, addr []byte) chan interface{} {
 	voteCh := make(chan interface{})
 	go func() {
 		for v := range voteCh0 {
-			vote := v.(types.TMEventData).Unwrap().(types.EventDataVote)
+			vote := v.(types.EventDataVote)
 			// we only fire for our own votes
 			if bytes.Equal(addr, vote.Vote.ValidatorAddress) {
 				voteCh <- v
@ -277,10 +278,10 @@ func newConsensusStateWithConfigAndBlockStore(thisConfig *cfg.Config, state sm.S
 	return cs
 }

-func loadPrivValidator(config *cfg.Config) *types.PrivValidatorFS {
+func loadPrivValidator(config *cfg.Config) *pvm.FilePV {
 	privValidatorFile := config.PrivValidatorFile()
 	ensureDir(path.Dir(privValidatorFile), 0700)
-	privValidator := types.LoadOrGenPrivValidatorFS(privValidatorFile)
+	privValidator := pvm.LoadOrGenFilePV(privValidatorFile)
 	privValidator.Reset()
 	return privValidator
 }
@ -378,7 +379,7 @@ func randConsensusNetWithPeers(nValidators, nPeers int, testName string, tickerF
 			privVal = privVals[i]
 		} else {
 			_, tempFilePath := cmn.Tempfile("priv_validator_")
-			privVal = types.GenPrivValidatorFS(tempFilePath)
+			privVal = pvm.GenFilePV(tempFilePath)
 		}

 		app := appFunc()
@ -394,7 +395,7 @@ func randConsensusNetWithPeers(nValidators, nPeers int, testName string, tickerF

 func getSwitchIndex(switches []*p2p.Switch, peer p2p.Peer) int {
 	for i, s := range switches {
-		if bytes.Equal(peer.NodeInfo().PubKey.Address(), s.NodeInfo().PubKey.Address()) {
+		if peer.NodeInfo().ID == s.NodeInfo().ID {
 			return i
 		}
 	}
@ -405,9 +406,9 @@ func getSwitchIndex(switches []*p2p.Switch, peer p2p.Peer) int {
 //-------------------------------------------------------------------------------
 // genesis

-func randGenesisDoc(numValidators int, randPower bool, minPower int64) (*types.GenesisDoc, []*types.PrivValidatorFS) {
+func randGenesisDoc(numValidators int, randPower bool, minPower int64) (*types.GenesisDoc, []types.PrivValidator) {
 	validators := make([]types.GenesisValidator, numValidators)
-	privValidators := make([]*types.PrivValidatorFS, numValidators)
+	privValidators := make([]types.PrivValidator, numValidators)
 	for i := 0; i < numValidators; i++ {
 		val, privVal := types.RandValidator(randPower, minPower)
 		validators[i] = types.GenesisValidator{
@ -425,7 +426,7 @@ func randGenesisDoc(numValidators int, randPower bool, minPower int64) (*types.G
 	}, privValidators
 }

-func randGenesisState(numValidators int, randPower bool, minPower int64) (sm.State, []*types.PrivValidatorFS) {
+func randGenesisState(numValidators int, randPower bool, minPower int64) (sm.State, []types.PrivValidator) {
 	genDoc, privValidators := randGenesisDoc(numValidators, randPower, minPower)
 	s0, _ := sm.MakeGenesisState(genDoc)
 	db := dbm.NewMemDB()
--- a/consensus/mempool_test.go
+++ b/consensus/mempool_test.go
@ -108,7 +108,7 @@ func TestMempoolTxConcurrentWithCommit(t *testing.T) {
 		ticker := time.NewTicker(time.Second * 30)
 		select {
 		case b := <-newBlockCh:
-			evt := b.(types.TMEventData).Unwrap().(types.EventDataNewBlock)
+			evt := b.(types.EventDataNewBlock)
 			nTxs += int(evt.Block.Header.NumTxs)
 		case <-ticker.C:
 			panic("Timed out waiting to commit blocks with transactions")
@ -200,7 +200,7 @@ func (app *CounterApplication) DeliverTx(tx []byte) abci.ResponseDeliverTx {
 			Code: code.CodeTypeBadNonce,
 			Log:  fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.txCount, txValue)}
 	}
-	app.txCount += 1
+	app.txCount++
 	return abci.ResponseDeliverTx{Code: code.CodeTypeOK}
 }

@ -211,7 +211,7 @@ func (app *CounterApplication) CheckTx(tx []byte) abci.ResponseCheckTx {
 			Code: code.CodeTypeBadNonce,
 			Log:  fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.mempoolTxCount, txValue)}
 	}
-	app.mempoolTxCount += 1
+	app.mempoolTxCount++
 	return abci.ResponseCheckTx{Code: code.CodeTypeOK}
 }

@ -225,9 +225,8 @@ func (app *CounterApplication) Commit() abci.ResponseCommit {
 	app.mempoolTxCount = app.txCount
 	if app.txCount == 0 {
 		return abci.ResponseCommit{}
-	} else {
-		hash := make([]byte, 8)
-		binary.BigEndian.PutUint64(hash, uint64(app.txCount))
-		return abci.ResponseCommit{Data: hash}
 	}
+	hash := make([]byte, 8)
+	binary.BigEndian.PutUint64(hash, uint64(app.txCount))
+	return abci.ResponseCommit{Data: hash}
 }
--- a/consensus/reactor.go
+++ b/consensus/reactor.go
@ -1,7 +1,6 @@
 package consensus

 import (
-	"bytes"
 	"context"
 	"fmt"
 	"reflect"
@ -10,7 +9,7 @@ import (

 	"github.com/pkg/errors"

-	wire "github.com/tendermint/go-wire"
+	amino "github.com/tendermint/go-amino"
 	cmn "github.com/tendermint/tmlibs/common"
 	"github.com/tendermint/tmlibs/log"

@ -26,7 +25,7 @@ const (
 	VoteChannel        = byte(0x22)
 	VoteSetBitsChannel = byte(0x23)

-	maxConsensusMessageSize = 1048576 // 1MB; NOTE/TODO: keep in sync with types.PartSet sizes.
+	maxMsgSize = 1048576 // 1MB; NOTE/TODO: keep in sync with types.PartSet sizes.

 	blocksToContributeToBecomeGoodPeer = 10000
 )
@ -110,27 +109,31 @@ func (conR *ConsensusReactor) GetChannels() []*p2p.ChannelDescriptor {
 	// TODO optimize
 	return []*p2p.ChannelDescriptor{
 		{
-			ID:                StateChannel,
-			Priority:          5,
-			SendQueueCapacity: 100,
+			ID:                  StateChannel,
+			Priority:            5,
+			SendQueueCapacity:   100,
+			RecvMessageCapacity: maxMsgSize,
 		},
 		{
-			ID:                 DataChannel, // maybe split between gossiping current block and catchup stuff
-			Priority:           10,          // once we gossip the whole block there's nothing left to send until next height or round
-			SendQueueCapacity:  100,
-			RecvBufferCapacity: 50 * 4096,
+			ID:                  DataChannel, // maybe split between gossiping current block and catchup stuff
+			Priority:            10,          // once we gossip the whole block there's nothing left to send until next height or round
+			SendQueueCapacity:   100,
+			RecvBufferCapacity:  50 * 4096,
+			RecvMessageCapacity: maxMsgSize,
 		},
 		{
-			ID:                 VoteChannel,
-			Priority:           5,
-			SendQueueCapacity:  100,
-			RecvBufferCapacity: 100 * 100,
+			ID:                  VoteChannel,
+			Priority:            5,
+			SendQueueCapacity:   100,
+			RecvBufferCapacity:  100 * 100,
+			RecvMessageCapacity: maxMsgSize,
 		},
 		{
-			ID:                 VoteSetBitsChannel,
-			Priority:           1,
-			SendQueueCapacity:  2,
-			RecvBufferCapacity: 1024,
+			ID:                  VoteSetBitsChannel,
+			Priority:            1,
+			SendQueueCapacity:   2,
+			RecvBufferCapacity:  1024,
+			RecvMessageCapacity: maxMsgSize,
 		},
 	}
 }
@ -178,7 +181,7 @@ func (conR *ConsensusReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)
 		return
 	}

-	_, msg, err := DecodeMessage(msgBytes)
+	msg, err := DecodeMessage(msgBytes)
 	if err != nil {
 		conR.Logger.Error("Error decoding message", "src", src, "chId", chID, "msg", msg, "err", err, "bytes", msgBytes)
 		conR.Switch.StopPeerForError(src, err)
@ -224,13 +227,13 @@ func (conR *ConsensusReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte)
 				conR.Logger.Error("Bad VoteSetBitsMessage field Type")
 				return
 			}
-			src.TrySend(VoteSetBitsChannel, struct{ ConsensusMessage }{&VoteSetBitsMessage{
+			src.TrySend(VoteSetBitsChannel, cdc.MustMarshalBinaryBare(&VoteSetBitsMessage{
 				Height:  msg.Height,
 				Round:   msg.Round,
 				Type:    msg.Type,
 				BlockID: msg.BlockID,
 				Votes:   ourVotes,
-			}})
+			}))
 		case *ProposalHeartbeatMessage:
 			hb := msg.Heartbeat
 			conR.Logger.Debug("Received proposal heartbeat message",
@ -371,27 +374,33 @@ func (conR *ConsensusReactor) startBroadcastRoutine() error {
 	}

 	go func() {
+		var data interface{}
+		var ok bool
 		for {
 			select {
-			case data, ok := <-stepsCh:
+			case data, ok = <-stepsCh:
 				if ok { // a receive from a closed channel returns the zero value immediately
-					edrs := data.(types.TMEventData).Unwrap().(types.EventDataRoundState)
+					edrs := data.(types.EventDataRoundState)
 					conR.broadcastNewRoundStep(edrs.RoundState.(*cstypes.RoundState))
 				}
-			case data, ok := <-votesCh:
+			case data, ok = <-votesCh:
 				if ok {
-					edv := data.(types.TMEventData).Unwrap().(types.EventDataVote)
+					edv := data.(types.EventDataVote)
 					conR.broadcastHasVoteMessage(edv.Vote)
 				}
-			case data, ok := <-heartbeatsCh:
+			case data, ok = <-heartbeatsCh:
 				if ok {
-					edph := data.(types.TMEventData).Unwrap().(types.EventDataProposalHeartbeat)
+					edph := data.(types.EventDataProposalHeartbeat)
 					conR.broadcastProposalHeartbeatMessage(edph)
 				}
 			case <-conR.Quit():
 				conR.eventBus.UnsubscribeAll(ctx, subscriber)
 				return
 			}
+			if !ok {
+				conR.eventBus.UnsubscribeAll(ctx, subscriber)
+				return
+			}
 		}
 	}()

@ -403,16 +412,16 @@ func (conR *ConsensusReactor) broadcastProposalHeartbeatMessage(heartbeat types.
 	conR.Logger.Debug("Broadcasting proposal heartbeat message",
 		"height", hb.Height, "round", hb.Round, "sequence", hb.Sequence)
 	msg := &ProposalHeartbeatMessage{hb}
-	conR.Switch.Broadcast(StateChannel, struct{ ConsensusMessage }{msg})
+	conR.Switch.Broadcast(StateChannel, cdc.MustMarshalBinaryBare(msg))
 }

 func (conR *ConsensusReactor) broadcastNewRoundStep(rs *cstypes.RoundState) {
 	nrsMsg, csMsg := makeRoundStepMessages(rs)
 	if nrsMsg != nil {
-		conR.Switch.Broadcast(StateChannel, struct{ ConsensusMessage }{nrsMsg})
+		conR.Switch.Broadcast(StateChannel, cdc.MustMarshalBinaryBare(nrsMsg))
 	}
 	if csMsg != nil {
-		conR.Switch.Broadcast(StateChannel, struct{ ConsensusMessage }{csMsg})
+		conR.Switch.Broadcast(StateChannel, cdc.MustMarshalBinaryBare(csMsg))
 	}
 }

@ -424,7 +433,7 @@ func (conR *ConsensusReactor) broadcastHasVoteMessage(vote *types.Vote) {
 		Type:   vote.Type,
 		Index:  vote.ValidatorIndex,
 	}
-	conR.Switch.Broadcast(StateChannel, struct{ ConsensusMessage }{msg})
+	conR.Switch.Broadcast(StateChannel, cdc.MustMarshalBinaryBare(msg))
 	/*
 		// TODO: Make this broadcast more selective.
 		for _, peer := range conR.Switch.Peers().List() {
@ -464,10 +473,10 @@ func (conR *ConsensusReactor) sendNewRoundStepMessages(peer p2p.Peer) {
 	rs := conR.conS.GetRoundState()
 	nrsMsg, csMsg := makeRoundStepMessages(rs)
 	if nrsMsg != nil {
-		peer.Send(StateChannel, struct{ ConsensusMessage }{nrsMsg})
+		peer.Send(StateChannel, cdc.MustMarshalBinaryBare(nrsMsg))
 	}
 	if csMsg != nil {
-		peer.Send(StateChannel, struct{ ConsensusMessage }{csMsg})
+		peer.Send(StateChannel, cdc.MustMarshalBinaryBare(csMsg))
 	}
 }

@ -494,7 +503,7 @@ OUTER_LOOP:
 					Part:   part,
 				}
 				logger.Debug("Sending block part", "height", prs.Height, "round", prs.Round)
-				if peer.Send(DataChannel, struct{ ConsensusMessage }{msg}) {
+				if peer.Send(DataChannel, cdc.MustMarshalBinaryBare(msg)) {
 					ps.SetHasProposalBlockPart(prs.Height, prs.Round, index)
 				}
 				continue OUTER_LOOP
@ -538,7 +547,7 @@ OUTER_LOOP:
 			{
 				msg := &ProposalMessage{Proposal: rs.Proposal}
 				logger.Debug("Sending proposal", "height", prs.Height, "round", prs.Round)
-				if peer.Send(DataChannel, struct{ ConsensusMessage }{msg}) {
+				if peer.Send(DataChannel, cdc.MustMarshalBinaryBare(msg)) {
 					ps.SetHasProposal(rs.Proposal)
 				}
 			}
@ -553,7 +562,7 @@ OUTER_LOOP:
 					ProposalPOL:      rs.Votes.Prevotes(rs.Proposal.POLRound).BitArray(),
 				}
 				logger.Debug("Sending POL", "height", prs.Height, "round", prs.Round)
-				peer.Send(DataChannel, struct{ ConsensusMessage }{msg})
+				peer.Send(DataChannel, cdc.MustMarshalBinaryBare(msg))
 			}
 			continue OUTER_LOOP
 		}
@ -596,17 +605,15 @@ func (conR *ConsensusReactor) gossipDataForCatchup(logger log.Logger, rs *cstype
 			Part:   part,
 		}
 		logger.Debug("Sending block part for catchup", "round", prs.Round, "index", index)
-		if peer.Send(DataChannel, struct{ ConsensusMessage }{msg}) {
+		if peer.Send(DataChannel, cdc.MustMarshalBinaryBare(msg)) {
 			ps.SetHasProposalBlockPart(prs.Height, prs.Round, index)
 		} else {
 			logger.Debug("Sending block part for catchup failed")
 		}
 		return
-	} else {
-		//logger.Info("No parts to send in catch-up, sleeping")
-		time.Sleep(conR.conS.config.PeerGossipSleep())
-		return
 	}
+	//logger.Info("No parts to send in catch-up, sleeping")
+	time.Sleep(conR.conS.config.PeerGossipSleep())
 }

 func (conR *ConsensusReactor) gossipVotesRoutine(peer p2p.Peer, ps *PeerState) {
@ -735,12 +742,12 @@ OUTER_LOOP:
 			prs := ps.GetRoundState()
 			if rs.Height == prs.Height {
 				if maj23, ok := rs.Votes.Prevotes(prs.Round).TwoThirdsMajority(); ok {
-					peer.TrySend(StateChannel, struct{ ConsensusMessage }{&VoteSetMaj23Message{
+					peer.TrySend(StateChannel, cdc.MustMarshalBinaryBare(&VoteSetMaj23Message{
 						Height:  prs.Height,
 						Round:   prs.Round,
 						Type:    types.VoteTypePrevote,
 						BlockID: maj23,
-					}})
+					}))
 					time.Sleep(conR.conS.config.PeerQueryMaj23Sleep())
 				}
 			}
@ -752,12 +759,12 @@ OUTER_LOOP:
 			prs := ps.GetRoundState()
 			if rs.Height == prs.Height {
 				if maj23, ok := rs.Votes.Precommits(prs.Round).TwoThirdsMajority(); ok {
-					peer.TrySend(StateChannel, struct{ ConsensusMessage }{&VoteSetMaj23Message{
+					peer.TrySend(StateChannel, cdc.MustMarshalBinaryBare(&VoteSetMaj23Message{
 						Height:  prs.Height,
 						Round:   prs.Round,
 						Type:    types.VoteTypePrecommit,
 						BlockID: maj23,
-					}})
+					}))
 					time.Sleep(conR.conS.config.PeerQueryMaj23Sleep())
 				}
 			}
@ -769,12 +776,12 @@ OUTER_LOOP:
 			prs := ps.GetRoundState()
 			if rs.Height == prs.Height && prs.ProposalPOLRound >= 0 {
 				if maj23, ok := rs.Votes.Prevotes(prs.ProposalPOLRound).TwoThirdsMajority(); ok {
-					peer.TrySend(StateChannel, struct{ ConsensusMessage }{&VoteSetMaj23Message{
+					peer.TrySend(StateChannel, cdc.MustMarshalBinaryBare(&VoteSetMaj23Message{
 						Height:  prs.Height,
 						Round:   prs.ProposalPOLRound,
 						Type:    types.VoteTypePrevote,
 						BlockID: maj23,
-					}})
+					}))
 					time.Sleep(conR.conS.config.PeerQueryMaj23Sleep())
 				}
 			}
@ -788,12 +795,12 @@ OUTER_LOOP:
 			prs := ps.GetRoundState()
 			if prs.CatchupCommitRound != -1 && 0 < prs.Height && prs.Height <= conR.conS.blockStore.Height() {
 				commit := conR.conS.LoadCommit(prs.Height)
-				peer.TrySend(StateChannel, struct{ ConsensusMessage }{&VoteSetMaj23Message{
+				peer.TrySend(StateChannel, cdc.MustMarshalBinaryBare(&VoteSetMaj23Message{
 					Height:  prs.Height,
 					Round:   commit.Round(),
 					Type:    types.VoteTypePrecommit,
 					BlockID: commit.BlockID,
-				}})
+				}))
 				time.Sleep(conR.conS.config.PeerQueryMaj23Sleep())
 			}
 		}
@ -831,8 +838,8 @@ var (
 	ErrPeerStateInvalidStartTime = errors.New("Error peer state invalid startTime")
 )

-// PeerState contains the known state of a peer, including its connection
-// and threadsafe access to its PeerRoundState.
+// PeerState contains the known state of a peer, including its connection and
+// threadsafe access to its PeerRoundState.
 type PeerState struct {
 	Peer   p2p.Peer
 	logger log.Logger
@ -871,12 +878,14 @@ func NewPeerState(peer p2p.Peer) *PeerState {
 	}
 }

+// SetLogger allows to set a logger on the peer state. Returns the peer state
+// itself.
 func (ps *PeerState) SetLogger(logger log.Logger) *PeerState {
 	ps.logger = logger
 	return ps
 }

-// GetRoundState returns an atomic snapshot of the PeerRoundState.
+// GetRoundState returns an shallow copy of the PeerRoundState.
 // There's no point in mutating it since it won't change PeerState.
 func (ps *PeerState) GetRoundState() *cstypes.PeerRoundState {
 	ps.mtx.Lock()
@ -886,6 +895,14 @@ func (ps *PeerState) GetRoundState() *cstypes.PeerRoundState {
 	return &prs
 }

+// GetRoundStateJSON returns a json of PeerRoundState, marshalled using go-amino.
+func (ps *PeerState) GetRoundStateJSON() ([]byte, error) {
+	ps.mtx.Lock()
+	defer ps.mtx.Unlock()
+
+	return cdc.MarshalJSON(ps.PeerRoundState)
+}
+
 // GetHeight returns an atomic snapshot of the PeerRoundState's height
 // used by the mempool to ensure peers are caught up before broadcasting new txs
 func (ps *PeerState) GetHeight() int64 {
@ -944,7 +961,7 @@ func (ps *PeerState) PickSendVote(votes types.VoteSetReader) bool {
 	if vote, ok := ps.PickVoteToSend(votes); ok {
 		msg := &VoteMessage{vote}
 		ps.logger.Debug("Sending vote message", "ps", ps, "vote", vote)
-		return ps.Peer.Send(VoteChannel, struct{ ConsensusMessage }{msg})
+		return ps.Peer.Send(VoteChannel, cdc.MustMarshalBinaryBare(msg))
 	}
 	return false
 }
@ -1048,7 +1065,7 @@ func (ps *PeerState) ensureCatchupCommitRound(height int64, round int, numValida
 	}
 }

-// EnsureVoteVitArrays ensures the bit-arrays have been allocated for tracking
+// EnsureVoteBitArrays ensures the bit-arrays have been allocated for tracking
 // what votes this peer has received.
 // NOTE: It's important to make sure that numValidators actually matches
 // what the node sees as the number of validators for height.
@ -1083,36 +1100,49 @@ func (ps *PeerState) ensureVoteBitArrays(height int64, numValidators int) {
 // It returns the total number of votes (1 per block). This essentially means
 // the number of blocks for which peer has been sending us votes.
 func (ps *PeerState) RecordVote(vote *types.Vote) int {
+	ps.mtx.Lock()
+	defer ps.mtx.Unlock()
+
 	if ps.stats.lastVoteHeight >= vote.Height {
 		return ps.stats.votes
 	}
 	ps.stats.lastVoteHeight = vote.Height
-	ps.stats.votes += 1
+	ps.stats.votes++
 	return ps.stats.votes
 }

 // VotesSent returns the number of blocks for which peer has been sending us
 // votes.
 func (ps *PeerState) VotesSent() int {
+	ps.mtx.Lock()
+	defer ps.mtx.Unlock()
+
 	return ps.stats.votes
 }

-// RecordVote updates internal statistics for this peer by recording the block part.
-// It returns the total number of block parts (1 per block). This essentially means
-// the number of blocks for which peer has been sending us block parts.
+// RecordBlockPart updates internal statistics for this peer by recording the
+// block part. It returns the total number of block parts (1 per block). This
+// essentially means the number of blocks for which peer has been sending us
+// block parts.
 func (ps *PeerState) RecordBlockPart(bp *BlockPartMessage) int {
+	ps.mtx.Lock()
+	defer ps.mtx.Unlock()
+
 	if ps.stats.lastBlockPartHeight >= bp.Height {
 		return ps.stats.blockParts
 	}

 	ps.stats.lastBlockPartHeight = bp.Height
-	ps.stats.blockParts += 1
+	ps.stats.blockParts++
 	return ps.stats.blockParts
 }

 // BlockPartsSent returns the number of blocks for which peer has been sending
 // us block parts.
 func (ps *PeerState) BlockPartsSent() int {
+	ps.mtx.Lock()
+	defer ps.mtx.Unlock()
+
 	return ps.stats.blockParts
 }

@ -1275,45 +1305,30 @@ func (ps *PeerState) StringIndented(indent string) string {
 //-----------------------------------------------------------------------------
 // Messages

-const (
-	msgTypeNewRoundStep = byte(0x01)
-	msgTypeCommitStep   = byte(0x02)
-	msgTypeProposal     = byte(0x11)
-	msgTypeProposalPOL  = byte(0x12)
-	msgTypeBlockPart    = byte(0x13) // both block & POL
-	msgTypeVote         = byte(0x14)
-	msgTypeHasVote      = byte(0x15)
-	msgTypeVoteSetMaj23 = byte(0x16)
-	msgTypeVoteSetBits  = byte(0x17)
-
-	msgTypeProposalHeartbeat = byte(0x20)
-)
-
 // ConsensusMessage is a message that can be sent and received on the ConsensusReactor
 type ConsensusMessage interface{}

-var _ = wire.RegisterInterface(
-	struct{ ConsensusMessage }{},
-	wire.ConcreteType{&NewRoundStepMessage{}, msgTypeNewRoundStep},
-	wire.ConcreteType{&CommitStepMessage{}, msgTypeCommitStep},
-	wire.ConcreteType{&ProposalMessage{}, msgTypeProposal},
-	wire.ConcreteType{&ProposalPOLMessage{}, msgTypeProposalPOL},
-	wire.ConcreteType{&BlockPartMessage{}, msgTypeBlockPart},
-	wire.ConcreteType{&VoteMessage{}, msgTypeVote},
-	wire.ConcreteType{&HasVoteMessage{}, msgTypeHasVote},
-	wire.ConcreteType{&VoteSetMaj23Message{}, msgTypeVoteSetMaj23},
-	wire.ConcreteType{&VoteSetBitsMessage{}, msgTypeVoteSetBits},
-	wire.ConcreteType{&ProposalHeartbeatMessage{}, msgTypeProposalHeartbeat},
-)
+func RegisterConsensusMessages(cdc *amino.Codec) {
+	cdc.RegisterInterface((*ConsensusMessage)(nil), nil)
+	cdc.RegisterConcrete(&NewRoundStepMessage{}, "tendermint/NewRoundStepMessage", nil)
+	cdc.RegisterConcrete(&CommitStepMessage{}, "tendermint/CommitStep", nil)
+	cdc.RegisterConcrete(&ProposalMessage{}, "tendermint/Proposal", nil)
+	cdc.RegisterConcrete(&ProposalPOLMessage{}, "tendermint/ProposalPOL", nil)
+	cdc.RegisterConcrete(&BlockPartMessage{}, "tendermint/BlockPart", nil)
+	cdc.RegisterConcrete(&VoteMessage{}, "tendermint/Vote", nil)
+	cdc.RegisterConcrete(&HasVoteMessage{}, "tendermint/HasVote", nil)
+	cdc.RegisterConcrete(&VoteSetMaj23Message{}, "tendermint/VoteSetMaj23", nil)
+	cdc.RegisterConcrete(&VoteSetBitsMessage{}, "tendermint/VoteSetBits", nil)
+	cdc.RegisterConcrete(&ProposalHeartbeatMessage{}, "tendermint/ProposalHeartbeat", nil)
+}

 // DecodeMessage decodes the given bytes into a ConsensusMessage.
-// TODO: check for unnecessary extra bytes at the end.
-func DecodeMessage(bz []byte) (msgType byte, msg ConsensusMessage, err error) {
-	msgType = bz[0]
-	n := new(int)
-	r := bytes.NewReader(bz)
-	msgI := wire.ReadBinary(struct{ ConsensusMessage }{}, r, maxConsensusMessageSize, n, &err)
-	msg = msgI.(struct{ ConsensusMessage }).ConsensusMessage
+func DecodeMessage(bz []byte) (msg ConsensusMessage, err error) {
+	if len(bz) > maxMsgSize {
+		return msg, fmt.Errorf("Msg exceeds max size (%d > %d)",
+			len(bz), maxMsgSize)
+	}
+	err = cdc.UnmarshalBinaryBare(bz, &msg)
 	return
 }

--- a/consensus/reactor_test.go
+++ b/consensus/reactor_test.go
@ -11,7 +11,6 @@ import (
 	"time"

 	"github.com/tendermint/abci/example/kvstore"
-	wire "github.com/tendermint/tendermint/wire"
 	cmn "github.com/tendermint/tmlibs/common"
 	"github.com/tendermint/tmlibs/log"

@ -149,30 +148,30 @@ func TestReactorRecordsBlockParts(t *testing.T) {
 		Round:  0,
 		Part:   parts.GetPart(0),
 	}
-	bz, err := wire.MarshalBinary(struct{ ConsensusMessage }{msg})
+	bz, err := cdc.MarshalBinaryBare(msg)
 	require.NoError(t, err)

 	reactor.Receive(DataChannel, peer, bz)
-	assert.Equal(t, 1, ps.BlockPartsSent(), "number of block parts sent should have increased by 1")
+	require.Equal(t, 1, ps.BlockPartsSent(), "number of block parts sent should have increased by 1")

 	// 2) block part with the same height, but different round
 	msg.Round = 1

-	bz, err = wire.MarshalBinary(struct{ ConsensusMessage }{msg})
+	bz, err = cdc.MarshalBinaryBare(msg)
 	require.NoError(t, err)

 	reactor.Receive(DataChannel, peer, bz)
-	assert.Equal(t, 1, ps.BlockPartsSent(), "number of block parts sent should stay the same")
+	require.Equal(t, 1, ps.BlockPartsSent(), "number of block parts sent should stay the same")

 	// 3) block part from earlier height
 	msg.Height = 1
 	msg.Round = 0

-	bz, err = wire.MarshalBinary(struct{ ConsensusMessage }{msg})
+	bz, err = cdc.MarshalBinaryBare(msg)
 	require.NoError(t, err)

 	reactor.Receive(DataChannel, peer, bz)
-	assert.Equal(t, 1, ps.BlockPartsSent(), "number of block parts sent should stay the same")
+	require.Equal(t, 1, ps.BlockPartsSent(), "number of block parts sent should stay the same")
 }

 // Test we record votes from other peers
@ -204,7 +203,7 @@ func TestReactorRecordsVotes(t *testing.T) {
 		Type:             types.VoteTypePrevote,
 		BlockID:          types.BlockID{},
 	}
-	bz, err := wire.MarshalBinary(struct{ ConsensusMessage }{&VoteMessage{vote}})
+	bz, err := cdc.MarshalBinaryBare(&VoteMessage{vote})
 	require.NoError(t, err)

 	reactor.Receive(VoteChannel, peer, bz)
@ -213,7 +212,7 @@ func TestReactorRecordsVotes(t *testing.T) {
 	// 2) vote with the same height, but different round
 	vote.Round = 1

-	bz, err = wire.MarshalBinary(struct{ ConsensusMessage }{&VoteMessage{vote}})
+	bz, err = cdc.MarshalBinaryBare(&VoteMessage{vote})
 	require.NoError(t, err)

 	reactor.Receive(VoteChannel, peer, bz)
@ -223,7 +222,7 @@ func TestReactorRecordsVotes(t *testing.T) {
 	vote.Height = 1
 	vote.Round = 0

-	bz, err = wire.MarshalBinary(struct{ ConsensusMessage }{&VoteMessage{vote}})
+	bz, err = cdc.MarshalBinaryBare(&VoteMessage{vote})
 	require.NoError(t, err)

 	reactor.Receive(VoteChannel, peer, bz)
@ -410,7 +409,7 @@ func waitForAndValidateBlock(t *testing.T, n int, activeVals map[string]struct{}
 		if !ok {
 			return
 		}
-		newBlock := newBlockI.(types.TMEventData).Unwrap().(types.EventDataNewBlock).Block
+		newBlock := newBlockI.(types.EventDataNewBlock).Block
 		css[j].Logger.Debug("waitForAndValidateBlock: Got block", "height", newBlock.Height)
 		err := validateBlock(newBlock, activeVals)
 		assert.Nil(t, err)
@ -431,7 +430,7 @@ func waitForAndValidateBlockWithTx(t *testing.T, n int, activeVals map[string]st
 			if !ok {
 				return
 			}
-			newBlock := newBlockI.(types.TMEventData).Unwrap().(types.EventDataNewBlock).Block
+			newBlock := newBlockI.(types.EventDataNewBlock).Block
 			css[j].Logger.Debug("waitForAndValidateBlockWithTx: Got block", "height", newBlock.Height)
 			err := validateBlock(newBlock, activeVals)
 			assert.Nil(t, err)
@ -441,7 +440,7 @@ func waitForAndValidateBlockWithTx(t *testing.T, n int, activeVals map[string]st
 			// but they should be in order.
 			for _, tx := range newBlock.Data.Txs {
 				assert.EqualValues(t, txs[ntxs], tx)
-				ntxs += 1
+				ntxs++
 			}

 			if ntxs == len(txs) {
@ -463,7 +462,7 @@ func waitForBlockWithUpdatedValsAndValidateIt(t *testing.T, n int, updatedVals m
 			if !ok {
 				return
 			}
-			newBlock = newBlockI.(types.TMEventData).Unwrap().(types.EventDataNewBlock).Block
+			newBlock = newBlockI.(types.EventDataNewBlock).Block
 			if newBlock.LastCommit.Size() == len(updatedVals) {
 				css[j].Logger.Debug("waitForBlockWithUpdatedValsAndValidateIt: Got block", "height", newBlock.Height)
 				break LOOP
--- a/consensus/replay.go
+++ b/consensus/replay.go
@ -112,7 +112,7 @@ func (cs *ConsensusState) catchupReplay(csHeight int64) error {
 		}
 	}
 	if found {
-		return fmt.Errorf("WAL should not contain #ENDHEIGHT %d.", csHeight)
+		return fmt.Errorf("WAL should not contain #ENDHEIGHT %d", csHeight)
 	}

 	// Search for last height marker
@ -125,7 +125,7 @@ func (cs *ConsensusState) catchupReplay(csHeight int64) error {
 		return err
 	}
 	if !found {
-		return fmt.Errorf("Cannot replay height %d. WAL does not contain #ENDHEIGHT for %d.", csHeight, csHeight-1)
+		return fmt.Errorf("Cannot replay height %d. WAL does not contain #ENDHEIGHT for %d", csHeight, csHeight-1)
 	}
 	defer gr.Close() // nolint: errcheck

@ -352,7 +352,7 @@ func (h *Handshaker) replayBlocks(state sm.State, proxyApp proxy.AppConns, appBl
 	var err error
 	finalBlock := storeBlockHeight
 	if mutateState {
-		finalBlock -= 1
+		finalBlock--
 	}
 	for i := appBlockHeight + 1; i <= finalBlock; i++ {
 		h.logger.Info("Applying block", "height", i)
@ -362,7 +362,7 @@ func (h *Handshaker) replayBlocks(state sm.State, proxyApp proxy.AppConns, appBl
 			return nil, err
 		}

-		h.nBlocks += 1
+		h.nBlocks++
 	}

 	if mutateState {
@ -390,7 +390,7 @@ func (h *Handshaker) replayBlock(state sm.State, height int64, proxyApp proxy.Ap
 		return sm.State{}, err
 	}

-	h.nBlocks += 1
+	h.nBlocks++

 	return state, nil
 }
@ -429,7 +429,7 @@ type mockProxyApp struct {

 func (mock *mockProxyApp) DeliverTx(tx []byte) abci.ResponseDeliverTx {
 	r := mock.abciResponses.DeliverTx[mock.txCount]
-	mock.txCount += 1
+	mock.txCount++
 	return *r
 }

--- a/consensus/replay_file.go
+++ b/consensus/replay_file.go
@ -29,6 +29,7 @@ const (
 //--------------------------------------------------------
 // replay messages interactively or all at once

+// replay the wal file
 func RunReplayFile(config cfg.BaseConfig, csConfig *cfg.ConsensusConfig, console bool) {
 	consensusState := newConsensusStateForReplay(config, csConfig)

@ -87,9 +88,9 @@ func (cs *ConsensusState) ReplayFile(file string, console bool) error {
 		}

 		if nextN > 0 {
-			nextN -= 1
+			nextN--
 		}
-		pb.count += 1
+		pb.count++
 	}
 	return nil
 }
@ -153,7 +154,7 @@ func (pb *playback) replayReset(count int, newStepCh chan interface{}) error {
 		if err := pb.cs.readReplayMessage(msg, newStepCh); err != nil {
 			return err
 		}
-		pb.count += 1
+		pb.count++
 	}
 	return nil
 }
@ -197,13 +198,12 @@ func (pb *playback) replayConsoleLoop() int {

 			if len(tokens) == 1 {
 				return 0
+			}
+			i, err := strconv.Atoi(tokens[1])
+			if err != nil {
+				fmt.Println("next takes an integer argument")
 			} else {
-				i, err := strconv.Atoi(tokens[1])
-				if err != nil {
-					fmt.Println("next takes an integer argument")
-				} else {
-					return i
-				}
+				return i
 			}

 		case "back":
@ -263,7 +263,7 @@ func (pb *playback) replayConsoleLoop() int {
 				case "locked_block":
 					fmt.Printf("%v %v\n", rs.LockedBlockParts.StringShort(), rs.LockedBlock.StringShort())
 				case "votes":
-					fmt.Println(rs.Votes.StringIndented("    "))
+					fmt.Println(rs.Votes.StringIndented("  "))

 				default:
 					fmt.Println("Unknown option", tokens[1])
--- a/consensus/replay_test.go
+++ b/consensus/replay_test.go
@ -18,7 +18,6 @@ import (
 	"github.com/tendermint/abci/example/kvstore"
 	abci "github.com/tendermint/abci/types"
 	crypto "github.com/tendermint/go-crypto"
-	wire "github.com/tendermint/go-wire"
 	auto "github.com/tendermint/tmlibs/autofile"
 	cmn "github.com/tendermint/tmlibs/common"
 	dbm "github.com/tendermint/tmlibs/db"
@ -27,6 +26,7 @@ import (
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
+	pvm "github.com/tendermint/tendermint/types/priv_validator"
 	"github.com/tendermint/tmlibs/log"
 )

@ -60,7 +60,7 @@ func startNewConsensusStateAndWaitForBlock(t *testing.T, lastBlockHeight int64,

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

 	err := cs.Start()
 	require.NoError(t, err)
@ -325,9 +325,9 @@ func testHandshakeReplay(t *testing.T, nBlocks int, mode uint) {
 	walFile := tempWALWithData(walBody)
 	config.Consensus.SetWalFile(walFile)

-	privVal := types.LoadPrivValidatorFS(config.PrivValidatorFile())
+	privVal := pvm.LoadFilePV(config.PrivValidatorFile())

-	wal, err := NewWAL(walFile, false)
+	wal, err := NewWAL(walFile)
 	if err != nil {
 		t.Fatal(err)
 	}
@ -382,9 +382,9 @@ func testHandshakeReplay(t *testing.T, nBlocks int, mode uint) {

 	expectedBlocksToSync := NUM_BLOCKS - nBlocks
 	if nBlocks == NUM_BLOCKS && mode > 0 {
-		expectedBlocksToSync += 1
+		expectedBlocksToSync++
 	} else if nBlocks > 0 && mode == 1 {
-		expectedBlocksToSync += 1
+		expectedBlocksToSync++
 	}

 	if handshaker.NBlocks() != expectedBlocksToSync {
@ -519,8 +519,8 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
 		case EndHeightMessage:
 			// if its not the first one, we have a full block
 			if thisBlockParts != nil {
-				var n int
-				block := wire.ReadBinary(&types.Block{}, thisBlockParts.GetReader(), 0, &n, &err).(*types.Block)
+				var block = new(types.Block)
+				_, err = cdc.UnmarshalBinaryReader(thisBlockParts.GetReader(), block, 0)
 				if err != nil {
 					panic(err)
 				}
@ -533,7 +533,7 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
 				}
 				blocks = append(blocks, block)
 				commits = append(commits, thisBlockCommit)
-				height += 1
+				height++
 			}
 		case *types.PartSetHeader:
 			thisBlockParts = types.NewPartSetFromHeader(*p)
@ -552,8 +552,8 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
 		}
 	}
 	// grab the last block too
-	var n int
-	block := wire.ReadBinary(&types.Block{}, thisBlockParts.GetReader(), 0, &n, &err).(*types.Block)
+	var block = new(types.Block)
+	_, err = cdc.UnmarshalBinaryReader(thisBlockParts.GetReader(), block, 0)
 	if err != nil {
 		panic(err)
 	}
--- a/consensus/state.go
+++ b/consensus/state.go
@ -10,8 +10,6 @@ import (
 	"time"

 	fail "github.com/ebuchman/fail-test"
-
-	wire "github.com/tendermint/go-wire"
 	cmn "github.com/tendermint/tmlibs/common"
 	"github.com/tendermint/tmlibs/log"

@ -170,18 +168,23 @@ func (cs *ConsensusState) GetState() sm.State {
 	return cs.state.Copy()
 }

-// GetRoundState returns a copy of the internal consensus state.
+// GetRoundState returns a shallow copy of the internal consensus state.
 func (cs *ConsensusState) GetRoundState() *cstypes.RoundState {
 	cs.mtx.Lock()
 	defer cs.mtx.Unlock()
-	return cs.getRoundState()
-}

-func (cs *ConsensusState) getRoundState() *cstypes.RoundState {
 	rs := cs.RoundState // copy
 	return &rs
 }

+// GetRoundStateJSON returns a json of RoundState, marshalled using go-amino.
+func (cs *ConsensusState) GetRoundStateJSON() ([]byte, error) {
+	cs.mtx.Lock()
+	defer cs.mtx.Unlock()
+
+	return cdc.MarshalJSON(cs.RoundState)
+}
+
 // GetValidators returns a copy of the current validators.
 func (cs *ConsensusState) GetValidators() (int64, []*types.Validator) {
 	cs.mtx.Lock()
@ -290,7 +293,7 @@ func (cs *ConsensusState) Wait() {

 // OpenWAL opens a file to log all consensus messages and timeouts for deterministic accountability
 func (cs *ConsensusState) OpenWAL(walFile string) (WAL, error) {
-	wal, err := NewWAL(walFile, cs.config.WalLight)
+	wal, err := NewWAL(walFile)
 	if err != nil {
 		cs.Logger.Error("Failed to open WAL for consensus state", "wal", walFile, "err", err)
 		return nil, err
@ -494,7 +497,7 @@ func (cs *ConsensusState) updateToState(state sm.State) {
 func (cs *ConsensusState) newStep() {
 	rs := cs.RoundStateEvent()
 	cs.wal.Save(rs)
-	cs.nSteps += 1
+	cs.nSteps++
 	// newStep is called by updateToStep in NewConsensusState before the eventBus is set!
 	if cs.eventBus != nil {
 		cs.eventBus.PublishEventNewRoundStep(rs)
@ -720,11 +723,7 @@ func (cs *ConsensusState) needProofBlock(height int64) bool {
 func (cs *ConsensusState) proposalHeartbeat(height int64, round int) {
 	counter := 0
 	addr := cs.privValidator.GetAddress()
-	valIndex, v := cs.Validators.GetByAddress(addr)
-	if v == nil {
-		// not a validator
-		valIndex = -1
-	}
+	valIndex, _ := cs.Validators.GetByAddress(addr)
 	chainID := cs.state.ChainID
 	for {
 		rs := cs.GetRoundState()
@ -741,7 +740,7 @@ func (cs *ConsensusState) proposalHeartbeat(height int64, round int) {
 		}
 		cs.privValidator.SignHeartbeat(chainID, heartbeat)
 		cs.eventBus.PublishEventProposalHeartbeat(types.EventDataProposalHeartbeat{heartbeat})
-		counter += 1
+		counter++
 		time.Sleep(proposalHeartbeatIntervalSeconds * time.Second)
 	}
 }
@ -780,7 +779,7 @@ func (cs *ConsensusState) enterPropose(height int64, round int) {

 	// if not a validator, we're done
 	if !cs.Validators.HasAddress(cs.privValidator.GetAddress()) {
-		cs.Logger.Debug("This node is not a validator")
+		cs.Logger.Debug("This node is not a validator", "addr", cs.privValidator.GetAddress(), "vals", cs.Validators)
 		return
 	}
 	cs.Logger.Debug("This node is a validator")
@ -852,10 +851,10 @@ func (cs *ConsensusState) isProposalComplete() bool {
 	// make sure we have the prevotes from it too
 	if cs.Proposal.POLRound < 0 {
 		return true
-	} else {
-		// if this is false the proposer is lying or we haven't received the POL yet
-		return cs.Votes.Prevotes(cs.Proposal.POLRound).HasTwoThirdsMajority()
 	}
+	// if this is false the proposer is lying or we haven't received the POL yet
+	return cs.Votes.Prevotes(cs.Proposal.POLRound).HasTwoThirdsMajority()
+
 }

 // Create the next block to propose and return it.
@ -991,6 +990,7 @@ func (cs *ConsensusState) enterPrecommit(height int64, round int) {
 		cs.newStep()
 	}()

+	// check for a polka
 	blockID, ok := cs.Votes.Prevotes(round).TwoThirdsMajority()

 	// If we don't have a polka, we must precommit nil
@ -1301,10 +1301,10 @@ func (cs *ConsensusState) addProposalBlockPart(height int64, part *types.Part, v
 	}
 	if added && cs.ProposalBlockParts.IsComplete() {
 		// Added and completed!
-		var n int
-		var err error
-		cs.ProposalBlock = wire.ReadBinary(&types.Block{}, cs.ProposalBlockParts.GetReader(),
-			cs.state.ConsensusParams.BlockSize.MaxBytes, &n, &err).(*types.Block)
+		_, err = cdc.UnmarshalBinaryReader(cs.ProposalBlockParts.GetReader(), &cs.ProposalBlock, int64(cs.state.ConsensusParams.BlockSize.MaxBytes))
+		if err != nil {
+			return true, err
+		}
 		// NOTE: it's possible to receive complete proposal blocks for future rounds without having the proposal
 		cs.Logger.Info("Received complete proposal block", "height", cs.ProposalBlock.Height, "hash", cs.ProposalBlock.Hash())
 		if cs.Step == cstypes.RoundStepPropose && cs.isProposalComplete() {
@ -1314,7 +1314,7 @@ func (cs *ConsensusState) addProposalBlockPart(height int64, part *types.Part, v
 			// If we're waiting on the proposal block...
 			cs.tryFinalizeCommit(height)
 		}
-		return true, err
+		return true, nil
 	}
 	return added, nil
 }
@ -1498,12 +1498,11 @@ func (cs *ConsensusState) signAddVote(type_ byte, hash []byte, header types.Part
 		cs.sendInternalMessage(msgInfo{&VoteMessage{vote}, ""})
 		cs.Logger.Info("Signed and pushed vote", "height", cs.Height, "round", cs.Round, "vote", vote, "err", err)
 		return vote
-	} else {
-		//if !cs.replayMode {
-		cs.Logger.Error("Error signing vote", "height", cs.Height, "round", cs.Round, "vote", vote, "err", err)
-		//}
-		return nil
 	}
+	//if !cs.replayMode {
+	cs.Logger.Error("Error signing vote", "height", cs.Height, "round", cs.Round, "vote", vote, "err", err)
+	//}
+	return nil
 }

 //---------------------------------------------------------
--- a/consensus/state_test.go
+++ b/consensus/state_test.go
@ -261,7 +261,7 @@ func TestStateFullRound1(t *testing.T) {

 	// grab proposal
 	re := <-propCh
-	propBlockHash := re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState).ProposalBlock.Hash()
+	propBlockHash := re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState).ProposalBlock.Hash()

 	<-voteCh // wait for prevote
 	validatePrevote(t, cs, round, vss[0], propBlockHash)
@ -356,7 +356,7 @@ func TestStateLockNoPOL(t *testing.T) {
 	cs1.startRoutines(0)

 	re := <-proposalCh
-	rs := re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs := re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
 	theBlockHash := rs.ProposalBlock.Hash()

 	<-voteCh // prevote
@ -396,7 +396,7 @@ func TestStateLockNoPOL(t *testing.T) {

 	// now we're on a new round and not the proposer, so wait for timeout
 	re = <-timeoutProposeCh
-	rs = re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs = re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)

 	if rs.ProposalBlock != nil {
 		panic("Expected proposal block to be nil")
@ -409,7 +409,7 @@ func TestStateLockNoPOL(t *testing.T) {
 	validatePrevote(t, cs1, 1, vss[0], rs.LockedBlock.Hash())

 	// add a conflicting prevote from the other validator
-	signAddVotes(cs1, types.VoteTypePrevote, hash, rs.ProposalBlock.MakePartSet(partSize).Header(), vs2)
+	signAddVotes(cs1, types.VoteTypePrevote, hash, rs.LockedBlock.MakePartSet(partSize).Header(), vs2)
 	<-voteCh

 	// now we're going to enter prevote again, but with invalid args
@ -424,7 +424,7 @@ func TestStateLockNoPOL(t *testing.T) {

 	// add conflicting precommit from vs2
 	// NOTE: in practice we should never get to a point where there are precommits for different blocks at the same round
-	signAddVotes(cs1, types.VoteTypePrecommit, hash, rs.ProposalBlock.MakePartSet(partSize).Header(), vs2)
+	signAddVotes(cs1, types.VoteTypePrecommit, hash, rs.LockedBlock.MakePartSet(partSize).Header(), vs2)
 	<-voteCh

 	// (note we're entering precommit for a second time this round, but with invalid args
@ -440,7 +440,7 @@ func TestStateLockNoPOL(t *testing.T) {
 	incrementRound(vs2)

 	re = <-proposalCh
-	rs = re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs = re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)

 	// now we're on a new round and are the proposer
 	if !bytes.Equal(rs.ProposalBlock.Hash(), rs.LockedBlock.Hash()) {
@ -529,7 +529,7 @@ func TestStateLockPOLRelock(t *testing.T) {

 	<-newRoundCh
 	re := <-proposalCh
-	rs := re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs := re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
 	theBlockHash := rs.ProposalBlock.Hash()

 	<-voteCh // prevote
@ -605,9 +605,9 @@ func TestStateLockPOLRelock(t *testing.T) {
 	discardFromChan(voteCh, 2)

 	be := <-newBlockCh
-	b := be.(types.TMEventData).Unwrap().(types.EventDataNewBlockHeader)
+	b := be.(types.EventDataNewBlockHeader)
 	re = <-newRoundCh
-	rs = re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs = re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
 	if rs.Height != 2 {
 		panic("Expected height to increment")
 	}
@ -643,7 +643,7 @@ func TestStateLockPOLUnlock(t *testing.T) {
 	startTestRound(cs1, cs1.Height, 0)
 	<-newRoundCh
 	re := <-proposalCh
-	rs := re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs := re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
 	theBlockHash := rs.ProposalBlock.Hash()

 	<-voteCh // prevote
@ -669,7 +669,7 @@ func TestStateLockPOLUnlock(t *testing.T) {

 	// timeout to new round
 	re = <-timeoutWaitCh
-	rs = re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs = re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
 	lockedBlockHash := rs.LockedBlock.Hash()

 	//XXX: this isnt guaranteed to get there before the timeoutPropose ...
@ -731,7 +731,7 @@ func TestStateLockPOLSafety1(t *testing.T) {
 	startTestRound(cs1, cs1.Height, 0)
 	<-newRoundCh
 	re := <-proposalCh
-	rs := re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs := re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
 	propBlock := rs.ProposalBlock

 	<-voteCh // prevote
@ -781,7 +781,7 @@ func TestStateLockPOLSafety1(t *testing.T) {
 		re = <-proposalCh
 	}

-	rs = re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs = re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)

 	if rs.LockedBlock != nil {
 		panic("we should not be locked!")
@ -1033,7 +1033,7 @@ func TestStateHalt1(t *testing.T) {
 	startTestRound(cs1, cs1.Height, 0)
 	<-newRoundCh
 	re := <-proposalCh
-	rs := re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs := re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
 	propBlock := rs.ProposalBlock
 	propBlockParts := propBlock.MakePartSet(partSize)

@ -1056,7 +1056,7 @@ func TestStateHalt1(t *testing.T) {
 	// timeout to new round
 	<-timeoutWaitCh
 	re = <-newRoundCh
-	rs = re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs = re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)

 	t.Log("### ONTO ROUND 1")
 	/*Round2
@ -1074,7 +1074,7 @@ func TestStateHalt1(t *testing.T) {
 	// receiving that precommit should take us straight to commit
 	<-newBlockCh
 	re = <-newRoundCh
-	rs = re.(types.TMEventData).Unwrap().(types.EventDataRoundState).RoundState.(*cstypes.RoundState)
+	rs = re.(types.EventDataRoundState).RoundState.(*cstypes.RoundState)

 	if rs.Height != 2 {
 		panic("expected height to increment")
--- a/consensus/types/height_vote_set.go
+++ b/consensus/types/height_vote_set.go
@ -207,6 +207,30 @@ func (hvs *HeightVoteSet) StringIndented(indent string) string {
 		indent)
 }

+type roundVoteBitArrays struct {
+	Round      int           `json:"round"`
+	Prevotes   *cmn.BitArray `json:"prevotes"`
+	Precommits *cmn.BitArray `json:"precommits"`
+}
+
+func (hvs *HeightVoteSet) MarshalJSON() ([]byte, error) {
+	hvs.mtx.Lock()
+	defer hvs.mtx.Unlock()
+	totalRounds := hvs.round + 1
+	roundsVotes := make([]roundVoteBitArrays, totalRounds)
+	// rounds 0 ~ hvs.round inclusive
+	for round := 0; round < totalRounds; round++ {
+		roundsVotes[round] = roundVoteBitArrays{
+			Round:      round,
+			Prevotes:   hvs.roundVoteSets[round].Prevotes.BitArray(),
+			Precommits: hvs.roundVoteSets[round].Precommits.BitArray(),
+		}
+	}
+	// TODO: all other peer catchup rounds
+
+	return cdc.MarshalJSON(roundsVotes)
+}
+
 // If a peer claims that it has 2/3 majority for given blockKey, call this.
 // NOTE: if there are too many peers, or too much peer churn,
 // this can cause memory issues.
--- a/consensus/types/height_vote_set_test.go
+++ b/consensus/types/height_vote_set_test.go
@ -48,7 +48,7 @@ func TestPeerCatchupRounds(t *testing.T) {

 }

-func makeVoteHR(t *testing.T, height int64, round int, privVals []*types.PrivValidatorFS, valIndex int) *types.Vote {
+func makeVoteHR(t *testing.T, height int64, round int, privVals []types.PrivValidator, valIndex int) *types.Vote {
 	privVal := privVals[valIndex]
 	vote := &types.Vote{
 		ValidatorAddress: privVal.GetAddress(),
--- a/consensus/types/peer_round_state.go
+++ b/consensus/types/peer_round_state.go
@ -0,0 +1,57 @@
+package types
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/tendermint/tendermint/types"
+	cmn "github.com/tendermint/tmlibs/common"
+)
+
+//-----------------------------------------------------------------------------
+
+// PeerRoundState contains the known state of a peer.
+// NOTE: Read-only when returned by PeerState.GetRoundState().
+type PeerRoundState struct {
+	Height                   int64               `json:"height"`                      // Height peer is at
+	Round                    int                 `json:"round"`                       // Round peer is at, -1 if unknown.
+	Step                     RoundStepType       `json:"step"`                        // Step peer is at
+	StartTime                time.Time           `json:"start_time"`                  // Estimated start of round 0 at this height
+	Proposal                 bool                `json:"proposal"`                    // True if peer has proposal for this round
+	ProposalBlockPartsHeader types.PartSetHeader `json:"proposal_block_parts_header"` //
+	ProposalBlockParts       *cmn.BitArray       `json:"proposal_block_parts"`        //
+	ProposalPOLRound         int                 `json:"proposal_pol_round"`          // Proposal's POL round. -1 if none.
+	ProposalPOL              *cmn.BitArray       `json:"proposal_pol"`                // nil until ProposalPOLMessage received.
+	Prevotes                 *cmn.BitArray       `json:"prevotes"`                    // All votes peer has for this round
+	Precommits               *cmn.BitArray       `json:"precommits"`                  // All precommits peer has for this round
+	LastCommitRound          int                 `json:"last_commit_round"`           // Round of commit for last height. -1 if none.
+	LastCommit               *cmn.BitArray       `json:"last_commit"`                 // All commit precommits of commit for last height.
+	CatchupCommitRound       int                 `json:"catchup_commit_round"`        // Round that we have commit for. Not necessarily unique. -1 if none.
+	CatchupCommit            *cmn.BitArray       `json:"catchup_commit"`              // All commit precommits peer has for this height & CatchupCommitRound
+}
+
+// String returns a string representation of the PeerRoundState
+func (prs PeerRoundState) String() string {
+	return prs.StringIndented("")
+}
+
+// StringIndented returns a string representation of the PeerRoundState
+func (prs PeerRoundState) StringIndented(indent string) string {
+	return fmt.Sprintf(`PeerRoundState{
+%s  %v/%v/%v @%v
+%s  Proposal %v -> %v
+%s  POL      %v (round %v)
+%s  Prevotes   %v
+%s  Precommits %v
+%s  LastCommit %v (round %v)
+%s  Catchup    %v (round %v)
+%s}`,
+		indent, prs.Height, prs.Round, prs.Step, prs.StartTime,
+		indent, prs.ProposalBlockPartsHeader, prs.ProposalBlockParts,
+		indent, prs.ProposalPOL, prs.ProposalPOLRound,
+		indent, prs.Prevotes,
+		indent, prs.Precommits,
+		indent, prs.LastCommit, prs.LastCommitRound,
+		indent, prs.CatchupCommit, prs.CatchupCommitRound,
+		indent)
+}
--- a/consensus/types/reactor.go
+++ b/consensus/types/reactor.go
@ -1,57 +0,0 @@
-package types
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/tendermint/tendermint/types"
-	cmn "github.com/tendermint/tmlibs/common"
-)
-
-//-----------------------------------------------------------------------------
-
-// PeerRoundState contains the known state of a peer.
-// NOTE: Read-only when returned by PeerState.GetRoundState().
-type PeerRoundState struct {
-	Height                   int64               // Height peer is at
-	Round                    int                 // Round peer is at, -1 if unknown.
-	Step                     RoundStepType       // Step peer is at
-	StartTime                time.Time           // Estimated start of round 0 at this height
-	Proposal                 bool                // True if peer has proposal for this round
-	ProposalBlockPartsHeader types.PartSetHeader //
-	ProposalBlockParts       *cmn.BitArray       //
-	ProposalPOLRound         int                 // Proposal's POL round. -1 if none.
-	ProposalPOL              *cmn.BitArray       // nil until ProposalPOLMessage received.
-	Prevotes                 *cmn.BitArray       // All votes peer has for this round
-	Precommits               *cmn.BitArray       // All precommits peer has for this round
-	LastCommitRound          int                 // Round of commit for last height. -1 if none.
-	LastCommit               *cmn.BitArray       // All commit precommits of commit for last height.
-	CatchupCommitRound       int                 // Round that we have commit for. Not necessarily unique. -1 if none.
-	CatchupCommit            *cmn.BitArray       // All commit precommits peer has for this height & CatchupCommitRound
-}
-
-// String returns a string representation of the PeerRoundState
-func (prs PeerRoundState) String() string {
-	return prs.StringIndented("")
-}
-
-// StringIndented returns a string representation of the PeerRoundState
-func (prs PeerRoundState) StringIndented(indent string) string {
-	return fmt.Sprintf(`PeerRoundState{
-%s  %v/%v/%v @%v
-%s  Proposal %v -> %v
-%s  POL      %v (round %v)
-%s  Prevotes   %v
-%s  Precommits %v
-%s  LastCommit %v (round %v)
-%s  Catchup    %v (round %v)
-%s}`,
-		indent, prs.Height, prs.Round, prs.Step, prs.StartTime,
-		indent, prs.ProposalBlockPartsHeader, prs.ProposalBlockParts,
-		indent, prs.ProposalPOL, prs.ProposalPOLRound,
-		indent, prs.Prevotes,
-		indent, prs.Precommits,
-		indent, prs.LastCommit, prs.LastCommitRound,
-		indent, prs.CatchupCommit, prs.CatchupCommitRound,
-		indent)
-}
--- a/consensus/types/round_state.go
+++ b/consensus/types/round_state.go
@ -13,6 +13,7 @@ import (
 // RoundStepType enumerates the state of the consensus state machine
 type RoundStepType uint8 // These must be numeric, ordered.

+// RoundStepType
 const (
 	RoundStepNewHeight     = RoundStepType(0x01) // Wait til CommitTime + timeoutCommit
 	RoundStepNewRound      = RoundStepType(0x02) // Setup new round and go to RoundStepPropose
@ -52,43 +53,40 @@ func (rs RoundStepType) String() string {
 //-----------------------------------------------------------------------------

 // RoundState defines the internal consensus state.
-// It is Immutable when returned from ConsensusState.GetRoundState()
-// TODO: Actually, only the top pointer is copied,
-// so access to field pointers is still racey
 // NOTE: Not thread safe. Should only be manipulated by functions downstream
 // of the cs.receiveRoutine
 type RoundState struct {
-	Height             int64 // Height we are working on
-	Round              int
-	Step               RoundStepType
-	StartTime          time.Time
-	CommitTime         time.Time // Subjective time when +2/3 precommits for Block at Round were found
-	Validators         *types.ValidatorSet
-	Proposal           *types.Proposal
-	ProposalBlock      *types.Block
-	ProposalBlockParts *types.PartSet
-	LockedRound        int
-	LockedBlock        *types.Block
-	LockedBlockParts   *types.PartSet
-	ValidRound         int
-	ValidBlock         *types.Block
-	ValidBlockParts    *types.PartSet
-	Votes              *HeightVoteSet
-	CommitRound        int            //
-	LastCommit         *types.VoteSet // Last precommits at Height-1
-	LastValidators     *types.ValidatorSet
+	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"`
+	ValidBlock         *types.Block        `json:"valid_block"`
+	ValidBlockParts    *types.PartSet      `json:"valid_block_parts"`
+	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"`
 }

 // RoundStateEvent returns the H/R/S of the RoundState as an event.
 func (rs *RoundState) RoundStateEvent() types.EventDataRoundState {
 	// XXX: copy the RoundState
 	// if we want to avoid this, we may need synchronous events after all
-	rs_ := *rs
+	rsCopy := *rs
 	edrs := types.EventDataRoundState{
 		Height:     rs.Height,
 		Round:      rs.Round,
 		Step:       rs.Step.String(),
-		RoundState: &rs_,
+		RoundState: &rsCopy,
 	}
 	return edrs
 }
@ -118,16 +116,16 @@ func (rs *RoundState) StringIndented(indent string) string {
 		indent, rs.Height, rs.Round, rs.Step,
 		indent, rs.StartTime,
 		indent, rs.CommitTime,
-		indent, rs.Validators.StringIndented(indent+"    "),
+		indent, rs.Validators.StringIndented(indent+"  "),
 		indent, rs.Proposal,
 		indent, rs.ProposalBlockParts.StringShort(), rs.ProposalBlock.StringShort(),
 		indent, rs.LockedRound,
 		indent, rs.LockedBlockParts.StringShort(), rs.LockedBlock.StringShort(),
 		indent, rs.ValidRound,
 		indent, rs.ValidBlockParts.StringShort(), rs.ValidBlock.StringShort(),
-		indent, rs.Votes.StringIndented(indent+"    "),
+		indent, rs.Votes.StringIndented(indent+"  "),
 		indent, rs.LastCommit.StringShort(),
-		indent, rs.LastValidators.StringIndented(indent+"    "),
+		indent, rs.LastValidators.StringIndented(indent+"  "),
 		indent)
 }

--- a/consensus/types/round_state_test.go
+++ b/consensus/types/round_state_test.go
@ -0,0 +1,95 @@
+package types
+
+import (
+	"testing"
+	"time"
+
+	"github.com/tendermint/go-amino"
+	"github.com/tendermint/go-crypto"
+	"github.com/tendermint/tendermint/types"
+	cmn "github.com/tendermint/tmlibs/common"
+)
+
+func BenchmarkRoundStateDeepCopy(b *testing.B) {
+	b.StopTimer()
+
+	// Random validators
+	nval, ntxs := 100, 100
+	vset, _ := types.RandValidatorSet(nval, 1)
+	precommits := make([]*types.Vote, nval)
+	blockID := types.BlockID{
+		Hash: cmn.RandBytes(20),
+		PartsHeader: types.PartSetHeader{
+			Hash: cmn.RandBytes(20),
+		},
+	}
+	sig := crypto.SignatureEd25519{}
+	for i := 0; i < nval; i++ {
+		precommits[i] = &types.Vote{
+			ValidatorAddress: types.Address(cmn.RandBytes(20)),
+			Timestamp:        time.Now(),
+			BlockID:          blockID,
+			Signature:        sig,
+		}
+	}
+	txs := make([]types.Tx, ntxs)
+	for i := 0; i < ntxs; i++ {
+		txs[i] = cmn.RandBytes(100)
+	}
+	// Random block
+	block := &types.Block{
+		Header: &types.Header{
+			ChainID:         cmn.RandStr(12),
+			Time:            time.Now(),
+			LastBlockID:     blockID,
+			LastCommitHash:  cmn.RandBytes(20),
+			DataHash:        cmn.RandBytes(20),
+			ValidatorsHash:  cmn.RandBytes(20),
+			ConsensusHash:   cmn.RandBytes(20),
+			AppHash:         cmn.RandBytes(20),
+			LastResultsHash: cmn.RandBytes(20),
+			EvidenceHash:    cmn.RandBytes(20),
+		},
+		Data: &types.Data{
+			Txs: txs,
+		},
+		Evidence: types.EvidenceData{},
+		LastCommit: &types.Commit{
+			BlockID:    blockID,
+			Precommits: precommits,
+		},
+	}
+	parts := block.MakePartSet(4096)
+	// Random Proposal
+	proposal := &types.Proposal{
+		Timestamp: time.Now(),
+		BlockPartsHeader: types.PartSetHeader{
+			Hash: cmn.RandBytes(20),
+		},
+		POLBlockID: blockID,
+		Signature:  sig,
+	}
+	// Random HeightVoteSet
+	// TODO: hvs :=
+
+	rs := &RoundState{
+		StartTime:          time.Now(),
+		CommitTime:         time.Now(),
+		Validators:         vset,
+		Proposal:           proposal,
+		ProposalBlock:      block,
+		ProposalBlockParts: parts,
+		LockedBlock:        block,
+		LockedBlockParts:   parts,
+		ValidBlock:         block,
+		ValidBlockParts:    parts,
+		Votes:              nil, // TODO
+		LastCommit:         nil, // TODO
+		LastValidators:     vset,
+	}
+	b.StartTimer()
+
+	for i := 0; i < b.N; i++ {
+		amino.DeepCopy(rs)
+	}
+}
--- a/consensus/types/wire.go
+++ b/consensus/types/wire.go
@ -0,0 +1,12 @@
+package types
+
+import (
+	"github.com/tendermint/go-amino"
+	"github.com/tendermint/go-crypto"
+)
+
+var cdc = amino.NewCodec()
+
+func init() {
+	crypto.RegisterAmino(cdc)
+}
--- a/consensus/wal.go
+++ b/consensus/wal.go
@ -1,7 +1,6 @@
 package consensus

 import (
-	"bytes"
 	"encoding/binary"
 	"fmt"
 	"hash/crc32"
@ -11,7 +10,7 @@ import (

 	"github.com/pkg/errors"

-	wire "github.com/tendermint/go-wire"
+	amino "github.com/tendermint/go-amino"
 	"github.com/tendermint/tendermint/types"
 	auto "github.com/tendermint/tmlibs/autofile"
 	cmn "github.com/tendermint/tmlibs/common"
@ -38,13 +37,13 @@ type EndHeightMessage struct {

 type WALMessage interface{}

-var _ = wire.RegisterInterface(
-	struct{ WALMessage }{},
-	wire.ConcreteType{types.EventDataRoundState{}, 0x01},
-	wire.ConcreteType{msgInfo{}, 0x02},
-	wire.ConcreteType{timeoutInfo{}, 0x03},
-	wire.ConcreteType{EndHeightMessage{}, 0x04},
-)
+func RegisterWALMessages(cdc *amino.Codec) {
+	cdc.RegisterInterface((*WALMessage)(nil), nil)
+	cdc.RegisterConcrete(types.EventDataRoundState{}, "tendermint/wal/EventDataRoundState", nil)
+	cdc.RegisterConcrete(msgInfo{}, "tendermint/wal/MsgInfo", nil)
+	cdc.RegisterConcrete(timeoutInfo{}, "tendermint/wal/TimeoutInfo", nil)
+	cdc.RegisterConcrete(EndHeightMessage{}, "tendermint/wal/EndHeightMessage", nil)
+}

 //--------------------------------------------------------
 // Simple write-ahead logger
@ -68,12 +67,11 @@ type baseWAL struct {
 	cmn.BaseService

 	group *auto.Group
-	light bool // ignore block parts

 	enc *WALEncoder
 }

-func NewWAL(walFile string, light bool) (*baseWAL, error) {
+func NewWAL(walFile string) (*baseWAL, error) {
 	err := cmn.EnsureDir(filepath.Dir(walFile), 0700)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to ensure WAL directory is in place")
@ -85,7 +83,6 @@ func NewWAL(walFile string, light bool) (*baseWAL, error) {
 	}
 	wal := &baseWAL{
 		group: group,
-		light: light,
 		enc:   NewWALEncoder(group),
 	}
 	wal.BaseService = *cmn.NewBaseService(nil, "baseWAL", wal)
@ -118,15 +115,6 @@ func (wal *baseWAL) Save(msg WALMessage) {
 		return
 	}

-	if wal.light {
-		// in light mode we only write new steps, timeouts, and our own votes (no proposals, block parts)
-		if mi, ok := msg.(msgInfo); ok {
-			if mi.PeerID != "" {
-				return
-			}
-		}
-	}
-
 	// Write the wal message
 	if err := wal.enc.Encode(&TimedWALMessage{time.Now(), msg}); err != nil {
 		cmn.PanicQ(cmn.Fmt("Error writing msg to consensus wal: %v \n\nMessage: %v", err, msg))
@ -193,7 +181,7 @@ func (wal *baseWAL) SearchForEndHeight(height int64, options *WALSearchOptions)

 // A WALEncoder writes custom-encoded WAL messages to an output stream.
 //
-// Format: 4 bytes CRC sum + 4 bytes length + arbitrary-length value (go-wire encoded)
+// Format: 4 bytes CRC sum + 4 bytes length + arbitrary-length value (go-amino encoded)
 type WALEncoder struct {
 	wr io.Writer
 }
@ -205,7 +193,7 @@ func NewWALEncoder(wr io.Writer) *WALEncoder {

 // Encode writes the custom encoding of v to the stream.
 func (enc *WALEncoder) Encode(v *TimedWALMessage) error {
-	data := wire.BinaryBytes(v)
+	data := cdc.MustMarshalBinaryBare(v)

 	crc := crc32.Checksum(data, crc32c)
 	length := uint32(len(data))
@ -298,9 +286,8 @@ func (dec *WALDecoder) Decode() (*TimedWALMessage, error) {
 		return nil, DataCorruptionError{fmt.Errorf("checksums do not match: (read: %v, actual: %v)", crc, actualCRC)}
 	}

-	var nn int
-	var res *TimedWALMessage // nolint: gosimple
-	res = wire.ReadBinary(&TimedWALMessage{}, bytes.NewBuffer(data), int(length), &nn, &err).(*TimedWALMessage)
+	var res = new(TimedWALMessage) // nolint: gosimple
+	err = cdc.UnmarshalBinaryBare(data, res)
 	if err != nil {
 		return nil, DataCorruptionError{fmt.Errorf("failed to decode data: %v", err)}
 	}
--- a/consensus/wal_generator.go
+++ b/consensus/wal_generator.go
@ -4,7 +4,6 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
-	"math/rand"
 	"os"
 	"path/filepath"
 	"strings"
@ -17,6 +16,7 @@ import (
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
+	pvm "github.com/tendermint/tendermint/types/priv_validator"
 	auto "github.com/tendermint/tmlibs/autofile"
 	cmn "github.com/tendermint/tmlibs/common"
 	"github.com/tendermint/tmlibs/db"
@ -40,7 +40,7 @@ func WALWithNBlocks(numBlocks int) (data []byte, err error) {
 	// COPY PASTE FROM node.go WITH A FEW MODIFICATIONS
 	// NOTE: we can't import node package because of circular dependency
 	privValidatorFile := config.PrivValidatorFile()
-	privValidator := types.LoadOrGenPrivValidatorFS(privValidatorFile)
+	privValidator := pvm.LoadOrGenFilePV(privValidatorFile)
 	genDoc, err := types.GenesisDocFromFile(config.GenesisFile())
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to read genesis file")
@ -116,7 +116,7 @@ func makePathname() string {
 func randPort() int {
 	// returns between base and base + spread
 	base, spread := 20000, 20000
-	return base + rand.Intn(spread)
+	return base + cmn.RandIntn(spread)
 }

 func makeAddrs() (string, string, string) {
--- a/consensus/wal_test.go
+++ b/consensus/wal_test.go
@ -3,11 +3,10 @@ package consensus
 import (
 	"bytes"
 	"crypto/rand"
-	"sync"
+	// "sync"
 	"testing"
 	"time"

-	wire "github.com/tendermint/go-wire"
 	"github.com/tendermint/tendermint/consensus/types"
 	tmtypes "github.com/tendermint/tendermint/types"
 	cmn "github.com/tendermint/tmlibs/common"
@ -36,7 +35,7 @@ func TestWALEncoderDecoder(t *testing.T) {
 		decoded, err := dec.Decode()
 		require.NoError(t, err)

-		assert.Equal(t, msg.Time.Truncate(time.Millisecond), decoded.Time)
+		assert.Equal(t, msg.Time.UTC(), decoded.Time)
 		assert.Equal(t, msg.Msg, decoded.Msg)
 	}
 }
@ -48,7 +47,7 @@ func TestWALSearchForEndHeight(t *testing.T) {
 	}
 	walFile := tempWALWithData(walBody)

-	wal, err := NewWAL(walFile, false)
+	wal, err := NewWAL(walFile)
 	if err != nil {
 		t.Fatal(err)
 	}
@ -68,6 +67,7 @@ func TestWALSearchForEndHeight(t *testing.T) {
 	assert.Equal(t, rs.Height, h+1, cmn.Fmt("wrong height"))
 }

+/*
 var initOnce sync.Once

 func registerInterfacesOnce() {
@ -78,6 +78,7 @@ func registerInterfacesOnce() {
 		)
 	})
 }
+*/

 func nBytes(n int) []byte {
 	buf := make([]byte, n)
@ -86,7 +87,7 @@ func nBytes(n int) []byte {
 }

 func benchmarkWalDecode(b *testing.B, n int) {
-	registerInterfacesOnce()
+	// registerInterfacesOnce()

 	buf := new(bytes.Buffer)
 	enc := NewWALEncoder(buf)
--- a/consensus/wire.go
+++ b/consensus/wire.go
@ -0,0 +1,14 @@
+package consensus
+
+import (
+	"github.com/tendermint/go-amino"
+	"github.com/tendermint/go-crypto"
+)
+
+var cdc = amino.NewCodec()
+
+func init() {
+	RegisterConsensusMessages(cdc)
+	RegisterWALMessages(cdc)
+	crypto.RegisterAmino(cdc)
+}
--- a/docker-compose.yml
+++ b/docker-compose.yml
@ -0,0 +1,68 @@
+version: '3'
+
+services:
+  node0:
+    container_name: node0
+    image: "tendermint/localnode"
+    ports:
+      - "46656-46657:46656-46657"
+    environment:
+      - ID=0
+      - LOG=${LOG:-tendermint.log}
+    volumes:
+      - ${FOLDER:-./build}:/tendermint:Z
+    networks:
+      localnet:
+        ipv4_address: 192.167.10.2
+
+  node1:
+    container_name: node1
+    image: "tendermint/localnode"
+    ports:
+      - "46659-46660:46656-46657"
+    environment:
+      - ID=1
+      - LOG=${LOG:-tendermint.log}
+    volumes:
+      - ${FOLDER:-./build}:/tendermint:Z
+    networks:
+      localnet:
+        ipv4_address: 192.167.10.3
+
+  node2:
+    container_name: node2
+    image: "tendermint/localnode"
+    environment:
+      - ID=2
+      - LOG=${LOG:-tendermint.log}
+    ports:
+      - "46661-46662:46656-46657"
+    volumes:
+      - ${FOLDER:-./build}:/tendermint:Z
+    networks:
+      localnet:
+        ipv4_address: 192.167.10.4
+
+  node3:
+    container_name: node3
+    image: "tendermint/localnode"
+    environment:
+      - ID=3
+      - LOG=${LOG:-tendermint.log}
+    ports:
+      - "46663-46664:46656-46657"
+    volumes:
+      - ${FOLDER:-./build}:/tendermint:Z
+    networks:
+      localnet:
+        ipv4_address: 192.167.10.5
+
+networks:
+  localnet:
+    driver: bridge
+    ipam:
+      driver: default
+      config:
+      -
+        subnet: 192.167.10.0/16
+
--- a/docs/architecture/adr-008-priv-validator.md
+++ b/docs/architecture/adr-008-priv-validator.md
@ -1,128 +1,29 @@
-# ADR 008: PrivValidator
+# ADR 008: SocketPV

-## Context
+Tendermint node's should support only two in-process PrivValidator
+implementations:

-The current PrivValidator is monolithic and isn't easily reuseable by alternative signers.
+- FilePV uses an unencrypted private key in a "priv_validator.json" file - no
+  configuration required (just `tendermint init`).
+- SocketPV uses a socket to send signing requests to another process - user is
+  responsible for starting that process themselves.

-For instance, see https://github.com/tendermint/tendermint/issues/673
+The SocketPV address can be provided via flags at the command line - doing so
+will cause Tendermint to ignore any "priv_validator.json" file and to listen on
+the given address for incoming connections from an external priv_validator
+process.  It will halt any operation until at least one external process
+succesfully connected.

-The goal is to have a clean PrivValidator interface like:
+The external priv_validator process will dial the address to connect to
+Tendermint, and then Tendermint will send requests on the ensuing connection to
+sign votes and proposals.  Thus the external process initiates the connection,
+but the Tendermint process makes all requests.  In a later stage we're going to
+support multiple validators for fault tolerance. To prevent double signing they
+need to be synced, which is deferred to an external solution (see #1185).

-```
-type PrivValidator interface {
-	Address() data.Bytes
-	PubKey() crypto.PubKey
-
-	SignVote(chainID string, vote *types.Vote) error
-	SignProposal(chainID string, proposal *types.Proposal) error
-	SignHeartbeat(chainID string, heartbeat *types.Heartbeat) error
-}
-```
-
-It should also be easy to re-use the LastSignedInfo logic to avoid double signing.
-
-## Decision
-
-Tendermint node's should support only two in-process PrivValidator implementations:
-
- PrivValidatorUnencrypted uses an unencrypted private key in a "priv_validator.json" file - no configuration required (just `tendermint init`).
- PrivValidatorSocket uses a socket to send signing requests to another process - user is responsible for starting that process themselves.
-
-The PrivValidatorSocket address can be provided via flags at the command line -
-doing so will cause Tendermint to ignore any "priv_validator.json" file and to listen
-on the given address for incoming connections from an external priv_validator process.
-It will halt any operation until at least one external process succesfully
-connected.
-
-The external priv_validator process will dial the address to connect to Tendermint,
-and then Tendermint will send requests on the ensuing connection to sign votes and proposals.
-Thus the external process initiates the connection, but the Tendermint process makes all requests.
-In a later stage we're going to support multiple validators for fault
-tolerance. To prevent double signing they need to be synced, which is deferred
-to an external solution (see #1185).
-
-In addition, Tendermint will provide implementations that can be run in that external process.
-These include:
-
- PrivValidatorEncrypted uses an encrypted private key persisted to disk - user must enter password to decrypt key when process is started.
- PrivValidatorLedger uses a Ledger Nano S to handle all signing.
-
-What follows are descriptions of useful types
-
-### Signer
-
-```
-type Signer interface {
-	Sign(msg []byte) (crypto.Signature, error)
-}
-```
-
-Signer signs a message. It can also return an error.
-
-### ValidatorID
-
-
-ValidatorID is just the Address and PubKey
-
-```
-type ValidatorID struct {
-	Address data.Bytes    `json:"address"`
-	PubKey  crypto.PubKey `json:"pub_key"`
-}
-```
-
-### LastSignedInfo
-
-LastSignedInfo tracks the last thing we signed:
-
-```
-type LastSignedInfo struct {
-	Height    int64            `json:"height"`
-	Round     int              `json:"round"`
-	Step      int8             `json:"step"`
-	Signature crypto.Signature `json:"signature,omitempty"` // so we dont lose signatures
-	SignBytes data.Bytes       `json:"signbytes,omitempty"` // so we dont lose signatures
-}
-```
-
-It exposes methods for signing votes and proposals using a `Signer`.
-
-This allows it to easily be reused by developers implemented their own PrivValidator.
-
-### PrivValidatorUnencrypted
-
-```
-type PrivValidatorUnencrypted struct {
-	ID             types.ValidatorID `json:"id"`
-	PrivKey        PrivKey           `json:"priv_key"`
-	LastSignedInfo *LastSignedInfo   `json:"last_signed_info"`
-}
-```
-
-Has the same structure as currently, but broken up into sub structs.
-
-Note the LastSignedInfo is mutated in place every time we sign.
-
-### PrivValidatorJSON
-
-The "priv_validator.json" file supports only the PrivValidatorUnencrypted type.
-
-It unmarshals into PrivValidatorJSON, which is used as the default PrivValidator type.
-It wraps the PrivValidatorUnencrypted and persists it to disk after every signature.
-
-## Status
-
-Accepted.
-
-## Consequences
-
-### Positive
-
- Cleaner separation of components enabling re-use.
-
-### Negative
-
- More files - led to creation of new directory.
-
-### Neutral
+In addition, Tendermint will provide implementations that can be run in that
+external process.  These include:

+- FilePV will encrypt the private key, and the user must enter password to
+  decrypt key when process is started.
+- LedgerPV uses a Ledger Nano S to handle all signing.
--- a/docs/conf.py
+++ b/docs/conf.py
@ -196,9 +196,8 @@ urllib.urlretrieve(tools_repo+tools_branch+'/mintnet-kubernetes/assets/statefuls
 urllib.urlretrieve(tools_repo+tools_branch+'/mintnet-kubernetes/assets/t_plus_k.png', filename=assets_dir+'/t_plus_k.png')

 urllib.urlretrieve(tools_repo+tools_branch+'/terraform-digitalocean/README.rst', filename=tools_dir+'/terraform-digitalocean.rst')
-urllib.urlretrieve(tools_repo+tools_branch+'/tm-bench/README.rst', filename=tools_dir+'/benchmarking-and-monitoring.rst')
-# the readme for below is included in tm-bench
-# urllib.urlretrieve('https://raw.githubusercontent.com/tendermint/tools/master/tm-monitor/README.rst', filename='tools/tm-monitor.rst')
+urllib.urlretrieve(tools_repo+tools_branch+'/tm-bench/README.rst', filename=tools_dir+'/benchmarking.rst')
+urllib.urlretrieve('https://raw.githubusercontent.com/tendermint/tools/master/tm-monitor/README.rst', filename='tools/monitoring.rst')

 #### abci spec #################################

--- a/docs/deploy-testnets.rst
+++ b/docs/deploy-testnets.rst
@ -11,26 +11,26 @@ Manual Deployments

 It's relatively easy to setup a Tendermint cluster manually. The only
 requirements for a particular Tendermint node are a private key for the
-validator, stored as ``priv_validator.json``, and a list of the public
-keys of all validators, stored as ``genesis.json``. These files should
-be stored in ``~/.tendermint/config``, or wherever the ``$TMHOME`` variable
-might be set to.
+validator, stored as ``priv_validator.json``, a node key, stored as
+``node_key.json`` and a list of the public keys of all validators, stored as
+``genesis.json``. These files should be stored in ``~/.tendermint/config``, or
+wherever the ``$TMHOME`` variable might be set to.

 Here are the steps to setting up a testnet manually:

 1) Provision nodes on your cloud provider of choice
 2) Install Tendermint and the application of interest on all nodes
-3) Generate a private key for each validator using
-   ``tendermint gen_validator``
+3) Generate a private key and a node key for each validator using
+   ``tendermint init``
 4) Compile a list of public keys for each validator into a
-   ``genesis.json`` file.
+   ``genesis.json`` file and replace the existing file with it.
 5) Run ``tendermint node --p2p.persistent_peers=< peer addresses >`` on each node,
   where ``< peer addresses >`` is a comma separated list of the IP:PORT
   combination for each node. The default port for Tendermint is
   ``46656``. Thus, if the IP addresses of your nodes were
   ``192.168.0.1, 192.168.0.2, 192.168.0.3, 192.168.0.4``, the command
   would look like:
-   ``tendermint node --p2p.persistent_peers=192.168.0.1:46656,192.168.0.2:46656,192.168.0.3:46656,192.168.0.4:46656``.
+   ``tendermint node --p2p.persistent_peers=96663a3dd0d7b9d17d4c8211b191af259621c693@192.168.0.1:46656, 429fcf25974313b95673f58d77eacdd434402665@192.168.0.2:46656, 0491d373a8e0fcf1023aaf18c51d6a1d0d4f31bd@192.168.0.3:46656, f9baeaa15fedf5e1ef7448dd60f46c01f1a9e9c4@192.168.0.4:46656``.

 After a few seconds, all the nodes should connect to each other and start
 making blocks! For more information, see the Tendermint Networks section
--- a/docs/examples/getting-started.md
+++ b/docs/examples/getting-started.md
@ -2,8 +2,9 @@

 ## Overview

-This is a quick start guide. If you have a vague idea about how Tendermint works
-and want to get started right away, continue. Otherwise, [review the documentation](http://tendermint.readthedocs.io/en/master/)
+This is a quick start guide. If you have a vague idea about how Tendermint
+works and want to get started right away, continue. Otherwise, [review the
+documentation](http://tendermint.readthedocs.io/en/master/).

 ## Install

@ -42,7 +43,7 @@ Confirm installation:

 ```
 $ tendermint version
-0.15.0-381fe19
+0.18.0-XXXXXXX
 ```

 ## Initialization
@ -117,7 +118,9 @@ where the value is returned in hex.

 ## Cluster of Nodes

-First create four Ubuntu cloud machines. The following was tested on Digital Ocean Ubuntu 16.04 x64 (3GB/1CPU, 20GB SSD). We'll refer to their respective IP addresses below as IP1, IP2, IP3, IP4.
+First create four Ubuntu cloud machines. The following was tested on Digital
+Ocean Ubuntu 16.04 x64 (3GB/1CPU, 20GB SSD). We'll refer to their respective IP
+addresses below as IP1, IP2, IP3, IP4.

 Then, `ssh` into each machine, and execute [this script](https://git.io/vNLfY):

@ -131,12 +134,16 @@ This will install `go` and other dependencies, get the Tendermint source code, t
 Next, `cd` into `docs/examples`. Each command below should be run from each node, in sequence:

 ```
-tendermint node --home ./node1 --proxy_app=kvstore --p2p.seeds IP1:46656,IP2:46656,IP3:46656,IP4:46656
-tendermint node --home ./node2 --proxy_app=kvstore --p2p.seeds IP1:46656,IP2:46656,IP3:46656,IP4:46656
-tendermint node --home ./node3 --proxy_app=kvstore --p2p.seeds IP1:46656,IP2:46656,IP3:46656,IP4:46656
-tendermint node --home ./node4 --proxy_app=kvstore --p2p.seeds IP1:46656,IP2:46656,IP3:46656,IP4:46656
+tendermint node --home ./node1 --proxy_app=kvstore --p2p.persistent_peers="3a558bd6f8c97453aa6c2372bb800e8b6ed8e6db@IP1:46656,ccf30d873fddda10a495f42687c8f33472a6569f@IP2:46656,9a4c3de5d6788a76c6ee3cd9ff41e3b45b4cfd14@IP3:46656,58e6f2ab297b3ceae107ba4c8c2898da5c009ff4@IP4:46656"
+tendermint node --home ./node2 --proxy_app=kvstore --p2p.persistent_peers="3a558bd6f8c97453aa6c2372bb800e8b6ed8e6db@IP1:46656,ccf30d873fddda10a495f42687c8f33472a6569f@IP2:46656,9a4c3de5d6788a76c6ee3cd9ff41e3b45b4cfd14@IP3:46656,58e6f2ab297b3ceae107ba4c8c2898da5c009ff4@IP4:46656"
+tendermint node --home ./node3 --proxy_app=kvstore --p2p.persistent_peers="3a558bd6f8c97453aa6c2372bb800e8b6ed8e6db@IP1:46656,ccf30d873fddda10a495f42687c8f33472a6569f@IP2:46656,9a4c3de5d6788a76c6ee3cd9ff41e3b45b4cfd14@IP3:46656,58e6f2ab297b3ceae107ba4c8c2898da5c009ff4@IP4:46656"
+tendermint node --home ./node4 --proxy_app=kvstore --p2p.persistent_peers="3a558bd6f8c97453aa6c2372bb800e8b6ed8e6db@IP1:46656,ccf30d873fddda10a495f42687c8f33472a6569f@IP2:46656,9a4c3de5d6788a76c6ee3cd9ff41e3b45b4cfd14@IP3:46656,58e6f2ab297b3ceae107ba4c8c2898da5c009ff4@IP4:46656"
 ```

-Note that after the third node is started, blocks will start to stream in because >2/3 of validators (defined in the `genesis.json`) have come online. Seeds can also be specified in the `config.toml`. See [this PR](https://github.com/tendermint/tendermint/pull/792) for more information about configuration options.
+Note that after the third node is started, blocks will start to stream in
+because >2/3 of validators (defined in the `genesis.json`) have come online.
+Seeds can also be specified in the `config.toml`. See [this
+PR](https://github.com/tendermint/tendermint/pull/792) for more information
+about configuration options.

 Transactions can then be sent as covered in the single, local node example above.
--- a/docs/examples/install_tendermint.sh
+++ b/docs/examples/install_tendermint.sh
@ -26,7 +26,7 @@ go get $REPO
 cd $GOPATH/src/$REPO

 ## build
-git checkout v0.17.0
+git checkout v0.18.0
 make get_tools
 make get_vendor_deps
 make install
--- a/docs/examples/node1/node_key.json
+++ b/docs/examples/node1/node_key.json
@ -0,0 +1,6 @@
+{
+   "priv_key" : {
+      "data" : "DA9BAABEA7211A6D93D9A1986B4279EAB3021FAA1653D459D53E6AB4D1CFB4C69BF7D52E48CF00AC5779AA0A6D3C368955D5636A677F72370B8ED19989714CFC",
+      "type" : "ed25519"
+   }
+}
--- a/docs/examples/node2/node_key.json
+++ b/docs/examples/node2/node_key.json
@ -0,0 +1,6 @@
+{
+   "priv_key" : {
+      "data" : "F7BCABA165DFC0DDD50AE563EFB285BAA236EA805D35612504238A36EFA105958756442B1D9F942D7ABD259F2D59671657B6378E9C7194342A7AAA47A66D1E95",
+      "type" : "ed25519"
+   }
+}
--- a/docs/examples/node3/node_key.json
+++ b/docs/examples/node3/node_key.json
@ -0,0 +1,6 @@
+{
+   "priv_key" : {
+      "data" : "95136FCC97E4446B3141EDF9841078107ECE755E99925D79CCBF91085492680B3CA1034D9917DF1DED4E4AB2D9BC225919F6CB2176F210D2368697CC339DF4E7",
+      "type" : "ed25519"
+   }
+}
--- a/docs/examples/node4/node_key.json
+++ b/docs/examples/node4/node_key.json
@ -0,0 +1,6 @@
+{
+   "priv_key" : {
+      "data" : "8895D6C9A1B46AB83A8E2BAE2121B8C3E245B9E9126EBD797FEAC5058285F2F64FDE2E8182C88AD5185A49D837C581465D57BD478C41865A66D7D9742D8AEF57",
+      "type" : "ed25519"
+   }
+}
--- a/docs/getting-started.rst
+++ b/docs/getting-started.rst
@ -81,9 +81,8 @@ Tendermint node as follows:

    curl -s localhost:46657/status

-The ``-s`` just silences ``curl``. For nicer output, pipe the result
-into a tool like `jq <https://stedolan.github.io/jq/>`__ or
-`jsonpp <https://github.com/jmhodges/jsonpp>`__.
+The ``-s`` just silences ``curl``. For nicer output, pipe the result into a
+tool like `jq <https://stedolan.github.io/jq/>`__ or ``json_pp``.

 Now let's send some transactions to the kvstore.

@ -104,17 +103,23 @@ like:
      "id": "",
      "result": {
        "check_tx": {
-          "code": 0,
-          "data": "",
-          "log": ""
+          "fee": {}
        },
        "deliver_tx": {
-          "code": 0,
-          "data": "",
-          "log": ""
+          "tags": [
+            {
+              "key": "YXBwLmNyZWF0b3I=",
+              "value": "amFl"
+            },
+            {
+              "key": "YXBwLmtleQ==",
+              "value": "YWJjZA=="
+            }
+          ],
+          "fee": {}
        },
-        "hash": "2B8EC32BA2579B3B8606E42C06DE2F7AFA2556EF",
-        "height": 154
+        "hash": "9DF66553F98DE3C26E3C3317A3E4CED54F714E39",
+        "height": 14
      }
    }

@ -134,20 +139,17 @@ The result should look like:
      "id": "",
      "result": {
        "response": {
-          "code": 0,
-          "index": 0,
-          "key": "",
-          "value": "61626364",
-          "proof": "",
-          "height": 0,
-          "log": "exists"
+          "log": "exists",
+          "index": "-1",
+          "key": "YWJjZA==",
+          "value": "YWJjZA=="
        }
      }
    }

-Note the ``value`` in the result (``61626364``); this is the
-hex-encoding of the ASCII of ``abcd``. You can verify this in
-a python 2 shell by running ``"61626364".decode('hex')`` or in python 3 shell by running ``import codecs; codecs.decode("61626364", 'hex').decode('ascii')``. Stay
+Note the ``value`` in the result (``YWJjZA==``); this is the
+base64-encoding of the ASCII of ``abcd``. You can verify this in
+a python 2 shell by running ``"61626364".decode('base64')`` or in python 3 shell by running ``import codecs; codecs.decode("61626364", 'base64').decode('ascii')``. Stay
 tuned for a future release that `makes this output more human-readable <https://github.com/tendermint/abci/issues/32>`__.

 Now let's try setting a different key and value:
@ -157,7 +159,7 @@ Now let's try setting a different key and value:
    curl -s 'localhost:46657/broadcast_tx_commit?tx="name=satoshi"'

 Now if we query for ``name``, we should get ``satoshi``, or
-``7361746F736869`` in hex:
+``c2F0b3NoaQ==`` in base64:

 ::

@ -226,17 +228,15 @@ the number ``1``. If instead, we try to send a ``5``, we get an error:
      "id": "",
      "result": {
        "check_tx": {
-          "code": 0,
-          "data": "",
-          "log": ""
+          "fee": {}
        },
        "deliver_tx": {
-          "code": 3,
-          "data": "",
-          "log": "Invalid nonce. Expected 1, got 5"
+          "code": 2,
+          "log": "Invalid nonce. Expected 1, got 5",
+          "fee": {}
        },
        "hash": "33B93DFF98749B0D6996A70F64071347060DC19C",
-        "height": 38
+        "height": 34
      }
    }

@ -250,17 +250,13 @@ But if we send a ``1``, it works again:
      "id": "",
      "result": {
        "check_tx": {
-          "code": 0,
-          "data": "",
-          "log": ""
+          "fee": {}
        },
        "deliver_tx": {
-          "code": 0,
-          "data": "",
-          "log": ""
+          "fee": {}
        },
        "hash": "F17854A977F6FA7EEA1BD758E296710B86F72F3D",
-        "height": 87
+        "height": 60
      }
    }

--- a/docs/how-to-read-logs.rst
+++ b/docs/how-to-read-logs.rst
@ -59,7 +59,7 @@ Next we replay all the messages from the WAL.
 ::

    I[10-04|13:54:30.391] Starting RPC HTTP server on tcp socket 0.0.0.0:46657 module=rpc-server
-    I[10-04|13:54:30.392] Started node                                 module=main nodeInfo="NodeInfo{pk: PubKeyEd25519{DF22D7C92C91082324A1312F092AA1DA197FA598DBBFB6526E177003C4D6FD66}, moniker: anonymous, network: test-chain-3MNw2N [remote , listen 10.0.2.15:46656], version: 0.11.0-10f361fc ([wire_version=0.6.2 p2p_version=0.5.0 consensus_version=v1/0.2.2 rpc_version=0.7.0/3 tx_index=on rpc_addr=tcp://0.0.0.0:46657])}"
+    I[10-04|13:54:30.392] Started node                                 module=main nodeInfo="NodeInfo{id: DF22D7C92C91082324A1312F092AA1DA197FA598DBBFB6526E, moniker: anonymous, network: test-chain-3MNw2N [remote , listen 10.0.2.15:46656], version: 0.11.0-10f361fc ([wire_version=0.6.2 p2p_version=0.5.0 consensus_version=v1/0.2.2 rpc_version=0.7.0/3 tx_index=on rpc_addr=tcp://0.0.0.0:46657])}"

 Next follows a standard block creation cycle, where we enter a new round,
 propose a block, receive more than 2/3 of prevotes, then precommits and finally
--- a/docs/index.rst
+++ b/docs/index.rst
@ -44,7 +44,8 @@ Tendermint Tools
   tools/docker.rst
   tools/mintnet-kubernetes.rst
   tools/terraform-digitalocean.rst
-   tools/benchmarking-and-monitoring.rst
+   tools/benchmarking.rst
+   tools/monitoring.rst

 Tendermint 102
 --------------
--- a/docs/install.rst
+++ b/docs/install.rst
@ -4,7 +4,7 @@ Install Tendermint
 From Binary
 -----------

-To download pre-built binaries, see the `Download page <https://tendermint.com/download>`__.
+To download pre-built binaries, see the `Download page <https://tendermint.com/downloads>`__.

 From Source
 -----------
@ -37,13 +37,13 @@ First, install ``dep``:

 ::

+    cd $GOPATH/src/github.com/tendermint/tendermint
    make get_tools

 Now we can fetch the correct versions of each dependency by running:

 ::

-    cd $GOPATH/src/github.com/tendermint/tendermint
    make get_vendor_deps
    make install

@ -96,6 +96,7 @@ If ``go get`` failing bothers you, fetch the code using ``git``:
    mkdir -p $GOPATH/src/github.com/tendermint
    git clone https://github.com/tendermint/tendermint $GOPATH/src/github.com/tendermint/tendermint
    cd $GOPATH/src/github.com/tendermint/tendermint
+    make get_tools
    make get_vendor_deps
    make install

--- a/docs/specification/configuration.rst
+++ b/docs/specification/configuration.rst
@ -140,7 +140,6 @@ like the file below, however, double check by inspecting the
    [consensus]

    wal_file = "data/cs.wal/wal"
-    wal_light = false

    # All timeouts are in milliseconds
    timeout_propose = 3000
--- a/docs/specification/genesis.rst
+++ b/docs/specification/genesis.rst
@ -18,8 +18,8 @@ Fields
 -  ``power``: The validator's voting power.
 -  ``name``: Name of the validator (optional).
 -  ``app_hash``: The expected application hash (as returned by the
-   ``Commit`` ABCI message) upon genesis. If the app's hash does not
-   match, a warning message is printed.
+   ``ResponseInfo`` ABCI message) upon genesis. If the app's hash does not
+   match, Tendermint will panic.
 -  ``app_state``: The application state (e.g. initial distribution of tokens).

 Sample genesis.json
--- a/docs/specification/new-spec/abci.md
+++ b/docs/specification/new-spec/abci.md
@ -0,0 +1,69 @@
+# Application Blockchain Interface (ABCI)
+
+ABCI is the interface between Tendermint (a state-machine replication engine)
+and an application (the actual state machine).
+
+The ABCI message types are defined in a [protobuf
+file](https://github.com/tendermint/abci/blob/master/types/types.proto).
+For full details on the ABCI message types and protocol, see the [ABCI
+specificaiton](https://github.com/tendermint/abci/blob/master/specification.rst).
+For additional details on server implementation, see the [ABCI
+readme](https://github.com/tendermint/abci#implementation).
+
+Here we provide some more details around the use of ABCI by Tendermint and
+clarify common "gotchas".
+
+## Validator Updates
+
+Updates to the Tendermint validator set can be made by returning `Validator`
+objects in the `ResponseBeginBlock`:
+
+```
+message Validator {
+    bytes pub_key = 1;
+    int64 power = 2;
+}
+```
+
+The `pub_key` is the Amino encoded public key for the validator. For details on
+Amino encoded public keys, see the [section of the encoding spec](./encoding.md#public-key-cryptography).
+
+For Ed25519 pubkeys, the Amino prefix is always "1624DE6220". For example, the 32-byte Ed25519 pubkey
+`76852933A4686A721442E931A8415F62F5F1AEDF4910F1F252FB393F74C40C85` would be
+Amino encoded as
+`1624DE622076852933A4686A721442E931A8415F62F5F1AEDF4910F1F252FB393F74C40C85`
+
+(Note: in old versions of Tendermint (pre-v0.19.0), the pubkey is just prefixed with a
+single type byte, so for ED25519 we'd have `pub_key = 0x1 | pub`)
+
+The `power` is the new voting power for the validator, with the
+following rules:
+
+- power must be non-negative
+- if power is 0, the validator must already exist, and will be removed from the
+  validator set
+- if power is non-0:
+    - 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
+
+## Query
+
+Query is a generic message type with lots of flexibility to enable diverse sets
+of queries from applications. Tendermint has no requirements from the Query
+message for normal operation - that is, the ABCI app developer need not implement Query functionality if they do not wish too.
+That said, Tendermint makes a number of queries to support some optional
+features. These are:
+
+### Peer Filtering
+
+When Tendermint connects to a peer, it sends two queries to the ABCI application
+using the following paths, with no additional data:
+
+ - `/p2p/filter/addr/<IP:PORT>`, where `<IP:PORT>` denote the IP address and
+   the port of the connection
+ - `p2p/filter/pubkey/<ID>`, where `<ID>` is the peer node ID (ie. the
+   pubkey.Address() for the peer's PubKey)
+
+If either of these queries return a non-zero ABCI code, Tendermint will refuse
+to connect to the peer.
--- a/docs/specification/new-spec/encoding.md
+++ b/docs/specification/new-spec/encoding.md
@ -1,106 +1,163 @@
 # Tendermint Encoding

-## Binary Serialization (TMBIN)
+## Amino

-Tendermint aims to encode data structures in a manner similar to how the corresponding Go structs
-are laid out in memory.
-Variable length items are length-prefixed.
-While the encoding was inspired by Go, it is easily implemented in other languages as well, given its intuitive design.
+Tendermint uses the Protobuf3 derrivative [Amino]() for all data structures.
+Think of Amino as an object-oriented Protobuf3 with native JSON support.
+The goal of the Amino encoding protocol is to bring parity between application
+logic objects and persistence objects.

-XXX: This is changing to use real varints and 4-byte-prefixes.
-See https://github.com/tendermint/go-wire/tree/sdk2.
+Please see the [Amino
+specification](https://github.com/tendermint/go-amino#amino-encoding-for-go) for
+more details.

-### Fixed Length Integers
+Notably, every object that satisfies an interface (eg. a particular kind of p2p message,
+or a particular kind of pubkey) is registered with a global name, the hash of
+which is included in the object's encoding as the so-called "prefix bytes".

-Fixed length integers are encoded in Big-Endian using the specified number of bytes.
-So `uint8` and `int8` use one byte, `uint16` and `int16` use two bytes,
-`uint32` and `int32` use 3 bytes, and `uint64` and `int64` use 4 bytes.
+We define the `func AminoEncode(obj interface{}) []byte` function to take an
+arbitrary object and return the Amino encoded bytes.

-Negative integers are encoded via twos-complement.
+## Byte Arrays

-Examples:
+The encoding of a byte array is simply the raw-bytes prefixed with the length of
+the array as a `UVarint` (what Protobuf calls a `Varint`).

-```go
-encode(uint8(6))    == [0x06]
-encode(uint32(6))   == [0x00, 0x00, 0x00, 0x06]
+For details on varints, see the [protobuf
+spec](https://developers.google.com/protocol-buffers/docs/encoding#varints).

-encode(int8(-6))    == [0xFA]
-encode(int32(-6))   == [0xFF, 0xFF, 0xFF, 0xFA]
+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.
+
+## Public Key Cryptography
+
+Tendermint uses Amino to distinguish between different types of private keys,
+public keys, and signatures. Additionally, for each public key, Tendermint
+defines an Address function that can be used as a more compact identifier in
+place of the public key. Here we list the concrete types, their names,
+and prefix bytes for public keys and signatures, as well as the address schemes
+for each PubKey. Note for brevity we don't
+include details of the private keys beyond their type and name, as they can be
+derrived the same way as the others using Amino.
+
+All registered objects are encoded by Amino using a 4-byte PrefixBytes that
+uniquely identifies the object and includes information about its underlying
+type. For details on how PrefixBytes are computed, see the [Amino
+spec](https://github.com/tendermint/go-amino#computing-the-prefix-and-disambiguation-bytes).
+
+In what follows, we provide the type names and prefix bytes directly.
+Notice that when encoding byte-arrays, the length of the byte-array is appended
+to the PrefixBytes. Thus the encoding of a byte array becomes `<PrefixBytes>
+<Length> <ByteArray>`
+
+(NOTE: the remainder of this section on Public Key Cryptography can be generated
+from [this script](./scripts/crypto.go))
+
+### PubKeyEd25519
+
+```
+// Name: tendermint/PubKeyEd25519
+// PrefixBytes: 0x1624DE62
+// Length: 0x20
+// Notes: raw 32-byte Ed25519 pubkey
+type PubKeyEd25519 [32]byte
+
+func (pubkey PubKeyEd25519) Address() []byte {
+      // NOTE: hash of the Amino encoded bytes!
+        return RIPEMD160(AminoEncode(pubkey))
+}
 ```

-### Variable Length Integers
+For example, the 32-byte Ed25519 pubkey
+`CCACD52F9B29D04393F01CD9AF6535455668115641F3D8BAEFD2295F24BAF60E` would be
+encoded as
+`1624DE6220CCACD52F9B29D04393F01CD9AF6535455668115641F3D8BAEFD2295F24BAF60E`.

-Variable length integers are encoded as length-prefixed Big-Endian integers.
-The length-prefix consists of a single byte and corresponds to the length of the encoded integer.
+The address would then be
+`RIPEMD160(0x1624DE6220CCACD52F9B29D04393F01CD9AF6535455668115641F3D8BAEFD2295F24BAF60E)`
+or `430FF75BAF1EC4B0D51BB3EEC2955479D0071605`

-Negative integers are encoded by flipping the leading bit of the length-prefix to a `1`.
+### SignatureEd25519

-Zero is encoded as `0x00`. It is not length-prefixed.
-
-Examples:
-
-```go
-encode(uint(6))     == [0x01, 0x06]
-encode(uint(70000)) == [0x03, 0x01, 0x11, 0x70]
-
-encode(int(-6))     == [0xF1, 0x06]
-encode(int(-70000)) == [0xF3, 0x01, 0x11, 0x70]
-
-encode(int(0))      == [0x00]
+```
+// Name: tendermint/SignatureKeyEd25519
+// PrefixBytes: 0x3DA1DB2A
+// Length: 0x40
+// Notes: raw 64-byte Ed25519 signature
+type SignatureEd25519 [64]byte
 ```

-### Strings
+For example, the 64-byte Ed25519 signature
+`1B6034A8ED149D3C94FDA13EC03B26CC0FB264D9B0E47D3FA3DEF9FCDE658E49C80B35F9BE74949356401B15B18FB817D6E54495AD1C4A8401B248466CB0DB0B`
+would be encoded as
+`3DA1DB2A401B6034A8ED149D3C94FDA13EC03B26CC0FB264D9B0E47D3FA3DEF9FCDE658E49C80B35F9BE74949356401B15B18FB817D6E54495AD1C4A8401B248466CB0DB0B`

-An encoded string is length-prefixed followed by the underlying bytes of the string.
-The length-prefix is itself encoded as an `int`.
+### PrivKeyEd25519

-The empty string is encoded as `0x00`. It is not length-prefixed.
-
-Examples:
-
-```go
-encode("")      == [0x00]
-encode("a")     == [0x01, 0x01, 0x61]
-encode("hello") == [0x01, 0x05, 0x68, 0x65, 0x6C, 0x6C, 0x6F]
-encode("¥")     == [0x01, 0x02, 0xC2, 0xA5]
+```
+// Name: tendermint/PrivKeyEd25519
+// Notes: raw 32-byte priv key concatenated to raw 32-byte pub key
+type PrivKeyEd25519 [64]byte
 ```

-### Arrays (fixed length)
+### PubKeySecp256k1

-An encoded fix-lengthed array is the concatenation of the encoding of its elements.
-There is no length-prefix.
+```
+// Name: tendermint/PubKeySecp256k1
+// PrefixBytes: 0xEB5AE982
+// Length: 0x21
+// Notes: OpenSSL compressed pubkey prefixed with 0x02 or 0x03
+type PubKeySecp256k1 [33]byte

-Examples:
-
-```go
-encode([4]int8{1, 2, 3, 4})     == [0x01, 0x02, 0x03, 0x04]
-encode([4]int16{1, 2, 3, 4})    == [0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04]
-encode([4]int{1, 2, 3, 4})      == [0x01, 0x01, 0x01, 0x02, 0x01, 0x03, 0x01, 0x04]
-encode([2]string{"abc", "efg"}) == [0x01, 0x03, 0x61, 0x62, 0x63, 0x01, 0x03, 0x65, 0x66, 0x67]
+func (pubkey PubKeySecp256k1) Address() []byte {
+      // NOTE: hash of the raw pubkey bytes (not Amino encoded!).
+        // Compatible with Bitcoin addresses.
+          return RIPEMD160(SHA256(pubkey[:]))
+}
 ```

-### Slices (variable length)
+For example, the 33-byte Secp256k1 pubkey
+`020BD40F225A57ED383B440CF073BC5539D0341F5767D2BF2D78406D00475A2EE9` would be
+encoded as
+`EB5AE98221020BD40F225A57ED383B440CF073BC5539D0341F5767D2BF2D78406D00475A2EE9`

-An encoded variable-length array is length-prefixed followed by the concatenation of the encoding of
-its elements.
-The length-prefix is itself encoded as an `int`.
+The address would then be
+`RIPEMD160(SHA256(0x020BD40F225A57ED383B440CF073BC5539D0341F5767D2BF2D78406D00475A2EE9))`
+or `0AE5BEE929ABE51BAD345DB925EEA652680783FC`

-An empty slice is encoded as `0x00`. It is not length-prefixed.
+### SignatureSecp256k1

-Examples:
-
-```go
-encode([]int8{})                == [0x00]
-encode([]int8{1, 2, 3, 4})      == [0x01, 0x04, 0x01, 0x02, 0x03, 0x04]
-encode([]int16{1, 2, 3, 4})     == [0x01, 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04]
-encode([]int{1, 2, 3, 4})       == [0x01, 0x04, 0x01, 0x01, 0x01, 0x02, 0x01, 0x03, 0x01, 0x4]
-encode([]string{"abc", "efg"})  == [0x01, 0x02, 0x01, 0x03, 0x61, 0x62, 0x63, 0x01, 0x03, 0x65, 0x66, 0x67]
 ```
+// Name: tendermint/SignatureKeySecp256k1
+// PrefixBytes: 0x16E1FEEA
+// Length: Variable
+// Encoding prefix: Variable
+// Notes: raw bytes of the Secp256k1 signature
+type SignatureSecp256k1 []byte
+```
+
+For example, the Secp256k1 signature
+`304402201CD4B8C764D2FD8AF23ECFE6666CA8A53886D47754D951295D2D311E1FEA33BF02201E0F906BB1CF2C30EAACFFB032A7129358AFF96B9F79B06ACFFB18AC90C2ADD7`
+would be encoded as
+`16E1FEEA46304402201CD4B8C764D2FD8AF23ECFE6666CA8A53886D47754D951295D2D311E1FEA33BF02201E0F906BB1CF2C30EAACFFB032A7129358AFF96B9F79B06ACFFB18AC90C2ADD7`
+
+### PrivKeySecp256k1
+
+```
+// Name: tendermint/PrivKeySecp256k1
+// Notes: raw 32-byte priv key
+type PrivKeySecp256k1 [32]byte
+```
+
+## Other Common Types

 ### BitArray

-BitArray is encoded as an `int` of the number of bits, and with an array of `uint64` to encode
-value of each array element.
+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`).

 ```go
 type BitArray struct {
@ -109,36 +166,35 @@ type BitArray struct {
 }
 ```

-### Time
+This type is easily encoded directly by Amino.

-Time is encoded as an `int64` of the number of nanoseconds since January 1, 1970,
-rounded to the nearest millisecond.
+Note BitArray receives a special JSON encoding in the form of `x` and `_`
+representing `1` and `0`. Ie. the BitArray `10110` would be JSON encoded as
+`"x_xx_"`

-Times before then are invalid.
+### Part

-Examples:
+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 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
-encode(time.Time("Jan 1 00:00:00 UTC 1970"))            == [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
-encode(time.Time("Jan 1 00:00:01 UTC 1970"))            == [0x00, 0x00, 0x00, 0x00, 0x3B, 0x9A, 0xCA, 0x00] // 1,000,000,000 ns
-encode(time.Time("Mon Jan 2 15:04:05 -0700 MST 2006"))  == [0x0F, 0xC4, 0xBB, 0xC1, 0x53, 0x03, 0x12, 0x00]
+type Part struct {
+    Index int
+    Bytes byte[]
+    Proof byte[]
+}
 ```

-### Structs
+### MakeParts

-An encoded struct is the concatenation of the encoding of its elements.
-There is no length-prefix.
-
-Examples:
+Encode an object using Amino and slice it into parts.

 ```go
-type MyStruct struct{
-    A int
-    B string
-    C time.Time
-}
-encode(MyStruct{4, "hello", time.Time("Mon Jan 2 15:04:05 -0700 MST 2006")}) ==
-    [0x01, 0x04, 0x01, 0x05, 0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x0F, 0xC4, 0xBB, 0xC1, 0x53, 0x03, 0x12, 0x00]
+func MakeParts(obj interface{}, partSize int) []Part
 ```

 ## Merkle Trees
@ -147,6 +203,8 @@ Simple Merkle trees are used in numerous places in Tendermint to compute a crypt

 RIPEMD160 is always used as the hashing function.

+### Simple Merkle Root
+
 The function `SimpleMerkleRoot` is a simple recursive function defined as follows:

 ```go
@ -159,20 +217,96 @@ func SimpleMerkleRoot(hashes [][]byte) []byte{
    default:
        left := SimpleMerkleRoot(hashes[:(len(hashes)+1)/2])
        right := SimpleMerkleRoot(hashes[(len(hashes)+1)/2:])
-        return RIPEMD160(append(left, right))
+        return SimpleConcatHash(left, right)
    }
 }
+
+func SimpleConcatHash(left, right []byte) []byte{
+    left = encodeByteSlice(left)
+    right = encodeByteSlice(right)
+    return RIPEMD160 (append(left, right))
+}
 ```

-Note: we abuse notion and call `SimpleMerkleRoot` with arguments of type `struct` or type `[]struct`.
+Note that the leaves are Amino encoded as byte-arrays (ie. simple Uvarint length
+prefix) before being concatenated together and hashed.
+
+Note: we will abuse notion and invoke `SimpleMerkleRoot` with arguments of type `struct` or type `[]struct`.
 For `struct` arguments, we compute a `[][]byte` by sorting elements of the `struct` according to
 field name and then hashing them.
 For `[]struct` arguments, we compute a `[][]byte` by hashing the individual `struct` elements.

-## JSON (TMJSON)
+### Simple Merkle Proof

-Signed messages (eg. votes, proposals) in the consensus are encoded in TMJSON, rather than TMBIN.
-TMJSON is JSON where `[]byte` are encoded as uppercase hex, rather than base64.
+Proof that a leaf is in a Merkle tree consists of a simple structure:
+
+
+```
+type SimpleProof struct {
+        Aunts [][]byte
+}
+```
+
+Which is verified using the following:
+
+```
+func (proof SimpleProof) Verify(index, total int, leafHash, rootHash []byte) bool {
+	computedHash := computeHashFromAunts(index, total, leafHash, proof.Aunts)
+    return computedHash == rootHash
+}
+
+func computeHashFromAunts(index, total int, leafHash []byte, innerHashes [][]byte) []byte{
+	assert(index < total && index >= 0 && total > 0)
+
+	if total == 1{
+		assert(len(proof.Aunts) == 0)
+		return leafHash
+	}
+
+	assert(len(innerHashes) > 0)
+
+	numLeft := (total + 1) / 2
+	if index < numLeft {
+		leftHash := computeHashFromAunts(index, numLeft, leafHash, innerHashes[:len(innerHashes)-1])
+		assert(leftHash != nil)
+		return SimpleHashFromTwoHashes(leftHash, innerHashes[len(innerHashes)-1])
+	}
+	rightHash := computeHashFromAunts(index-numLeft, total-numLeft, leafHash, innerHashes[:len(innerHashes)-1])
+	assert(rightHash != nil)
+	return SimpleHashFromTwoHashes(innerHashes[len(innerHashes)-1], rightHash)
+}
+```
+
+## JSON
+
+### Amino
+
+TODO: improve this
+
+Amino also supports JSON encoding - registered types are simply encoded as:
+
+```
+{
+  "type": "<DisfixBytes>",
+  "value": <JSON>
+}
+
+For instance, an ED25519 PubKey would look like:
+
+```
+{
+  "type": "AC26791624DE60",
+  "value": "uZ4h63OFWuQ36ZZ4Bd6NF+/w9fWUwrOncrQsackrsTk="
+}
+```
+
+Where the `"value"` is the base64 encoding of the raw pubkey bytes, and the
+`"type"` is the full disfix bytes for Ed25519 pubkeys.
+
+
+### Signed Messages
+
+Signed messages (eg. votes, proposals) in the consensus are encoded using Amino-JSON, rather than in the standard binary format.

 When signing, the elements of a message are sorted by key and the sorted message is embedded in an
 outer JSON that includes a `chain_id` field.
@ -184,23 +318,3 @@ like:
 ```

 Note how the fields within each level are sorted.
-
-## Other
-
-### MakeParts
-
-Encode an object using TMBIN and slice it into parts.
-
-```go
-MakeParts(object, partSize)
-```
-
-### Part
-
-```go
-type Part struct {
-    Index int
-    Bytes byte[]
-    Proof byte[]
-}
-```
--- a/docs/specification/new-spec/light-client.md
+++ b/docs/specification/new-spec/light-client.md
@ -0,0 +1,114 @@
+# Light client
+
+A light client is a process that connects to the Tendermint Full Node(s) and then tries to verify the Merkle proofs 
+about the blockchain application. In this document we describe mechanisms that ensures that the Tendermint light client 
+has the same level of security as Full Node processes (without being itself a Full Node). 
+
+To be able to validate a Merkle proof, a light client needs to validate the blockchain header that contains the root app hash. 
+Validating a blockchain header in Tendermint consists in verifying that the header is committed (signed) by >2/3 of the 
+voting power of the corresponding validator set. As the validator set is a dynamic set (it is changing), one of the 
+core functionality of the light client is updating the current validator set, that is then used to verify the 
+blockchain header, and further the corresponding Merkle proofs. 
+
+For the purpose of this light client specification, we assume that the Tendermint Full Node exposes the following functions over
+Tendermint RPC:
+
+```golang
+Header(height int64) (SignedHeader, error) // returns signed header for the given height
+Validators(height int64) (ResultValidators, error) // returns validator set for the given height
+LastHeader(valSetNumber int64) (SignedHeader, error)   // returns last header signed by the validator set with the given validator set number
+
+type SignedHeader struct {
+    Header        Header 
+    Commit        Commit
+    ValSetNumber  int64 
+}
+
+type ResultValidators struct {
+    BlockHeight   int64              
+    Validators    []Validator 
+    // time the current validator set is initialised, i.e, time of the last validator change before header BlockHeight 
+    ValSetTime    int64               
+}
+```
+
+We assume that Tendermint keeps track of the validator set changes and that each time a validator set is changed it is 
+being assigned the next sequence number. We can call this number the validator set sequence number. Tendermint also remembers 
+the Time from the header when the next validator set is initialised (starts to be in power), and we refer to this time
+as validator set init time.
+Furthermore, we assume that each validator set change is signed (committed) by the current validator set. More precisely,
+given a block `H` that contains transactions that are modifying the current validator set, the Merkle root hash of the next 
+validator set (modified based on transactions from block H) will be in block `H+1` (and signed by the current validator 
+set), and then starting from the block `H+2`, it will be signed by the next validator set.    
+
+Note that the real Tendermint RPC API is slightly different (for example, response messages contain more data and function 
+names are slightly different); we shortened (and modified) it for the purpose of this document to make the spec more 
+clear and simple. Furthermore, note that in case of the third function, the returned header has `ValSetNumber` equals to 
+`valSetNumber+1`.    
+
+
+Locally, light client manages the following state:
+
+```golang
+valSet        []Validator    // current validator set (last known and verified validator set) 
+valSetNumber  int64          // sequence number of the current validator set 
+valSetHash    []byte         // hash of the current validator set
+valSetTime    int64          // time when the current validator set is initialised  
+```
+
+The light client is initialised with the trusted validator set, for example based on the known validator set hash,
+validator set sequence number and the validator set init time.
+The core of the light client logic is captured by the VerifyAndUpdate function that is used to 1) verify if the given header is valid,
+and 2) update the validator set (when the given header is valid and it is more recent than the seen headers). 
+
+```golang
+VerifyAndUpdate(signedHeader SignedHeader):
+  assertThat signedHeader.valSetNumber >= valSetNumber  
+  if isValid(signedHeader) and signedHeader.Header.Time <= valSetTime + UNBONDING_PERIOD then
+    setValidatorSet(signedHeader)
+    return true
+  else
+    updateValidatorSet(signedHeader.ValSetNumber)
+    return VerifyAndUpdate(signedHeader)
+
+isValid(signedHeader SignedHeader):
+  valSetOfTheHeader = Validators(signedHeader.Header.Height)
+  assertThat Hash(valSetOfTheHeader) == signedHeader.Header.ValSetHash
+  assertThat signedHeader is passing basic validation
+  if votingPower(signedHeader.Commit) > 2/3 * votingPower(valSetOfTheHeader) then return true
+  else 
+    return false
+
+setValidatorSet(signedHeader SignedHeader):
+  nextValSet = Validators(signedHeader.Header.Height)
+  assertThat Hash(nextValSet) == signedHeader.Header.ValidatorsHash
+  valSet = nextValSet.Validators
+  valSetHash = signedHeader.Header.ValidatorsHash
+  valSetNumber = signedHeader.ValSetNumber
+  valSetTime = nextValSet.ValSetTime  
+
+votingPower(commit Commit):
+  votingPower = 0
+  for each precommit in commit.Precommits do:
+    if precommit.ValidatorAddress is in valSet and signature of the precommit verifies then
+      votingPower += valSet[precommit.ValidatorAddress].VotingPower
+  return votingPower
+
+votingPower(validatorSet []Validator):
+  for each validator in validatorSet do:
+    votingPower += validator.VotingPower    
+  return votingPower
+  
+updateValidatorSet(valSetNumberOfTheHeader):
+  while valSetNumber != valSetNumberOfTheHeader do
+    signedHeader = LastHeader(valSetNumber)
+    if isValid(signedHeader) then
+      setValidatorSet(signedHeader)
+    else return error
+  return
+```
+
+Note that in the logic above we assume that the light client will always go upward with respect to header verifications,
+i.e., that it will always be used to verify more recent headers. In case a light client needs to be used to verify older
+headers (go backward) the same mechanisms and similar logic can be used. In case a call to the FullNode or subsequent 
+checks fail, a light client need to implement some recovery strategy, for example connecting to other FullNode.  
--- a/docs/specification/new-spec/p2p/peer.md
+++ b/docs/specification/new-spec/p2p/peer.md
@ -83,7 +83,7 @@ The Tendermint Version Handshake allows the peers to exchange their NodeInfo:

 ```golang
 type NodeInfo struct {
-  PubKey     crypto.PubKey
+  ID         p2p.ID
  Moniker    string
  Network    string
  RemoteAddr string
@ -95,7 +95,7 @@ type NodeInfo struct {
 ```

 The connection is disconnected if:
- `peer.NodeInfo.PubKey != peer.PubKey`
+- `peer.NodeInfo.ID` is not equal `peerConn.ID`
 - `peer.NodeInfo.Version` is not formatted as `X.X.X` where X are integers known as Major, Minor, and Revision
 - `peer.NodeInfo.Version` Major is not the same as ours
 - `peer.NodeInfo.Version` Minor is not the same as ours
--- a/docs/specification/new-spec/pre-amino.md
+++ b/docs/specification/new-spec/pre-amino.md
@ -0,0 +1,246 @@
+# Tendermint Encoding (Pre-Amino)
+
+## PubKeys and Addresses
+
+PubKeys are prefixed with a type-byte, followed by the raw bytes of the public
+key.
+
+Two keys are supported with the following type bytes:
+
+```
+TypeByteEd25519 = 0x1
+TypeByteSecp256k1 = 0x2
+```
+
+```
+// TypeByte: 0x1
+type PubKeyEd25519 [32]byte
+
+func (pub PubKeyEd25519) Encode() []byte {
+    return 0x1 | pub
+}
+
+func (pub PubKeyEd25519) Address() []byte {
+    // NOTE: the length (0x0120) is also included
+    return RIPEMD160(0x1 | 0x0120 | pub)
+}
+
+// TypeByte: 0x2
+// NOTE: OpenSSL compressed pubkey (x-cord with 0x2 or 0x3)
+type PubKeySecp256k1 [33]byte
+
+func (pub PubKeySecp256k1) Encode() []byte {
+    return 0x2 | pub
+}
+
+func (pub PubKeySecp256k1) Address() []byte {
+    return RIPEMD160(SHA256(pub))
+}
+```
+
+See https://github.com/tendermint/go-crypto/blob/v0.5.0/pub_key.go for more.
+
+## Binary Serialization (go-wire)
+
+Tendermint aims to encode data structures in a manner similar to how the corresponding Go structs
+are laid out in memory.
+Variable length items are length-prefixed.
+While the encoding was inspired by Go, it is easily implemented in other languages as well, given its intuitive design.
+
+XXX: This is changing to use real varints and 4-byte-prefixes.
+See https://github.com/tendermint/go-wire/tree/sdk2.
+
+### Fixed Length Integers
+
+Fixed length integers are encoded in Big-Endian using the specified number of bytes.
+So `uint8` and `int8` use one byte, `uint16` and `int16` use two bytes,
+`uint32` and `int32` use 3 bytes, and `uint64` and `int64` use 4 bytes.
+
+Negative integers are encoded via twos-complement.
+
+Examples:
+
+```go
+encode(uint8(6))    == [0x06]
+encode(uint32(6))   == [0x00, 0x00, 0x00, 0x06]
+
+encode(int8(-6))    == [0xFA]
+encode(int32(-6))   == [0xFF, 0xFF, 0xFF, 0xFA]
+```
+
+### Variable Length Integers
+
+Variable length integers are encoded as length-prefixed Big-Endian integers.
+The length-prefix consists of a single byte and corresponds to the length of the encoded integer.
+
+Negative integers are encoded by flipping the leading bit of the length-prefix to a `1`.
+
+Zero is encoded as `0x00`. It is not length-prefixed.
+
+Examples:
+
+```go
+encode(uint(6))     == [0x01, 0x06]
+encode(uint(70000)) == [0x03, 0x01, 0x11, 0x70]
+
+encode(int(-6))     == [0xF1, 0x06]
+encode(int(-70000)) == [0xF3, 0x01, 0x11, 0x70]
+
+encode(int(0))      == [0x00]
+```
+
+### Strings
+
+An encoded string is length-prefixed followed by the underlying bytes of the string.
+The length-prefix is itself encoded as an `int`.
+
+The empty string is encoded as `0x00`. It is not length-prefixed.
+
+Examples:
+
+```go
+encode("")      == [0x00]
+encode("a")     == [0x01, 0x01, 0x61]
+encode("hello") == [0x01, 0x05, 0x68, 0x65, 0x6C, 0x6C, 0x6F]
+encode("¥")     == [0x01, 0x02, 0xC2, 0xA5]
+```
+
+### Arrays (fixed length)
+
+An encoded fix-lengthed array is the concatenation of the encoding of its elements.
+There is no length-prefix.
+
+Examples:
+
+```go
+encode([4]int8{1, 2, 3, 4})     == [0x01, 0x02, 0x03, 0x04]
+encode([4]int16{1, 2, 3, 4})    == [0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04]
+encode([4]int{1, 2, 3, 4})      == [0x01, 0x01, 0x01, 0x02, 0x01, 0x03, 0x01, 0x04]
+encode([2]string{"abc", "efg"}) == [0x01, 0x03, 0x61, 0x62, 0x63, 0x01, 0x03, 0x65, 0x66, 0x67]
+```
+
+### Slices (variable length)
+
+An encoded variable-length array is length-prefixed followed by the concatenation of the encoding of
+its elements.
+The length-prefix is itself encoded as an `int`.
+
+An empty slice is encoded as `0x00`. It is not length-prefixed.
+
+Examples:
+
+```go
+encode([]int8{})                == [0x00]
+encode([]int8{1, 2, 3, 4})      == [0x01, 0x04, 0x01, 0x02, 0x03, 0x04]
+encode([]int16{1, 2, 3, 4})     == [0x01, 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04]
+encode([]int{1, 2, 3, 4})       == [0x01, 0x04, 0x01, 0x01, 0x01, 0x02, 0x01, 0x03, 0x01, 0x4]
+encode([]string{"abc", "efg"})  == [0x01, 0x02, 0x01, 0x03, 0x61, 0x62, 0x63, 0x01, 0x03, 0x65, 0x66, 0x67]
+```
+
+### BitArray
+
+BitArray is encoded as an `int` of the number of bits, and with an array of `uint64` to encode
+value of each array element.
+
+```go
+type BitArray struct {
+    Bits  int
+    Elems []uint64
+}
+```
+
+### Time
+
+Time is encoded as an `int64` of the number of nanoseconds since January 1, 1970,
+rounded to the nearest millisecond.
+
+Times before then are invalid.
+
+Examples:
+
+```go
+encode(time.Time("Jan 1 00:00:00 UTC 1970"))            == [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
+encode(time.Time("Jan 1 00:00:01 UTC 1970"))            == [0x00, 0x00, 0x00, 0x00, 0x3B, 0x9A, 0xCA, 0x00] // 1,000,000,000 ns
+encode(time.Time("Mon Jan 2 15:04:05 -0700 MST 2006"))  == [0x0F, 0xC4, 0xBB, 0xC1, 0x53, 0x03, 0x12, 0x00]
+```
+
+### Structs
+
+An encoded struct is the concatenation of the encoding of its elements.
+There is no length-prefix.
+
+Examples:
+
+```go
+type MyStruct struct{
+    A int
+    B string
+    C time.Time
+}
+encode(MyStruct{4, "hello", time.Time("Mon Jan 2 15:04:05 -0700 MST 2006")}) ==
+    [0x01, 0x04, 0x01, 0x05, 0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x0F, 0xC4, 0xBB, 0xC1, 0x53, 0x03, 0x12, 0x00]
+```
+
+## Merkle Trees
+
+Simple Merkle trees are used in numerous places in Tendermint to compute a cryptographic digest of a data structure.
+
+RIPEMD160 is always used as the hashing function.
+
+The function `SimpleMerkleRoot` is a simple recursive function defined as follows:
+
+```go
+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 RIPEMD160(append(left, right))
+    }
+}
+```
+
+Note: we abuse notion and call `SimpleMerkleRoot` with arguments of type `struct` or type `[]struct`.
+For `struct` arguments, we compute a `[][]byte` by sorting elements of the `struct` according to
+field name and then hashing them.
+For `[]struct` arguments, we compute a `[][]byte` by hashing the individual `struct` elements.
+
+## JSON (TMJSON)
+
+Signed messages (eg. votes, proposals) in the consensus are encoded in TMJSON, rather than TMBIN.
+TMJSON is JSON where `[]byte` are encoded as uppercase hex, rather than base64.
+
+When signing, the elements of a message are sorted by key and the sorted message is embedded in an
+outer JSON that includes a `chain_id` field.
+We call this encoding the CanonicalSignBytes. For instance, CanonicalSignBytes for a vote would look
+like:
+
+```json
+{"chain_id":"my-chain-id","vote":{"block_id":{"hash":DEADBEEF,"parts":{"hash":BEEFDEAD,"total":3}},"height":3,"round":2,"timestamp":1234567890, "type":2}
+```
+
+Note how the fields within each level are sorted.
+
+## Other
+
+### MakeParts
+
+Encode an object using TMBIN and slice it into parts.
+
+```go
+MakeParts(object, partSize)
+```
+
+### Part
+
+```go
+type Part struct {
+    Index int
+    Bytes byte[]
+    Proof byte[]
+}
+```
--- a/docs/specification/new-spec/scripts/crypto.go
+++ b/docs/specification/new-spec/scripts/crypto.go
@ -0,0 +1,125 @@
+package main
+
+import (
+	"fmt"
+
+	crypto "github.com/tendermint/go-crypto"
+)
+
+// SECRET
+var SECRET = []byte("some secret")
+
+func printEd() {
+	priv := crypto.GenPrivKeyEd25519FromSecret(SECRET)
+	pub := priv.PubKey().(crypto.PubKeyEd25519)
+	sig := priv.Sign([]byte("hello")).(crypto.SignatureEd25519)
+
+	name := "tendermint/PubKeyEd25519"
+	length := len(pub[:])
+
+	fmt.Println("### PubKeyEd25519")
+	fmt.Println("")
+	fmt.Println("```")
+	fmt.Printf("// Name: %s\n", name)
+	fmt.Printf("// PrefixBytes: 0x%X \n", pub.Bytes()[:4])
+	fmt.Printf("// Length: 0x%X \n", length)
+	fmt.Println("// Notes: raw 32-byte Ed25519 pubkey")
+	fmt.Println("type PubKeyEd25519 [32]byte")
+	fmt.Println("")
+	fmt.Println(`func (pubkey PubKeyEd25519) Address() []byte {
+  // NOTE: hash of the Amino encoded bytes!
+  return RIPEMD160(AminoEncode(pubkey))
+}`)
+	fmt.Println("```")
+	fmt.Println("")
+	fmt.Printf("For example, the 32-byte Ed25519 pubkey `%X` would be encoded as `%X`.\n\n", pub[:], pub.Bytes())
+	fmt.Printf("The address would then be `RIPEMD160(0x%X)` or `%X`\n", pub.Bytes(), pub.Address())
+	fmt.Println("")
+
+	name = "tendermint/SignatureKeyEd25519"
+	length = len(sig[:])
+
+	fmt.Println("### SignatureEd25519")
+	fmt.Println("")
+	fmt.Println("```")
+	fmt.Printf("// Name: %s\n", name)
+	fmt.Printf("// PrefixBytes: 0x%X \n", sig.Bytes()[:4])
+	fmt.Printf("// Length: 0x%X \n", length)
+	fmt.Println("// Notes: raw 64-byte Ed25519 signature")
+	fmt.Println("type SignatureEd25519 [64]byte")
+	fmt.Println("```")
+	fmt.Println("")
+	fmt.Printf("For example, the 64-byte Ed25519 signature `%X` would be encoded as `%X`\n", sig[:], sig.Bytes())
+	fmt.Println("")
+
+	name = "tendermint/PrivKeyEd25519"
+
+	fmt.Println("### PrivKeyEd25519")
+	fmt.Println("")
+	fmt.Println("```")
+	fmt.Println("// Name:", name)
+	fmt.Println("// Notes: raw 32-byte priv key concatenated to raw 32-byte pub key")
+	fmt.Println("type PrivKeyEd25519 [64]byte")
+	fmt.Println("```")
+}
+
+func printSecp() {
+	priv := crypto.GenPrivKeySecp256k1FromSecret(SECRET)
+	pub := priv.PubKey().(crypto.PubKeySecp256k1)
+	sig := priv.Sign([]byte("hello")).(crypto.SignatureSecp256k1)
+
+	name := "tendermint/PubKeySecp256k1"
+	length := len(pub[:])
+
+	fmt.Println("### PubKeySecp256k1")
+	fmt.Println("")
+	fmt.Println("```")
+	fmt.Printf("// Name: %s\n", name)
+	fmt.Printf("// PrefixBytes: 0x%X \n", pub.Bytes()[:4])
+	fmt.Printf("// Length: 0x%X \n", length)
+	fmt.Println("// Notes: OpenSSL compressed pubkey prefixed with 0x02 or 0x03")
+	fmt.Println("type PubKeySecp256k1 [33]byte")
+	fmt.Println("")
+	fmt.Println(`func (pubkey PubKeySecp256k1) Address() []byte {
+  // NOTE: hash of the raw pubkey bytes (not Amino encoded!).
+  // Compatible with Bitcoin addresses.
+  return RIPEMD160(SHA256(pubkey[:]))
+}`)
+	fmt.Println("```")
+	fmt.Println("")
+	fmt.Printf("For example, the 33-byte Secp256k1 pubkey `%X` would be encoded as `%X`\n\n", pub[:], pub.Bytes())
+	fmt.Printf("The address would then be `RIPEMD160(SHA256(0x%X))` or `%X`\n", pub[:], pub.Address())
+	fmt.Println("")
+
+	name = "tendermint/SignatureKeySecp256k1"
+
+	fmt.Println("### SignatureSecp256k1")
+	fmt.Println("")
+	fmt.Println("```")
+	fmt.Printf("// Name: %s\n", name)
+	fmt.Printf("// PrefixBytes: 0x%X \n", sig.Bytes()[:4])
+	fmt.Printf("// Length: Variable\n")
+	fmt.Printf("// Encoding prefix: Variable\n")
+	fmt.Println("// Notes: raw bytes of the Secp256k1 signature")
+	fmt.Println("type SignatureSecp256k1 []byte")
+	fmt.Println("```")
+	fmt.Println("")
+	fmt.Printf("For example, the Secp256k1 signature `%X` would be encoded as `%X`\n", []byte(sig[:]), sig.Bytes())
+	fmt.Println("")
+
+	name = "tendermint/PrivKeySecp256k1"
+
+	fmt.Println("### PrivKeySecp256k1")
+	fmt.Println("")
+	fmt.Println("```")
+	fmt.Println("// Name:", name)
+	fmt.Println("// Notes: raw 32-byte priv key")
+	fmt.Println("type PrivKeySecp256k1 [32]byte")
+	fmt.Println("```")
+}
+
+func main() {
+	printEd()
+	fmt.Println("")
+	printSecp()
+}
--- a/docs/specification/new-spec/state.md
+++ b/docs/specification/new-spec/state.md
@ -74,9 +74,6 @@ func TotalVotingPower(vals []Validators) int64{
 }
 ```

-### PubKey
-
-TODO:

 ### ConsensusParams

--- a/docs/specification/new-spec/wire.go
+++ b/docs/specification/new-spec/wire.go
@ -1,80 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"time"
-
-	wire "github.com/tendermint/go-wire"
-)
-
-func main() {
-
-	encode(uint8(6))
-	encode(uint32(6))
-	encode(int8(-6))
-	encode(int32(-6))
-	Break()
-	encode(uint(6))
-	encode(uint(70000))
-	encode(int(0))
-	encode(int(-6))
-	encode(int(-70000))
-	Break()
-	encode("")
-	encode("a")
-	encode("hello")
-	encode("¥")
-	Break()
-	encode([4]int8{1, 2, 3, 4})
-	encode([4]int16{1, 2, 3, 4})
-	encode([4]int{1, 2, 3, 4})
-	encode([2]string{"abc", "efg"})
-	Break()
-	encode([]int8{})
-	encode([]int8{1, 2, 3, 4})
-	encode([]int16{1, 2, 3, 4})
-	encode([]int{1, 2, 3, 4})
-	encode([]string{"abc", "efg"})
-	Break()
-
-	timeFmt := "Mon Jan 2 15:04:05 -0700 MST 2006"
-	t1, _ := time.Parse(timeFmt, timeFmt)
-	n := (t1.UnixNano() / 1000000.) * 1000000
-	encode(n)
-	encode(t1)
-
-	t2, _ := time.Parse(timeFmt, "Thu Jan 1 00:00:00 -0000 UTC 1970")
-	encode(t2)
-
-	t2, _ = time.Parse(timeFmt, "Thu Jan 1 00:00:01 -0000 UTC 1970")
-	fmt.Println("N", t2.UnixNano())
-	encode(t2)
-	Break()
-	encode(struct {
-		A int
-		B string
-		C time.Time
-	}{
-		4,
-		"hello",
-		t1,
-	})
-}
-
-func encode(i interface{}) {
-	Println(wire.BinaryBytes(i))
-
-}
-
-func Println(b []byte) {
-	s := "["
-	for _, x := range b {
-		s += fmt.Sprintf("0x%.2X, ", x)
-	}
-	s = s[:len(s)-2] + "]"
-	fmt.Println(s)
-}
-
-func Break() {
-	fmt.Println("------")
-}
--- a/docs/specification/secure-p2p.rst
+++ b/docs/specification/secure-p2p.rst
@ -62,6 +62,13 @@ such as the Web-of-Trust or Certificate Authorities. In our case, we can
 use the blockchain itself as a certificate authority to ensure that we
 are connected to at least one validator.

+Config
+------
+
+Authenticated encryption is enabled by default. If you wish to use another
+authentication scheme or your peers are connected via VPN, you can turn it off
+by setting ``auth_enc`` to ``false`` in the config file.
+
 Additional Reading
 ------------------

--- a/docs/using-tendermint.rst
+++ b/docs/using-tendermint.rst
@ -74,20 +74,17 @@ RPC server, for example:

    curl http://localhost:46657/broadcast_tx_commit?tx=\"abcd\"

-For handling responses, we recommend you `install the jsonpp
-tool <http://jmhodges.github.io/jsonpp/>`__ to pretty print the JSON.
-
 We can see the chain's status at the ``/status`` end-point:

 ::

-    curl http://localhost:46657/status |  jsonpp
+    curl http://localhost:46657/status | json_pp

 and the ``latest_app_hash`` in particular:

 ::

-    curl http://localhost:46657/status |  jsonpp | grep app_hash
+    curl http://localhost:46657/status | json_pp | grep latest_app_hash

 Visit http://localhost:46657 in your browser to see the list of other
 endpoints. Some take no arguments (like ``/status``), while others
@ -185,7 +182,7 @@ once per second, it is possible to disable empty blocks or set a block creation
 interval. In the former case, blocks will be created when there are new
 transactions or when the AppHash changes.

-To configure Tendermint to not produce empty blocks unless there are 
+To configure Tendermint to not produce empty blocks unless there are
 transactions or the app hash changes, run Tendermint with this additional flag:

 ::
@ -260,19 +257,19 @@ When ``tendermint init`` is run, both a ``genesis.json`` and
 ::

    {
-        "app_hash": "",
-        "chain_id": "test-chain-HZw6TB",
-        "genesis_time": "0001-01-01T00:00:00.000Z",
-        "validators": [
-            {
-                "power": 10,
-                "name": "",
-                "pub_key": [
-                    1,
-                    "5770B4DD55B3E08B7F5711C48B516347D8C33F47C30C226315D21AA64E0DFF2E"
-                ]
-            }
-        ]
+      "validators" : [
+        {
+          "pub_key" : {
+            "value" : "h3hk+QE8c6QLTySp8TcfzclJw/BG79ziGB/pIA+DfPE=",
+            "type" : "AC26791624DE60"
+          },
+          "power" : 10,
+          "name" : ""
+        }
+      ],
+      "app_hash" : "",
+      "chain_id" : "test-chain-rDlYSN",
+      "genesis_time" : "0001-01-01T00:00:00Z"
    }

 And the ``priv_validator.json``:
@ -280,20 +277,18 @@ And the ``priv_validator.json``:
 ::

    {
-        "address": "4F4D895F882A18E1D1FC608D102601DA8D3570E5",
-        "last_height": 0,
-        "last_round": 0,
-        "last_signature": null,
-        "last_signbytes": "",
-        "last_step": 0,
-        "priv_key": [
-            1,
-            "F9FA3CD435BDAE54D0BCA8F1BC289D718C23D855C6DB21E8543F5E4F457E62805770B4DD55B3E08B7F5711C48B516347D8C33F47C30C226315D21AA64E0DFF2E"
-        ],
-        "pub_key": [
-            1,
-            "5770B4DD55B3E08B7F5711C48B516347D8C33F47C30C226315D21AA64E0DFF2E"
-        ]
+      "last_step" : 0,
+      "last_round" : 0,
+      "address" : "B788DEDE4F50AD8BC9462DE76741CCAFF87D51E2",
+      "pub_key" : {
+        "value" : "h3hk+QE8c6QLTySp8TcfzclJw/BG79ziGB/pIA+DfPE=",
+        "type" : "AC26791624DE60"
+      },
+      "last_height" : 0,
+      "priv_key" : {
+        "value" : "JPivl82x+LfVkp8i3ztoTjY6c6GJ4pBxQexErOCyhwqHeGT5ATxzpAtPJKnxNx/NyUnD8Ebv3OIYH+kgD4N88Q==",
+        "type" : "954568A3288910"
+      }
    }

 The ``priv_validator.json`` actually contains a private key, and should
@ -334,14 +329,14 @@ For instance,

 ::

-    tendermint node --p2p.seeds "1.2.3.4:46656,5.6.7.8:46656"
+    tendermint node --p2p.seeds "f9baeaa15fedf5e1ef7448dd60f46c01f1a9e9c4@1.2.3.4:46656,0491d373a8e0fcf1023aaf18c51d6a1d0d4f31bd@5.6.7.8:46656"

 Alternatively, you can use the ``/dial_seeds`` endpoint of the RPC to
 specify seeds for a running node to connect to:

 ::

-    curl 'localhost:46657/dial_seeds?seeds=\["1.2.3.4:46656","5.6.7.8:46656"\]'
+    curl 'localhost:46657/dial_seeds?seeds=\["f9baeaa15fedf5e1ef7448dd60f46c01f1a9e9c4@1.2.3.4:46656","0491d373a8e0fcf1023aaf18c51d6a1d0d4f31bd@5.6.7.8:46656"\]'

 Note, if the peer-exchange protocol (PEX) is enabled (default), you should not
 normally need seeds after the first start. Peers will be gossipping about known
@ -355,8 +350,8 @@ core instance.

 ::

-    tendermint node --p2p.persistent_peers "10.11.12.13:46656,10.11.12.14:46656"
-    curl 'localhost:46657/dial_peers?persistent=true&peers=\["1.2.3.4:46656","5.6.7.8:46656"\]'
+    tendermint node --p2p.persistent_peers "429fcf25974313b95673f58d77eacdd434402665@10.11.12.13:46656,96663a3dd0d7b9d17d4c8211b191af259621c693@10.11.12.14:46656"
+    curl 'localhost:46657/dial_peers?persistent=true&peers=\["429fcf25974313b95673f58d77eacdd434402665@10.11.12.13:46656","96663a3dd0d7b9d17d4c8211b191af259621c693@10.11.12.14:46656"\]'

 Adding a Non-Validator
 ~~~~~~~~~~~~~~~~~~~~~~
@ -387,20 +382,18 @@ Now we can update our genesis file. For instance, if the new
 ::

    {
-            "address": "AC379688105901436A34A65F185C115B8BB277A1",
-            "last_height": 0,
-            "last_round": 0,
-            "last_signature": null,
-            "last_signbytes": "",
-            "last_step": 0,
-            "priv_key": [
-                    1,
-                    "0D2ED337D748ADF79BE28559B9E59EBE1ABBA0BAFE6D65FCB9797985329B950C8F2B5AACAACC9FCE41881349743B0CFDE190DF0177744568D4E82A18F0B7DF94"
-            ],
-            "pub_key": [
-                    1,
-                    "8F2B5AACAACC9FCE41881349743B0CFDE190DF0177744568D4E82A18F0B7DF94"
-            ]
+      "address" : "5AF49D2A2D4F5AD4C7C8C4CC2FB020131E9C4902",
+      "pub_key" : {
+        "value" : "l9X9+fjkeBzDfPGbUM7AMIRE6uJN78zN5+lk5OYotek=",
+        "type" : "AC26791624DE60"
+      },
+      "priv_key" : {
+        "value" : "EDJY9W6zlAw+su6ITgTKg2nTZcHAH1NMTW5iwlgmNDuX1f35+OR4HMN88ZtQzsAwhETq4k3vzM3n6WTk5ii16Q==",
+        "type" : "954568A3288910"
+      },
+      "last_step" : 0,
+      "last_round" : 0,
+      "last_height" : 0
    }

 then the new ``genesis.json`` will be:
@ -408,27 +401,27 @@ then the new ``genesis.json`` will be:
 ::

    {
-        "app_hash": "",
-        "chain_id": "test-chain-HZw6TB",
-        "genesis_time": "0001-01-01T00:00:00.000Z",
-        "validators": [
-            {
-                "power": 10,
-                "name": "",
-                "pub_key": [
-                    1,
-                    "5770B4DD55B3E08B7F5711C48B516347D8C33F47C30C226315D21AA64E0DFF2E"
-                ]
-            },
-            {
-                "power": 10,
-                "name": "",
-                "pub_key": [
-                    1,
-                    "8F2B5AACAACC9FCE41881349743B0CFDE190DF0177744568D4E82A18F0B7DF94"
-                ]
-            }
-        ]
+      "validators" : [
+        {
+          "pub_key" : {
+            "value" : "h3hk+QE8c6QLTySp8TcfzclJw/BG79ziGB/pIA+DfPE=",
+            "type" : "AC26791624DE60"
+          },
+          "power" : 10,
+          "name" : ""
+        },
+        {
+          "pub_key" : {
+            "value" : "l9X9+fjkeBzDfPGbUM7AMIRE6uJN78zN5+lk5OYotek=",
+            "type" : "AC26791624DE60"
+          },
+          "power" : 10,
+          "name" : ""
+        }
+      ],
+      "app_hash" : "",
+      "chain_id" : "test-chain-rDlYSN",
+      "genesis_time" : "0001-01-01T00:00:00Z"
    }

 Update the ``genesis.json`` in ``~/.tendermint/config``. Copy the genesis file
--- a/evidence/reactor.go
+++ b/evidence/reactor.go
@ -1,12 +1,11 @@
 package evidence

 import (
-	"bytes"
 	"fmt"
 	"reflect"
 	"time"

-	wire "github.com/tendermint/go-wire"
+	"github.com/tendermint/go-amino"
 	"github.com/tendermint/tmlibs/log"

 	"github.com/tendermint/tendermint/p2p"
@ -16,7 +15,7 @@ import (
 const (
 	EvidenceChannel = byte(0x38)

-	maxEvidenceMessageSize     = 1048576 // 1MB TODO make it configurable
+	maxMsgSize                 = 1048576 // 1MB TODO make it configurable
 	broadcastEvidenceIntervalS = 60      // broadcast uncommitted evidence this often
 )

@ -68,7 +67,7 @@ func (evR *EvidenceReactor) AddPeer(peer p2p.Peer) {
 	// the rest will be sent by the broadcastRoutine
 	evidences := evR.evpool.PriorityEvidence()
 	msg := &EvidenceListMessage{evidences}
-	success := peer.Send(EvidenceChannel, struct{ EvidenceMessage }{msg})
+	success := peer.Send(EvidenceChannel, cdc.MustMarshalBinaryBare(msg))
 	if !success {
 		// TODO: remove peer ?
 	}
@ -82,7 +81,7 @@ func (evR *EvidenceReactor) RemovePeer(peer p2p.Peer, reason interface{}) {
 // Receive implements Reactor.
 // It adds any received evidence to the evpool.
 func (evR *EvidenceReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
-	_, msg, err := DecodeMessage(msgBytes)
+	msg, err := DecodeMessage(msgBytes)
 	if err != nil {
 		evR.Logger.Error("Error decoding message", "src", src, "chId", chID, "msg", msg, "err", err, "bytes", msgBytes)
 		evR.Switch.StopPeerForError(src, err)
@ -119,7 +118,7 @@ func (evR *EvidenceReactor) broadcastRoutine() {
 		case evidence := <-evR.evpool.EvidenceChan():
 			// broadcast some new evidence
 			msg := &EvidenceListMessage{[]types.Evidence{evidence}}
-			evR.Switch.Broadcast(EvidenceChannel, struct{ EvidenceMessage }{msg})
+			evR.Switch.Broadcast(EvidenceChannel, cdc.MustMarshalBinaryBare(msg))

 			// TODO: Broadcast runs asynchronously, so this should wait on the successChan
 			// in another routine before marking to be proper.
@ -127,7 +126,7 @@ func (evR *EvidenceReactor) broadcastRoutine() {
 		case <-ticker.C:
 			// broadcast all pending evidence
 			msg := &EvidenceListMessage{evR.evpool.PendingEvidence()}
-			evR.Switch.Broadcast(EvidenceChannel, struct{ EvidenceMessage }{msg})
+			evR.Switch.Broadcast(EvidenceChannel, cdc.MustMarshalBinaryBare(msg))
 		case <-evR.Quit():
 			return
 		}
@ -137,24 +136,22 @@ func (evR *EvidenceReactor) broadcastRoutine() {
 //-----------------------------------------------------------------------------
 // Messages

-const (
-	msgTypeEvidence = byte(0x01)
-)
-
 // EvidenceMessage is a message sent or received by the EvidenceReactor.
 type EvidenceMessage interface{}

-var _ = wire.RegisterInterface(
-	struct{ EvidenceMessage }{},
-	wire.ConcreteType{&EvidenceListMessage{}, msgTypeEvidence},
-)
+func RegisterEvidenceMessages(cdc *amino.Codec) {
+	cdc.RegisterInterface((*EvidenceMessage)(nil), nil)
+	cdc.RegisterConcrete(&EvidenceListMessage{},
+		"tendermint/evidence/EvidenceListMessage", nil)
+}

 // DecodeMessage decodes a byte-array into a EvidenceMessage.
-func DecodeMessage(bz []byte) (msgType byte, msg EvidenceMessage, err error) {
-	msgType = bz[0]
-	n := new(int)
-	r := bytes.NewReader(bz)
-	msg = wire.ReadBinary(struct{ EvidenceMessage }{}, r, maxEvidenceMessageSize, n, &err).(struct{ EvidenceMessage }).EvidenceMessage
+func DecodeMessage(bz []byte) (msg EvidenceMessage, err error) {
+	if len(bz) > maxMsgSize {
+		return msg, fmt.Errorf("Msg exceeds max size (%d > %d)",
+			len(bz), maxMsgSize)
+	}
+	err = cdc.UnmarshalBinaryBare(bz, &msg)
 	return
 }

--- a/evidence/store.go
+++ b/evidence/store.go
@ -3,7 +3,6 @@ package evidence
 import (
 	"fmt"

-	wire "github.com/tendermint/go-wire"
 	"github.com/tendermint/tendermint/types"
 	dbm "github.com/tendermint/tmlibs/db"
 )
@ -104,7 +103,10 @@ func (store *EvidenceStore) ListEvidence(prefixKey string) (evidence []types.Evi
 		val := iter.Value()

 		var ei EvidenceInfo
-		wire.ReadBinaryBytes(val, &ei)
+		err := cdc.UnmarshalBinaryBare(val, &ei)
+		if err != nil {
+			panic(err)
+		}
 		evidence = append(evidence, ei.Evidence)
 	}
 	return evidence
@ -119,7 +121,10 @@ func (store *EvidenceStore) GetEvidence(height int64, hash []byte) *EvidenceInfo
 		return nil
 	}
 	var ei EvidenceInfo
-	wire.ReadBinaryBytes(val, &ei)
+	err := cdc.UnmarshalBinaryBare(val, &ei)
+	if err != nil {
+		panic(err)
+	}
 	return &ei
 }

@ -137,7 +142,7 @@ func (store *EvidenceStore) AddNewEvidence(evidence types.Evidence, priority int
 		Priority:  priority,
 		Evidence:  evidence,
 	}
-	eiBytes := wire.BinaryBytes(ei)
+	eiBytes := cdc.MustMarshalBinaryBare(ei)

 	// add it to the store
 	key := keyOutqueue(evidence, priority)
@ -171,7 +176,7 @@ func (store *EvidenceStore) MarkEvidenceAsCommitted(evidence types.Evidence) {
 	ei.Committed = true

 	lookupKey := keyLookup(evidence)
-	store.db.SetSync(lookupKey, wire.BinaryBytes(ei))
+	store.db.SetSync(lookupKey, cdc.MustMarshalBinaryBare(ei))
 }

 //---------------------------------------------------
@ -181,6 +186,9 @@ func (store *EvidenceStore) getEvidenceInfo(evidence types.Evidence) EvidenceInf
 	key := keyLookup(evidence)
 	var ei EvidenceInfo
 	b := store.db.Get(key)
-	wire.ReadBinaryBytes(b, &ei)
+	err := cdc.UnmarshalBinaryBare(b, &ei)
+	if err != nil {
+		panic(err)
+	}
 	return ei
 }
--- a/evidence/store_test.go
+++ b/evidence/store_test.go
@ -4,7 +4,6 @@ import (
 	"testing"

 	"github.com/stretchr/testify/assert"
-	wire "github.com/tendermint/go-wire"
 	"github.com/tendermint/tendermint/types"
 	dbm "github.com/tendermint/tmlibs/db"
 )
@ -108,15 +107,3 @@ func TestStorePriority(t *testing.T) {
 		assert.Equal(ev, cases[i].ev)
 	}
 }
-
-//-------------------------------------------
-const (
-	evidenceTypeMockGood = byte(0x01)
-	evidenceTypeMockBad  = byte(0x02)
-)
-
-var _ = wire.RegisterInterface(
-	struct{ types.Evidence }{},
-	wire.ConcreteType{types.MockGoodEvidence{}, evidenceTypeMockGood},
-	wire.ConcreteType{types.MockBadEvidence{}, evidenceTypeMockBad},
-)
--- a/evidence/wire.go
+++ b/evidence/wire.go
@ -0,0 +1,25 @@
+package evidence
+
+import (
+	"github.com/tendermint/go-amino"
+	"github.com/tendermint/go-crypto"
+	"github.com/tendermint/tendermint/types"
+)
+
+var cdc = amino.NewCodec()
+
+func init() {
+	RegisterEvidenceMessages(cdc)
+	crypto.RegisterAmino(cdc)
+	types.RegisterEvidences(cdc)
+	RegisterMockEvidences(cdc) // For testing
+}
+
+//-------------------------------------------
+
+func RegisterMockEvidences(cdc *amino.Codec) {
+	cdc.RegisterConcrete(types.MockGoodEvidence{},
+		"tendermint/MockGoodEvidence", nil)
+	cdc.RegisterConcrete(types.MockBadEvidence{},
+		"tendermint/MockBadEvidence", nil)
+}
--- a/lite/client/provider.go
+++ b/lite/client/provider.go
@ -93,7 +93,7 @@ func (p *provider) GetLatestCommit() (*ctypes.ResultCommit, error) {
 	if err != nil {
 		return nil, err
 	}
-	return p.node.Commit(&status.LatestBlockHeight)
+	return p.node.Commit(&status.SyncInfo.LatestBlockHeight)
 }

 // CommitFromResult ...
--- a/lite/files/commit.go
+++ b/lite/files/commit.go
@ -1,13 +1,11 @@
 package files

 import (
-	"encoding/json"
+	"io/ioutil"
 	"os"

 	"github.com/pkg/errors"

-	wire "github.com/tendermint/go-wire"
-
 	"github.com/tendermint/tendermint/lite"
 	liteErr "github.com/tendermint/tendermint/lite/errors"
 )
@ -19,7 +17,7 @@ const (
 	MaxFullCommitSize = 1024 * 1024
 )

-// SaveFullCommit exports the seed in binary / go-wire style
+// SaveFullCommit exports the seed in binary / go-amino style
 func SaveFullCommit(fc lite.FullCommit, path string) error {
 	f, err := os.Create(path)
 	if err != nil {
@ -27,9 +25,11 @@ func SaveFullCommit(fc lite.FullCommit, path string) error {
 	}
 	defer f.Close()

-	var n int
-	wire.WriteBinary(fc, f, &n, &err)
-	return errors.WithStack(err)
+	_, err = cdc.MarshalBinaryWriter(f, fc)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	return nil
 }

 // SaveFullCommitJSON exports the seed in a json format
@ -39,9 +39,15 @@ func SaveFullCommitJSON(fc lite.FullCommit, path string) error {
 		return errors.WithStack(err)
 	}
 	defer f.Close()
-	stream := json.NewEncoder(f)
-	err = stream.Encode(fc)
-	return errors.WithStack(err)
+	bz, err := cdc.MarshalJSON(fc)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	_, err = f.Write(bz)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	return nil
 }

 // LoadFullCommit loads the full commit from the file system.
@ -56,9 +62,11 @@ func LoadFullCommit(path string) (lite.FullCommit, error) {
 	}
 	defer f.Close()

-	var n int
-	wire.ReadBinaryPtr(&fc, f, MaxFullCommitSize, &n, &err)
-	return fc, errors.WithStack(err)
+	_, err = cdc.UnmarshalBinaryReader(f, &fc, 0)
+	if err != nil {
+		return fc, errors.WithStack(err)
+	}
+	return fc, nil
 }

 // LoadFullCommitJSON loads the commit from the file system in JSON format.
@ -73,7 +81,13 @@ func LoadFullCommitJSON(path string) (lite.FullCommit, error) {
 	}
 	defer f.Close()

-	stream := json.NewDecoder(f)
-	err = stream.Decode(&fc)
-	return fc, errors.WithStack(err)
+	bz, err := ioutil.ReadAll(f)
+	if err != nil {
+		return fc, errors.WithStack(err)
+	}
+	err = cdc.UnmarshalJSON(bz, &fc)
+	if err != nil {
+		return fc, errors.WithStack(err)
+	}
+	return fc, nil
 }
--- a/lite/files/wire.go
+++ b/lite/files/wire.go
@ -0,0 +1,12 @@
+package files
+
+import (
+	"github.com/tendermint/go-amino"
+	"github.com/tendermint/go-crypto"
+)
+
+var cdc = amino.NewCodec()
+
+func init() {
+	crypto.RegisterAmino(cdc)
+}
--- a/lite/helpers.go
+++ b/lite/helpers.go
@ -23,7 +23,7 @@ type ValKeys []crypto.PrivKey
 func GenValKeys(n int) ValKeys {
 	res := make(ValKeys, n)
 	for i := range res {
-		res[i] = crypto.GenPrivKeyEd25519().Wrap()
+		res[i] = crypto.GenPrivKeyEd25519()
 	}
 	return res
 }
@ -32,7 +32,7 @@ func GenValKeys(n int) ValKeys {
 func (v ValKeys) Change(i int) ValKeys {
 	res := make(ValKeys, len(v))
 	copy(res, v)
-	res[i] = crypto.GenPrivKeyEd25519().Wrap()
+	res[i] = crypto.GenPrivKeyEd25519()
 	return res
 }

@ -46,7 +46,7 @@ func (v ValKeys) Extend(n int) ValKeys {
 func GenSecpValKeys(n int) ValKeys {
 	res := make(ValKeys, n)
 	for i := range res {
-		res[i] = crypto.GenPrivKeySecp256k1().Wrap()
+		res[i] = crypto.GenPrivKeySecp256k1()
 	}
 	return res
 }
--- a/lite/proxy/block.go
+++ b/lite/proxy/block.go
@ -11,11 +11,17 @@ import (
 )

 func ValidateBlockMeta(meta *types.BlockMeta, check lite.Commit) error {
+	if meta == nil {
+		return errors.New("expecting a non-nil BlockMeta")
+	}
 	// TODO: check the BlockID??
 	return ValidateHeader(meta.Header, check)
 }

 func ValidateBlock(meta *types.Block, check lite.Commit) error {
+	if meta == nil {
+		return errors.New("expecting a non-nil Block")
+	}
 	err := ValidateHeader(meta.Header, check)
 	if err != nil {
 		return err
@ -27,6 +33,9 @@ func ValidateBlock(meta *types.Block, check lite.Commit) error {
 }

 func ValidateHeader(head *types.Header, check lite.Commit) error {
+	if head == nil {
+		return errors.New("expecting a non-nil Header")
+	}
 	// make sure they are for the same height (obvious fail)
 	if head.Height != check.Height() {
 		return certerr.ErrHeightMismatch(head.Height, check.Height())
--- a/lite/proxy/proxy.go
+++ b/lite/proxy/proxy.go
@ -3,10 +3,12 @@ package proxy
 import (
 	"net/http"

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

 	rpcclient "github.com/tendermint/tendermint/rpc/client"
 	"github.com/tendermint/tendermint/rpc/core"
+	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 	rpc "github.com/tendermint/tendermint/rpc/lib/server"
 )

@ -23,13 +25,15 @@ func StartProxy(c rpcclient.Client, listenAddr string, logger log.Logger) error
 		return err
 	}

+	cdc := amino.NewCodec()
+	ctypes.RegisterAmino(cdc)
 	r := RPCRoutes(c)

 	// build the handler...
 	mux := http.NewServeMux()
-	rpc.RegisterRPCFuncs(mux, r, logger)
+	rpc.RegisterRPCFuncs(mux, r, cdc, logger)

-	wm := rpc.NewWebsocketManager(r, rpc.EventSubscriber(c))
+	wm := rpc.NewWebsocketManager(r, cdc, rpc.EventSubscriber(c))
 	wm.SetLogger(logger)
 	core.SetLogger(logger)
 	mux.HandleFunc(wsEndpoint, wm.WebsocketHandler)
--- a/lite/proxy/validate_test.go
+++ b/lite/proxy/validate_test.go
@ -0,0 +1,218 @@
+package proxy_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/tendermint/tendermint/lite"
+	"github.com/tendermint/tendermint/lite/proxy"
+	"github.com/tendermint/tendermint/types"
+)
+
+var (
+	deadBeefTxs  = types.Txs{[]byte("DE"), []byte("AD"), []byte("BE"), []byte("EF")}
+	deadBeefHash = deadBeefTxs.Hash()
+	testTime1    = time.Date(2018, 1, 1, 1, 1, 1, 1, time.UTC)
+	testTime2    = time.Date(2017, 1, 2, 1, 1, 1, 1, time.UTC)
+)
+
+var hdrHeight11 = &types.Header{
+	Height:         11,
+	Time:           testTime1,
+	ValidatorsHash: []byte("Tendermint"),
+}
+
+func TestValidateBlock(t *testing.T) {
+	tests := []struct {
+		block   *types.Block
+		commit  lite.Commit
+		wantErr string
+	}{
+		{
+			block: nil, wantErr: "non-nil Block",
+		},
+		{
+			block: &types.Block{}, wantErr: "nil Header",
+		},
+		{
+			block: &types.Block{Header: new(types.Header)},
+		},
+
+		// Start Header.Height mismatch test
+		{
+			block:   &types.Block{Header: &types.Header{Height: 10}},
+			commit:  lite.Commit{Header: &types.Header{Height: 11}},
+			wantErr: "don't match - 10 vs 11",
+		},
+
+		{
+			block:  &types.Block{Header: &types.Header{Height: 11}},
+			commit: lite.Commit{Header: &types.Header{Height: 11}},
+		},
+		// End Header.Height mismatch test
+
+		// Start Header.Hash mismatch test
+		{
+			block:   &types.Block{Header: hdrHeight11},
+			commit:  lite.Commit{Header: &types.Header{Height: 11}},
+			wantErr: "Headers don't match",
+		},
+
+		{
+			block:  &types.Block{Header: hdrHeight11},
+			commit: lite.Commit{Header: hdrHeight11},
+		},
+		// End Header.Hash mismatch test
+
+		// Start Header.Data hash mismatch test
+		{
+			block: &types.Block{
+				Header: &types.Header{Height: 11},
+				Data:   &types.Data{Txs: []types.Tx{[]byte("0xDE"), []byte("AD")}},
+			},
+			commit: lite.Commit{
+				Header: &types.Header{Height: 11},
+				Commit: &types.Commit{BlockID: types.BlockID{Hash: []byte("0xDEADBEEF")}},
+			},
+			wantErr: "Data hash doesn't match header",
+		},
+		{
+			block: &types.Block{
+				Header: &types.Header{Height: 11, DataHash: deadBeefHash},
+				Data:   &types.Data{Txs: deadBeefTxs},
+			},
+			commit: lite.Commit{
+				Header: &types.Header{Height: 11},
+				Commit: &types.Commit{BlockID: types.BlockID{Hash: []byte("DEADBEEF")}},
+			},
+		},
+		// End Header.Data hash mismatch test
+	}
+
+	for i, tt := range tests {
+		err := proxy.ValidateBlock(tt.block, tt.commit)
+		if tt.wantErr != "" {
+			if err == nil {
+				assert.FailNowf(t, "Unexpectedly passed", "#%d", i)
+			} else {
+				assert.Contains(t, err.Error(), tt.wantErr, "#%d should contain the substring\n\n", i)
+			}
+			continue
+		}
+
+		assert.Nil(t, err, "#%d: expecting a nil error", i)
+	}
+}
+
+func TestValidateBlockMeta(t *testing.T) {
+	tests := []struct {
+		meta    *types.BlockMeta
+		commit  lite.Commit
+		wantErr string
+	}{
+		{
+			meta: nil, wantErr: "non-nil BlockMeta",
+		},
+		{
+			meta: &types.BlockMeta{}, wantErr: "non-nil Header",
+		},
+		{
+			meta: &types.BlockMeta{Header: new(types.Header)},
+		},
+
+		// Start Header.Height mismatch test
+		{
+			meta:    &types.BlockMeta{Header: &types.Header{Height: 10}},
+			commit:  lite.Commit{Header: &types.Header{Height: 11}},
+			wantErr: "don't match - 10 vs 11",
+		},
+
+		{
+			meta:   &types.BlockMeta{Header: &types.Header{Height: 11}},
+			commit: lite.Commit{Header: &types.Header{Height: 11}},
+		},
+		// End Header.Height mismatch test
+
+		// Start Headers don't match test
+		{
+			meta:    &types.BlockMeta{Header: hdrHeight11},
+			commit:  lite.Commit{Header: &types.Header{Height: 11}},
+			wantErr: "Headers don't match",
+		},
+
+		{
+			meta:   &types.BlockMeta{Header: hdrHeight11},
+			commit: lite.Commit{Header: hdrHeight11},
+		},
+
+		{
+			meta: &types.BlockMeta{
+				Header: &types.Header{
+					Height:         11,
+					ValidatorsHash: []byte("lite-test"),
+					// TODO: should be able to use empty time after Amino upgrade
+					Time: testTime1,
+				},
+			},
+			commit: lite.Commit{
+				Header: &types.Header{Height: 11, DataHash: deadBeefHash},
+			},
+			wantErr: "Headers don't match",
+		},
+
+		{
+			meta: &types.BlockMeta{
+				Header: &types.Header{
+					Height: 11, DataHash: deadBeefHash,
+					ValidatorsHash: []byte("Tendermint"),
+					Time:           testTime1,
+				},
+			},
+			commit: lite.Commit{
+				Header: &types.Header{
+					Height: 11, DataHash: deadBeefHash,
+					ValidatorsHash: []byte("Tendermint"),
+					Time:           testTime2,
+				},
+				Commit: &types.Commit{BlockID: types.BlockID{Hash: []byte("DEADBEEF")}},
+			},
+			wantErr: "Headers don't match",
+		},
+
+		{
+			meta: &types.BlockMeta{
+				Header: &types.Header{
+					Height: 11, DataHash: deadBeefHash,
+					ValidatorsHash: []byte("Tendermint"),
+					Time:           testTime2,
+				},
+			},
+			commit: lite.Commit{
+				Header: &types.Header{
+					Height: 11, DataHash: deadBeefHash,
+					ValidatorsHash: []byte("Tendermint-x"),
+					Time:           testTime2,
+				},
+				Commit: &types.Commit{BlockID: types.BlockID{Hash: []byte("DEADBEEF")}},
+			},
+			wantErr: "Headers don't match",
+		},
+		// End Headers don't match test
+	}
+
+	for i, tt := range tests {
+		err := proxy.ValidateBlockMeta(tt.meta, tt.commit)
+		if tt.wantErr != "" {
+			if err == nil {
+				assert.FailNowf(t, "Unexpectedly passed", "#%d: wanted error %q", i, tt.wantErr)
+			} else {
+				assert.Contains(t, err.Error(), tt.wantErr, "#%d should contain the substring\n\n", i)
+			}
+			continue
+		}
+
+		assert.Nil(t, err, "#%d: expecting a nil error", i)
+	}
+}
--- a/lite/proxy/wrapper.go
+++ b/lite/proxy/wrapper.go
@ -146,7 +146,7 @@ func (w Wrapper) Commit(height *int64) (*ctypes.ResultCommit, error) {
 // 	}

 // 	// check to validate it if possible, and drop if not valid
-// 	switch t := tm.Unwrap().(type) {
+// 	switch t := tm.(type) {
 // 	case types.EventDataNewBlockHeader:
 // 		err := verifyHeader(s.client, t.Header)
 // 		if err != nil {
--- a/mempool/reactor.go
+++ b/mempool/reactor.go
@ -1,13 +1,12 @@
 package mempool

 import (
-	"bytes"
 	"fmt"
 	"reflect"
 	"time"

 	abci "github.com/tendermint/abci/types"
-	wire "github.com/tendermint/go-wire"
+	"github.com/tendermint/go-amino"
 	"github.com/tendermint/tmlibs/clist"
 	"github.com/tendermint/tmlibs/log"

@ -19,7 +18,7 @@ import (
 const (
 	MempoolChannel = byte(0x30)

-	maxMempoolMessageSize      = 1048576 // 1MB TODO make it configurable
+	maxMsgSize                 = 1048576 // 1MB TODO make it configurable
 	peerCatchupSleepIntervalMS = 100     // If peer is behind, sleep this amount
 )

@ -71,7 +70,7 @@ func (memR *MempoolReactor) RemovePeer(peer p2p.Peer, reason interface{}) {
 // Receive implements Reactor.
 // It adds any received transactions to the mempool.
 func (memR *MempoolReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
-	_, msg, err := DecodeMessage(msgBytes)
+	msg, err := DecodeMessage(msgBytes)
 	if err != nil {
 		memR.Logger.Error("Error decoding message", "src", src, "chId", chID, "msg", msg, "err", err, "bytes", msgBytes)
 		memR.Switch.StopPeerForError(src, err)
@ -137,7 +136,7 @@ func (memR *MempoolReactor) broadcastTxRoutine(peer p2p.Peer) {
 		}
 		// send memTx
 		msg := &TxMessage{Tx: memTx.tx}
-		success := peer.Send(MempoolChannel, struct{ MempoolMessage }{msg})
+		success := peer.Send(MempoolChannel, cdc.MustMarshalBinaryBare(msg))
 		if !success {
 			time.Sleep(peerCatchupSleepIntervalMS * time.Millisecond)
 			continue
@ -158,24 +157,21 @@ func (memR *MempoolReactor) broadcastTxRoutine(peer p2p.Peer) {
 //-----------------------------------------------------------------------------
 // Messages

-const (
-	msgTypeTx = byte(0x01)
-)
-
 // MempoolMessage is a message sent or received by the MempoolReactor.
 type MempoolMessage interface{}

-var _ = wire.RegisterInterface(
-	struct{ MempoolMessage }{},
-	wire.ConcreteType{&TxMessage{}, msgTypeTx},
-)
+func RegisterMempoolMessages(cdc *amino.Codec) {
+	cdc.RegisterInterface((*MempoolMessage)(nil), nil)
+	cdc.RegisterConcrete(&TxMessage{}, "tendermint/mempool/TxMessage", nil)
+}

 // DecodeMessage decodes a byte-array into a MempoolMessage.
-func DecodeMessage(bz []byte) (msgType byte, msg MempoolMessage, err error) {
-	msgType = bz[0]
-	n := new(int)
-	r := bytes.NewReader(bz)
-	msg = wire.ReadBinary(struct{ MempoolMessage }{}, r, maxMempoolMessageSize, n, &err).(struct{ MempoolMessage }).MempoolMessage
+func DecodeMessage(bz []byte) (msg MempoolMessage, err error) {
+	if len(bz) > maxMsgSize {
+		return msg, fmt.Errorf("Msg exceeds max size (%d > %d)",
+			len(bz), maxMsgSize)
+	}
+	err = cdc.UnmarshalBinaryBare(bz, &msg)
 	return
 }

--- a/mempool/wire.go
+++ b/mempool/wire.go
@ -0,0 +1,11 @@
+package mempool
+
+import (
+	"github.com/tendermint/go-amino"
+)
+
+var cdc = amino.NewCodec()
+
+func init() {
+	RegisterMempoolMessages(cdc)
+}
--- a/networks/local/Makefile
+++ b/networks/local/Makefile
@ -0,0 +1,7 @@
+# Makefile for the "localnode" docker image.
+
+all:
+	docker build --tag tendermint/localnode localnode
+
+.PHONY: all
+
--- a/networks/local/README.rst
+++ b/networks/local/README.rst
@ -0,0 +1,40 @@
+localnode
+=========
+
+It is assumed that you have already `setup docker <https://docs.docker.com/engine/installation/>`__.
+
+Description
+-----------
+Image for local testnets.
+
+Add the tendermint binary to the image by attaching it in a folder to the `/tendermint` mount point.
+
+It assumes that the configuration was created by the `tendermint testnet` command and it is also attached to the `/tendermint` mount point.
+
+Example:
+This example builds a linux tendermint binary under the `build/` folder, creates tendermint configuration for a single-node validator and runs the node:
+```
+cd $GOPATH/src/github.com/tendermint/tendermint
+
+#Build binary
+make build-linux
+
+#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
+```
+
+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.
+
+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.
+
+docker-compose.yml
+==================
+This file creates a 4-node network using the localnode image. The nodes of the network are exposed to the host machine on ports 46656-46657, 46659-46660, 46661-46662, 46663-46664 respectively.
+
--- a/networks/local/localnode/Dockerfile
+++ b/networks/local/localnode/Dockerfile
@ -0,0 +1,16 @@
+FROM alpine:3.7
+MAINTAINER Greg Szabo <greg@tendermint.com>
+
+RUN apk update && \
+    apk upgrade && \
+    apk --no-cache add curl jq file
+
+VOLUME [ /tendermint ]
+WORKDIR /tendermint
+EXPOSE 46656 46657
+ENTRYPOINT ["/usr/bin/wrapper.sh"]
+CMD ["node", "--proxy_app dummy"]
+STOPSIGNAL SIGTERM
+
+COPY wrapper.sh /usr/bin/wrapper.sh
+
--- a/networks/local/localnode/wrapper.sh
+++ b/networks/local/localnode/wrapper.sh
@ -0,0 +1,35 @@
+#!/usr/bin/env sh
+
+##
+## Input parameters
+##
+BINARY=/tendermint/${BINARY:-tendermint}
+ID=${ID:-0}
+LOG=${LOG:-tendermint.log}
+
+##
+## Assert linux binary
+##
+if ! [ -f "${BINARY}" ]; then
+	echo "The binary $(basename "${BINARY}") cannot be found. Please add the binary to the shared folder. Please use the BINARY environment variable if the name of the binary is not 'tendermint' E.g.: -e BINARY=tendermint_my_test_version"
+	exit 1
+fi
+BINARY_CHECK="$(file "$BINARY" | grep 'ELF 64-bit LSB executable, x86-64')"
+if [ -z "${BINARY_CHECK}" ]; then
+	echo "Binary needs to be OS linux, ARCH amd64"
+	exit 1
+fi
+
+##
+## Run binary with all parameters
+##
+export TMHOME="/tendermint/node${ID}"
+
+if [ -d "`dirname ${TMHOME}/${LOG}`" ]; then
+  "$BINARY" "$@" | tee "${TMHOME}/${LOG}"
+else
+  "$BINARY" "$@"
+fi
+
+chmod 777 -R /tendermint
+
--- a/Show More
+++ b/Show More