[docs] update state spec

when deciding if we should send evidence to it

CHANGELOG_PENDING.md

@@ -1,107 +1,77 @@
 # Pending
 
-## v0.26.0
-
-*October 19, 2018*
-
 Special thanks to external contributors on this release:
-@bradyjoestar, @connorwstein, @goolAdapter, @HaoyangLiu,
-@james-ray, @overbool, @phymbert, @Slamper, @Uzair1995
-
-This release is primarily about adding Version fields to various data structures,
-optimizing consensus messages for signing and verification in
-restricted environments (like HSMs and the Ethereum Virtual Machine), and
-aligning the consensus code with the [specification](https://arxiv.org/abs/1807.04938).
-It also includes our first take at a generalized merkle proof system.
-
-See the [UPGRADING.md](UPGRADING.md#v0.26.0) for details on upgrading to the new
-version.
-
-Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
+@goolAdapter, @bradyjoestar
 
 BREAKING CHANGES:
 
 * CLI/RPC/Config
-  * [config] [\#2232](https://github.com/tendermint/tendermint/issues/2232) timeouts as time.Duration, not ints
-  * [config] [\#2505](https://github.com/tendermint/tendermint/issues/2505) Remove Mempool.RecheckEmpty (it was effectively useless anyways)
-  * [config] [\#2490](https://github.com/tendermint/tendermint/issues/2490) `mempool.wal` is disabled by default
-  * [privval] [\#2459](https://github.com/tendermint/tendermint/issues/2459) Split `SocketPVMsg`s implementations into Request and Response, where the Response may contain a error message (returned by the remote signer)
-  * [state] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Add Version field to State, breaking the format of State as
-    encoded on disk.
-  * [rpc] [\#2298](https://github.com/tendermint/tendermint/issues/2298) `/abci_query` takes `prove` argument instead of `trusted` and switches the default
+  * [config] \#2232 timeouts as time.Duration, not ints
+  * [config] \#2505 Remove Mempool.RecheckEmpty (it was effectively useless anyways)
+  * [config] `mempool.wal` is disabled by default
+  * [rpc] \#2298 `/abci_query` takes `prove` argument instead of `trusted` and switches the default
     behaviour to `prove=false`
-  * [rpc] [\#2654](https://github.com/tendermint/tendermint/issues/2654) Remove all `node_info.other.*_version` fields in `/status` and
-    `/net_info`
+  * [privval] \#2459 Split `SocketPVMsg`s implementations into Request and Response, where the Response may contain a error message (returned by the remote signer)
+  * [genesis] \#2565 `consensus_params.evidence_params.max_age` is now `time.Duration` (nanosecond count)
+        ```json
+        "evidence_params": {
+          "max_age": "48h0m0s"
+        }
+        ```
 
 * Apps
-  * [abci] [\#2298](https://github.com/tendermint/tendermint/issues/2298) ResponseQuery.Proof is now a structured merkle.Proof, not just
+  * [abci] \#2298 ResponseQuery.Proof is now a structured merkle.Proof, not just
     arbitrary bytes
-  * [abci] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Add Version to Header and shift all fields by one
-  * [abci] [\#2662](https://github.com/tendermint/tendermint/issues/2662) Bump the field numbers for some `ResponseInfo` fields to make room for
-      `AppVersion`
+  * [abci] \#2565 InitChain `ConsensusParams.EvidenceParams.MaxAge` is now `google.protobuf.Duration` (see https://developers.google.com/protocol-buffers/docs/reference/csharp/class/google/protobuf/well-known-types/duration)
 
 * Go API
-  * [config] [\#2232](https://github.com/tendermint/tendermint/issues/2232) timeouts as time.Duration, not ints
-  * [crypto/merkle & lite] [\#2298](https://github.com/tendermint/tendermint/issues/2298) Various changes to accomodate General Merkle trees
-  * [crypto/merkle] [\#2595](https://github.com/tendermint/tendermint/issues/2595) Remove all Hasher objects in favor of byte slices
-  * [crypto/merkle] [\#2635](https://github.com/tendermint/tendermint/issues/2635) merkle.SimpleHashFromTwoHashes is no longer exported
-  * [node] [\#2479](https://github.com/tendermint/tendermint/issues/2479) Remove node.RunForever
-  * [rpc/client] [\#2298](https://github.com/tendermint/tendermint/issues/2298) `ABCIQueryOptions.Trusted` -> `ABCIQueryOptions.Prove`
-  * [types] [\#2298](https://github.com/tendermint/tendermint/issues/2298) Remove `Index` and `Total` fields from `TxProof`.
-  * [types] [\#2598](https://github.com/tendermint/tendermint/issues/2598) `VoteTypeXxx` are now of type `SignedMsgType byte` and named `XxxType`, eg. `PrevoteType`,
-    `PrecommitType`.
+  * [node] Remove node.RunForever
+  * [config] \#2232 timeouts as time.Duration, not ints
+  * [rpc/client] \#2298 `ABCIQueryOptions.Trusted` -> `ABCIQueryOptions.Prove`
+  * [types] \#2298 Remove `Index` and `Total` fields from `TxProof`.
+  * [crypto/merkle & lite] \#2298 Various changes to accomodate General Merkle trees
+  * [crypto/merkle] \#2595 Remove all Hasher objects in favor of byte slices
+  * [crypto/merkle] \#2635 merkle.SimpleHashFromTwoHashes is no longer exported
+  * [types] \#2598 `VoteTypeXxx` are now
 
 * Blockchain Protocol
   * [types] Update SignBytes for `Vote`/`Proposal`/`Heartbeat`:
-    * [\#2459](https://github.com/tendermint/tendermint/issues/2459) Use amino encoding instead of JSON in `SignBytes`.
-    * [\#2598](https://github.com/tendermint/tendermint/issues/2598) Reorder fields and use fixed sized encoding.
-    * [\#2598](https://github.com/tendermint/tendermint/issues/2598) Change `Type` field fromt `string` to `byte` and use new
+    * \#2459 Use amino encoding instead of JSON in `SignBytes`.
+    * \#2598 Reorder fields and use fixed sized encoding.
+    * \#2598 Change `Type` field fromt `string` to `byte` and use new
       `SignedMsgType` to enumerate.
-  * [types] [\#2512](https://github.com/tendermint/tendermint/issues/2512) Remove the pubkey field from the validator hash
-  * [types] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Add Version struct to Header
-  * [types] [\#2609](https://github.com/tendermint/tendermint/issues/2609) ConsensusParams.Hash() is the hash of the amino encoded
-    struct instead of the Merkle tree of the fields
-  * [state] [\#2587](https://github.com/tendermint/tendermint/issues/2587) Require block.Time of the fist block to be genesis time
-  * [state] [\#2644](https://github.com/tendermint/tendermint/issues/2644) Require block.Version to match state.Version
-  * [types] [\#2670](https://github.com/tendermint/tendermint/issues/2670) Header.Hash() builds Merkle tree out of fields in the same
-    order they appear in the header, instead of sorting by field name
+  * [types] \#2512 Remove the pubkey field from the validator hash
+  * [state] \#2587 Require block.Time of the fist block to be genesis time
 
 * P2P Protocol
-  * [p2p] [\#2654](https://github.com/tendermint/tendermint/issues/2654) Add `ProtocolVersion` struct with protocol versions to top of
-    DefaultNodeInfo and require `ProtocolVersion.Block` to match during peer handshake
 
 FEATURES:
-- [abci] [\#2557](https://github.com/tendermint/tendermint/issues/2557) Add `Codespace` field to `Response{CheckTx, DeliverTx, Query}`
-- [abci] [\#2662](https://github.com/tendermint/tendermint/issues/2662) Add `BlockVersion` and `P2PVersion` to `RequestInfo`
-- [crypto/merkle] [\#2298](https://github.com/tendermint/tendermint/issues/2298) General Merkle Proof scheme for chaining various types of Merkle trees together
+- [crypto/merkle] \#2298 General Merkle Proof scheme for chaining various types of Merkle trees together
+- [abci] \#2557 Add `Codespace` field to `Response{CheckTx, DeliverTx, Query}`
 
 IMPROVEMENTS:
 - Additional Metrics
     - [consensus] [\#2169](https://github.com/cosmos/cosmos-sdk/issues/2169)
     - [p2p] [\#2169](https://github.com/cosmos/cosmos-sdk/issues/2169)
-- [config] [\#2232](https://github.com/tendermint/tendermint/issues/2232) Added ValidateBasic method, which performs basic checks
-- [crypto/ed25519] [\#2558](https://github.com/tendermint/tendermint/issues/2558) Switch to use latest `golang.org/x/crypto` through our fork at
+- [config] \#2232 Added ValidateBasic method, which performs basic checks
+- [crypto/ed25519] \#2558 Switch to use latest `golang.org/x/crypto` through our fork at
   github.com/tendermint/crypto
-- [tools] [\#2238](https://github.com/tendermint/tendermint/issues/2238) Binary dependencies are now locked to a specific git commit
+- [tools] \#2238 Binary dependencies are now locked to a specific git commit
+- [crypto] \#2099 make crypto random use chacha, and have forward secrecy of generated randomness
 
 BUG FIXES:
-- [autofile] [\#2428](https://github.com/tendermint/tendermint/issues/2428) Group.RotateFile need call Flush() before rename (@goolAdapter)
-- [common] [\#2533](https://github.com/tendermint/tendermint/issues/2533) Fixed a bug in the `BitArray.Or` method
-- [common] [\#2506](https://github.com/tendermint/tendermint/issues/2506) Fixed a bug in the `BitArray.Sub` method (@james-ray)
-- [common] [\#2534](https://github.com/tendermint/tendermint/issues/2534) Fix `BitArray.PickRandom` to choose uniformly from true bits
-- [consensus] [\#1690](https://github.com/tendermint/tendermint/issues/1690) Wait for
-  timeoutPrecommit before starting next round
-- [consensus] [\#1745](https://github.com/tendermint/tendermint/issues/1745) Wait for
-  Proposal or timeoutProposal before entering prevote
-- [consensus] [\#2642](https://github.com/tendermint/tendermint/issues/2642) Only propose ValidBlock, not LockedBlock
-- [consensus] [\#2642](https://github.com/tendermint/tendermint/issues/2642) Initialized ValidRound and LockedRound to -1
-- [consensus] [\#1637](https://github.com/tendermint/tendermint/issues/1637) Limit the amount of evidence that can be included in a
+- [autofile] \#2428 Group.RotateFile need call Flush() before rename (@goolAdapter)
+- [node] \#2434 Make node respond to signal interrupts while sleeping for genesis time
+- [consensus] [\#1690](https://github.com/tendermint/tendermint/issues/1690) wait for
+timeoutPrecommit before starting next round
+- [consensus] [\#1745](https://github.com/tendermint/tendermint/issues/1745) wait for
+Proposal or timeoutProposal before entering prevote
+- [evidence] \#2515 fix db iter leak (@goolAdapter)
+- [common/bit_array] Fixed a bug in the `Or` function
+- [common/bit_array] Fixed a bug in the `Sub` function (@james-ray)
+- [common] \#2534 Make bit array's PickRandom choose uniformly from true bits
+- [consensus] \#1637 Limit the amount of evidence that can be included in a
   block
-- [evidence] [\#2515](https://github.com/tendermint/tendermint/issues/2515) Fix db iter leak (@goolAdapter)
-- [libs/event] [\#2518](https://github.com/tendermint/tendermint/issues/2518) Fix event concurrency flaw (@goolAdapter)
-- [node] [\#2434](https://github.com/tendermint/tendermint/issues/2434) Make node respond to signal interrupts while sleeping for genesis time
-- [state] [\#2616](https://github.com/tendermint/tendermint/issues/2616) Pass nil to NewValidatorSet() when genesis file's Validators field is nil
-- [p2p] [\#2555](https://github.com/tendermint/tendermint/issues/2555) Fix p2p switch FlushThrottle value (@goolAdapter)
-- [p2p] [\#2668](https://github.com/tendermint/tendermint/issues/2668) Reconnect to originally dialed address (not self-reported
-  address) for persistent peers
-
+- [p2p] \#2555 fix p2p switch FlushThrottle value (@goolAdapter)
+- [libs/event] \#2518 fix event concurrency flaw (@goolAdapter)
+- [state] \#2616 Pass nil to NewValidatorSet() when genesis file's Validators field is nil

Gopkg.lock

@@ -11,11 +11,11 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:c0decf632843204d2b8781de7b26e7038584e2dcccc7e2f401e88ae85b1df2b7"
+  digest = "1:2c00f064ba355903866cbfbf3f7f4c0fe64af6638cc7d1b8bdcf3181bc67f1d8"
   name = "github.com/btcsuite/btcd"
   packages = ["btcec"]
   pruneopts = "UT"
-  revision = "67e573d211ace594f1366b4ce9d39726c4b19bd0"
+  revision = "f5e261fc9ec3437697fb31d8b38453c293204b29"
 
 [[projects]]
   digest = "1:1d8e1cb71c33a9470bbbae09bfec09db43c6bf358dfcae13cd8807c4e2a9a2bf"
@@ -28,12 +28,12 @@
   revision = "d4cc87b860166d00d6b5b9e0d3b3d71d6088d4d4"
 
 [[projects]]
-  digest = "1:ffe9824d294da03b391f44e1ae8281281b4afc1bdaa9588c9097785e3af10cec"
+  digest = "1:a2c1d0e43bd3baaa071d1b9ed72c27d78169b2b269f71c105ac4ba34b1be4a39"
   name = "github.com/davecgh/go-spew"
   packages = ["spew"]
   pruneopts = "UT"
-  revision = "8991bc29aa16c548c550c7ff78260e27b9ab7c73"
-  version = "v1.1.1"
+  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
+  version = "v1.1.0"
 
 [[projects]]
   digest = "1:c7644c73a3d23741fdba8a99b1464e021a224b7e205be497271a8003a15ca41b"
@@ -83,12 +83,12 @@
   version = "v0.3.0"
 
 [[projects]]
-  digest = "1:586ea76dbd0374d6fb649a91d70d652b7fe0ccffb8910a77468e7702e7901f3d"
+  digest = "1:c4a2528ccbcabf90f9f3c464a5fc9e302d592861bbfd0b7135a7de8a943d0406"
   name = "github.com/go-stack/stack"
   packages = ["."]
   pruneopts = "UT"
-  revision = "2fee6af1a9795aafbe0253a0cfbdf668e1fb8a9a"
-  version = "v1.8.0"
+  revision = "259ab82a6cad3992b4e21ff5cac294ccb06474bc"
+  version = "v1.7.0"
 
 [[projects]]
   digest = "1:35621fe20f140f05a0c4ef662c26c0ab4ee50bca78aa30fe87d33120bd28165e"
@@ -136,7 +136,8 @@
   version = "v1.2.0"
 
 [[projects]]
-  digest = "1:ea40c24cdbacd054a6ae9de03e62c5f252479b96c716375aace5c120d68647c8"
+  branch = "master"
+  digest = "1:12247a2e99a060cc692f6680e5272c8adf0b8f572e6bce0d7095e624c958a240"
   name = "github.com/hashicorp/hcl"
   packages = [
     ".",
@@ -150,8 +151,7 @@
     "json/token",
   ]
   pruneopts = "UT"
-  revision = "8cb6e5b959231cc1119e43259c4a608f9c51a241"
-  version = "v1.0.0"
+  revision = "ef8a98b0bbce4a65b5aa4c368430a80ddc533168"
 
 [[projects]]
   digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be"
@@ -193,12 +193,12 @@
   version = "v1.0.1"
 
 [[projects]]
-  digest = "1:53bc4cd4914cd7cd52139990d5170d6dc99067ae31c56530621b18b35fc30318"
+  branch = "master"
+  digest = "1:5ab79470a1d0fb19b041a624415612f8236b3c06070161a910562f2b2d064355"
   name = "github.com/mitchellh/mapstructure"
   packages = ["."]
   pruneopts = "UT"
-  revision = "3536a929edddb9a5b34bd6861dc4a9647cb459fe"
-  version = "v1.1.2"
+  revision = "f15292f7a699fcc1a38a80977f80a046874ba8ac"
 
 [[projects]]
   digest = "1:95741de3af260a92cc5c7f3f3061e85273f5a81b5db20d4bd68da74bd521675e"
@@ -244,7 +244,7 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:db712fde5d12d6cdbdf14b777f0c230f4ff5ab0be8e35b239fc319953ed577a4"
+  digest = "1:63b68062b8968092eb86bedc4e68894bd096ea6b24920faca8b9dcf451f54bb5"
   name = "github.com/prometheus/common"
   packages = [
     "expfmt",
@@ -252,11 +252,11 @@
     "model",
   ]
   pruneopts = "UT"
-  revision = "7e9e6cabbd393fc208072eedef99188d0ce788b6"
+  revision = "c7de2306084e37d54b8be01f3541a8464345e9a5"
 
 [[projects]]
   branch = "master"
-  digest = "1:ef74914912f99c79434d9c09658274678bc85080ebe3ab32bec3940ebce5e1fc"
+  digest = "1:8c49953a1414305f2ff5465147ee576dd705487c35b15918fcd4efdc0cb7a290"
   name = "github.com/prometheus/procfs"
   packages = [
     ".",
@@ -265,7 +265,7 @@
     "xfs",
   ]
   pruneopts = "UT"
-  revision = "185b4288413d2a0dd0806f78c90dde719829e5ae"
+  revision = "05ee40e3a273f7245e8777337fc7b46e533a9a92"
 
 [[projects]]
   digest = "1:c4556a44e350b50a490544d9b06e9fba9c286c21d6c0e47f54f3a9214597298c"
@@ -275,15 +275,15 @@
   revision = "e2704e165165ec55d062f5919b4b29494e9fa790"
 
 [[projects]]
-  digest = "1:6a4a11ba764a56d2758899ec6f3848d24698d48442ebce85ee7a3f63284526cd"
+  digest = "1:bd1ae00087d17c5a748660b8e89e1043e1e5479d0fea743352cda2f8dd8c4f84"
   name = "github.com/spf13/afero"
   packages = [
     ".",
     "mem",
   ]
   pruneopts = "UT"
-  revision = "d40851caa0d747393da1ffb28f7f9d8b4eeffebd"
-  version = "v1.1.2"
+  revision = "787d034dfe70e44075ccc060d346146ef53270ad"
+  version = "v1.1.1"
 
 [[projects]]
   digest = "1:516e71bed754268937f57d4ecb190e01958452336fa73dbac880894164e91c1f"
@@ -302,20 +302,20 @@
   version = "v0.0.1"
 
 [[projects]]
-  digest = "1:68ea4e23713989dc20b1bded5d9da2c5f9be14ff9885beef481848edd18c26cb"
+  branch = "master"
+  digest = "1:080e5f630945ad754f4b920e60b4d3095ba0237ebf88dc462eb28002932e3805"
   name = "github.com/spf13/jwalterweatherman"
   packages = ["."]
   pruneopts = "UT"
-  revision = "4a4406e478ca629068e7768fc33f3f044173c0a6"
-  version = "v1.0.0"
+  revision = "7c0cea34c8ece3fbeb2b27ab9b59511d360fb394"
 
 [[projects]]
-  digest = "1:c1b1102241e7f645bc8e0c22ae352e8f0dc6484b6cb4d132fa9f24174e0119e2"
+  digest = "1:9424f440bba8f7508b69414634aef3b2b3a877e522d8a4624692412805407bb7"
   name = "github.com/spf13/pflag"
   packages = ["."]
   pruneopts = "UT"
-  revision = "298182f68c66c05229eb03ac171abe6e309ee79a"
-  version = "v1.0.3"
+  revision = "583c0c0531f06d5278b7d917446061adc344b5cd"
+  version = "v1.0.1"
 
 [[projects]]
   digest = "1:f8e1a678a2571e265f4bf91a3e5e32aa6b1474a55cb0ea849750cc177b664d96"
@@ -338,7 +338,7 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:59483b8e8183f10ab21a85ba1f4cbb4a2335d48891801f79ed7b9499f44d383c"
+  digest = "1:b3cfb8d82b1601a846417c3f31c03a7961862cb2c98dcf0959c473843e6d9a2b"
   name = "github.com/syndtr/goleveldb"
   packages = [
     "leveldb",
@@ -355,7 +355,7 @@
     "leveldb/util",
   ]
   pruneopts = "UT"
-  revision = "6b91fda63f2e36186f1c9d0e48578defb69c5d43"
+  revision = "c4c61651e9e37fa117f53c5a906d3b63090d8445"
 
 [[projects]]
   digest = "1:605b6546f3f43745695298ec2d342d3e952b6d91cdf9f349bea9315f677d759f"
@@ -365,12 +365,12 @@
   revision = "e5840949ff4fff0c56f9b6a541e22b63581ea9df"
 
 [[projects]]
-  digest = "1:5f52e817b6c9d52ddba70dece0ea31134d82a52c05bce98fbc739ab2a832df28"
+  digest = "1:e0a2a4be1e20c305badc2b0a7a9ab7fef6da500763bec23ab81df3b5f9eec9ee"
   name = "github.com/tendermint/go-amino"
   packages = ["."]
   pruneopts = "UT"
-  revision = "cb07448b240918aa8d8df4505153549b86b77134"
-  version = "v0.13.0"
+  revision = "a8328986c1608950fa5d3d1c0472cccc4f8fc02c"
+  version = "v0.12.0-rc0"
 
 [[projects]]
   digest = "1:72b71e3a29775e5752ed7a8012052a3dee165e27ec18cedddae5288058f09acf"
@@ -415,14 +415,14 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:d1da39c9bac61327dbef1d8ef9f210425e99fd2924b6fb5f0bc587a193353637"
+  digest = "1:bb0fe59917bdd5b89f49b9a8b26e5f465e325d9223b3a8e32254314bdf51e0f1"
   name = "golang.org/x/sys"
   packages = [
     "cpu",
     "unix",
   ]
   pruneopts = "UT"
-  revision = "8a28ead16f52c8aaeffbf79239b251dfdf6c4f96"
+  revision = "3dc4335d56c789b04b0ba99b7a37249d9b614314"
 
 [[projects]]
   digest = "1:a2ab62866c75542dd18d2b069fec854577a20211d7c0ea6ae746072a1dccdd18"
@@ -449,11 +449,11 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:56b0bca90b7e5d1facf5fbdacba23e4e0ce069d25381b8e2f70ef1e7ebfb9c1a"
+  digest = "1:077c1c599507b3b3e9156d17d36e1e61928ee9b53a5b420f10f28ebd4a0b275c"
   name = "google.golang.org/genproto"
   packages = ["googleapis/rpc/status"]
   pruneopts = "UT"
-  revision = "94acd270e44e65579b9ee3cdab25034d33fed608"
+  revision = "daca94659cb50e9f37c1b834680f2e46358f10b0"
 
 [[projects]]
   digest = "1:2dab32a43451e320e49608ff4542fdfc653c95dcc35d0065ec9c6c3dd540ed74"
@@ -517,6 +517,7 @@
     "github.com/gogo/protobuf/proto",
     "github.com/gogo/protobuf/types",
     "github.com/golang/protobuf/proto",
+    "github.com/golang/protobuf/ptypes/duration",
     "github.com/golang/protobuf/ptypes/timestamp",
     "github.com/gorilla/websocket",
     "github.com/jmhodges/levigo",

Gopkg.toml

@@ -58,7 +58,7 @@
 
 [[constraint]]
   name = "github.com/tendermint/go-amino"
-  version = "v0.13.0"
+  version = "v0.12.0-rc0"
 
 [[constraint]]
   name = "google.golang.org/grpc"

Makefile

@@ -44,7 +44,7 @@ protoc_all: protoc_libs protoc_merkle protoc_abci protoc_grpc
 	## See https://stackoverflow.com/a/25518702
 	## Note the $< here is substituted for the %.proto
 	## Note the $@ here is substituted for the %.pb.go
-	protoc $(INCLUDE) $< --gogo_out=Mgoogle/protobuf/timestamp.proto=github.com/golang/protobuf/ptypes/timestamp,plugins=grpc:.
+	protoc $(INCLUDE) $< --gogo_out=Mgoogle/protobuf/timestamp.proto=github.com/golang/protobuf/ptypes/timestamp,Mgoogle/protobuf/duration.proto=github.com/golang/protobuf/ptypes/duration,plugins=grpc:.
 
 ########################################
 ### Build ABCI

UPGRADING.md

@@ -3,82 +3,6 @@
 This guide provides steps to be followed when you upgrade your applications to
 a newer version of Tendermint Core.
 
-## v0.26.0
-
-New 0.26.0 release contains a lot of changes to core data types. It is not
-compatible to the old versions and there is no straight forward way to update
-old data to be compatible with the new version.
-
-To reset the state do:
-
-```
-$ tendermint unsafe_reset_all
-```
-
-Here we summarize some other notable changes to be mindful of.
-
-### Config Changes
-
-All timeouts must be changed from integers to strings with their duration, for
-instance `flush_throttle_timeout = 100` would be changed to
-`flush_throttle_timeout = "100ms"` and `timeout_propose = 3000` would be changed
-to `timeout_propose = "3s"`.
-
-### RPC Changes
-
-The default behaviour of `/abci_query` has been changed to not return a proof,
-and the name of the parameter that controls this has been changed from `trusted`
-to `prove`. To get proofs with your queries, ensure you set `prove=true`.
-
-Various version fields like `amino_version`, `p2p_version`, `consensus_version`,
-and `rpc_version` have been removed from the `node_info.other` and are
-consolidated under the tendermint semantic version (ie. `node_info.version`) and
-the new `block` and `p2p` protocol versions under `node_info.protocol_version`..
-
-### ABCI Changes
-
-Field numbers were bumped in the `Header` and `ResponseInfo` messages to make
-room for new `version` fields. It should be straight forward to recompile the
-protobuf file for these changes.
-
-#### Proofs
-
-The `ResponseQuery.Proof` field is now structured as a `[]ProofOp` to support
-generalized Merkle tree constructions where the leaves of one Merkle tree are
-the root of another. If you don't need this functionaluty, and you used to
-return `<proof bytes>` here, you should instead return a single `ProofOp` with
-just the `Data` field set:
-
-```
-[]ProofOp{
-    ProofOp{
-        Data: <proof bytes>,
-    }
-}
-```
-
-For more information, see:
-
-- [ADR-026](https://github.com/tendermint/tendermint/blob/30519e8361c19f4bf320ef4d26288ebc621ad725/docs/architecture/adr-026-general-merkle-proof.md)
-- [Relevant ABCI
-  documentation](https://github.com/tendermint/tendermint/blob/30519e8361c19f4bf320ef4d26288ebc621ad725/docs/spec/abci/apps.md#query-proofs)
-- [Description of
-  keys](https://github.com/tendermint/tendermint/blob/30519e8361c19f4bf320ef4d26288ebc621ad725/crypto/merkle/proof_key_path.go#L14)
-
-### Go API Changes
-
-#### crypto.merkle
-
-The `merkle.Hasher` interface was removed. Functions which used to take `Hasher`
-now simply take `[]byte`. This means that any objects being Merklized should be
-serialized before they are passed in.
-
-#### node
-
-The `node.RunForever` function was removed. Signal handling and running forever
-should instead be explicitly configured by the caller. See how we do it
-[here](https://github.com/tendermint/tendermint/blob/30519e8361c19f4bf320ef4d26288ebc621ad725/cmd/tendermint/commands/run_node.go#L60).
-
 ## v0.25.0
 
 This release has minimal impact.

abci/example/kvstore/kvstore.go

@@ -10,14 +10,11 @@ import (
 	"github.com/tendermint/tendermint/abci/types"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	dbm "github.com/tendermint/tendermint/libs/db"
-	"github.com/tendermint/tendermint/version"
 )
 
 var (
 	stateKey        = []byte("stateKey")
 	kvPairPrefixKey = []byte("kvPairKey:")
-
-	ProtocolVersion version.Protocol = 0x1
 )
 
 type State struct {
@@ -68,11 +65,7 @@ func NewKVStoreApplication() *KVStoreApplication {
 }
 
 func (app *KVStoreApplication) Info(req types.RequestInfo) (resInfo types.ResponseInfo) {
-	return types.ResponseInfo{
-		Data:       fmt.Sprintf("{\"size\":%v}", app.state.Size),
-		Version:    version.ABCIVersion,
-		AppVersion: ProtocolVersion.Uint64(),
-	}
+	return types.ResponseInfo{Data: fmt.Sprintf("{\"size\":%v}", app.state.Size)}
 }
 
 // tx is either "key=value" or just arbitrary bytes

abci/types/types.proto

@@ -5,6 +5,7 @@ package types;
 // https://github.com/gogo/protobuf/blob/master/extensions.md
 import "github.com/gogo/protobuf/gogoproto/gogo.proto";
 import "google/protobuf/timestamp.proto";
+import "google/protobuf/duration.proto";
 import "github.com/tendermint/tendermint/libs/common/types.proto";
 import "github.com/tendermint/tendermint/crypto/merkle/merkle.proto";
 
@@ -49,8 +50,6 @@ message RequestFlush {
 
 message RequestInfo {
   string version = 1;
-  uint64 block_version = 2;
-  uint64 p2p_version = 3;
 }
 
 // nondeterministic
@@ -131,12 +130,9 @@ message ResponseFlush {
 
 message ResponseInfo {
   string data = 1;
-
   string version = 2;
-  uint64 app_version = 3;
-
-  int64 last_block_height = 4;
-  bytes last_block_app_hash = 5;
+  int64 last_block_height = 3;
+  bytes last_block_app_hash = 4;
 }
 
 // nondeterministic
@@ -222,8 +218,8 @@ message BlockSize {
 
 // EvidenceParams contains limits on the evidence.
 message EvidenceParams {
-  // Note: must be greater than 0
-  int64 max_age = 1;
+  // Note: must be greater than 0 if provided
+  google.protobuf.Duration max_age = 1 [(gogoproto.nullable)=false, (gogoproto.stdduration)=true];
 }
 
 message LastCommitInfo {
@@ -236,38 +232,31 @@ message LastCommitInfo {
 
 message Header {
   // basic block info
-  Version version = 1 [(gogoproto.nullable)=false];
-  string chain_id = 2 [(gogoproto.customname)="ChainID"];
-  int64 height = 3;
-  google.protobuf.Timestamp time = 4 [(gogoproto.nullable)=false, (gogoproto.stdtime)=true];
-  int64 num_txs = 5;
-  int64 total_txs = 6;
+  string chain_id = 1 [(gogoproto.customname)="ChainID"];
+  int64 height = 2;
+  google.protobuf.Timestamp time = 3 [(gogoproto.nullable)=false, (gogoproto.stdtime)=true];
+  int64 num_txs = 4;
+  int64 total_txs = 5;
 
   // prev block info
-  BlockID last_block_id = 7 [(gogoproto.nullable)=false];
+  BlockID last_block_id = 6 [(gogoproto.nullable)=false];
 
   // hashes of block data
-  bytes last_commit_hash = 8; // commit from validators from the last block
-  bytes data_hash = 9;        // transactions
+  bytes last_commit_hash = 7; // commit from validators from the last block
+  bytes data_hash = 8;        // transactions
 
   // hashes from the app output from the prev block
-  bytes validators_hash = 10;   // validators for the current block
-  bytes next_validators_hash = 11;   // validators for the next block
-  bytes consensus_hash = 12;   // consensus params for current block
-  bytes app_hash = 13;         // state after txs from the previous block
-  bytes last_results_hash = 14;// root hash of all results from the txs from the previous block
+  bytes validators_hash = 9;   // validators for the current block
+  bytes next_validators_hash = 10;   // validators for the next block
+  bytes consensus_hash = 11;   // consensus params for current block
+  bytes app_hash = 12;         // state after txs from the previous block
+  bytes last_results_hash = 13;// root hash of all results from the txs from the previous block
 
   // consensus info
-  bytes evidence_hash = 15;    // evidence included in the block
-  bytes proposer_address = 16; // original proposer of the block
+  bytes evidence_hash = 14;    // evidence included in the block
+  bytes proposer_address = 15; // original proposer of the block
 }
 
-message Version {
-  uint64 Block = 1;
-  uint64 App = 2;
-}
-
-
 message BlockID {
   bytes hash = 1;
   PartSetHeader parts_header = 2 [(gogoproto.nullable)=false];

abci/types/typespb_test.go

@@ -13,6 +13,7 @@ import golang_proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import math "math"
 import _ "github.com/gogo/protobuf/gogoproto"
+import _ "github.com/golang/protobuf/ptypes/duration"
 import _ "github.com/golang/protobuf/ptypes/timestamp"
 import _ "github.com/tendermint/tendermint/crypto/merkle"
 import _ "github.com/tendermint/tendermint/libs/common"
@@ -1703,62 +1704,6 @@ func TestHeaderMarshalTo(t *testing.T) {
 	}
 }
 
-func TestVersionProto(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedVersion(popr, false)
-	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
-	if err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	msg := &Version{}
-	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	littlefuzz := make([]byte, len(dAtA))
-	copy(littlefuzz, dAtA)
-	for i := range dAtA {
-		dAtA[i] = byte(popr.Intn(256))
-	}
-	if !p.Equal(msg) {
-		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
-	}
-	if len(littlefuzz) > 0 {
-		fuzzamount := 100
-		for i := 0; i < fuzzamount; i++ {
-			littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))
-			littlefuzz = append(littlefuzz, byte(popr.Intn(256)))
-		}
-		// shouldn't panic
-		_ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg)
-	}
-}
-
-func TestVersionMarshalTo(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedVersion(popr, false)
-	size := p.Size()
-	dAtA := make([]byte, size)
-	for i := range dAtA {
-		dAtA[i] = byte(popr.Intn(256))
-	}
-	_, err := p.MarshalTo(dAtA)
-	if err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	msg := &Version{}
-	if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	for i := range dAtA {
-		dAtA[i] = byte(popr.Intn(256))
-	}
-	if !p.Equal(msg) {
-		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
-	}
-}
-
 func TestBlockIDProto(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
@@ -2691,24 +2636,6 @@ func TestHeaderJSON(t *testing.T) {
 		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
 	}
 }
-func TestVersionJSON(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedVersion(popr, true)
-	marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
-	jsondata, err := marshaler.MarshalToString(p)
-	if err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	msg := &Version{}
-	err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
-	if err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	if !p.Equal(msg) {
-		t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
-	}
-}
 func TestBlockIDJSON(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
@@ -3675,34 +3602,6 @@ func TestHeaderProtoCompactText(t *testing.T) {
 	}
 }
 
-func TestVersionProtoText(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedVersion(popr, true)
-	dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
-	msg := &Version{}
-	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	if !p.Equal(msg) {
-		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
-	}
-}
-
-func TestVersionProtoCompactText(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedVersion(popr, true)
-	dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
-	msg := &Version{}
-	if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	if !p.Equal(msg) {
-		t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)
-	}
-}
-
 func TestBlockIDProtoText(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))
@@ -4559,28 +4458,6 @@ func TestHeaderSize(t *testing.T) {
 	}
 }
 
-func TestVersionSize(t *testing.T) {
-	seed := time.Now().UnixNano()
-	popr := math_rand.New(math_rand.NewSource(seed))
-	p := NewPopulatedVersion(popr, true)
-	size2 := github_com_gogo_protobuf_proto.Size(p)
-	dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
-	if err != nil {
-		t.Fatalf("seed = %d, err = %v", seed, err)
-	}
-	size := p.Size()
-	if len(dAtA) != size {
-		t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(dAtA))
-	}
-	if size2 != size {
-		t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)
-	}
-	size3 := github_com_gogo_protobuf_proto.Size(p)
-	if size3 != size {
-		t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)
-	}
-}
-
 func TestBlockIDSize(t *testing.T) {
 	seed := time.Now().UnixNano()
 	popr := math_rand.New(math_rand.NewSource(seed))

benchmarks/codec_test.go

@@ -14,15 +14,14 @@ import (
 
 func testNodeInfo(id p2p.ID) p2p.DefaultNodeInfo {
 	return p2p.DefaultNodeInfo{
-		ProtocolVersion: p2p.ProtocolVersion{1, 2, 3},
-		ID_:             id,
-		Moniker:         "SOMENAME",
-		Network:         "SOMENAME",
-		ListenAddr:      "SOMEADDR",
-		Version:         "SOMEVER",
+		ID_:        id,
+		Moniker:    "SOMENAME",
+		Network:    "SOMENAME",
+		ListenAddr: "SOMEADDR",
+		Version:    "SOMEVER",
 		Other: p2p.DefaultNodeInfoOther{
-			TxIndex:    "on",
-			RPCAddress: "0.0.0.0:26657",
+			AminoVersion: "SOMESTRING",
+			P2PVersion:   "OTHERSTRING",
 		},
 	}
 }

blockchain/reactor_test.go

@@ -206,4 +206,3 @@ func (tp *bcrTestPeer) IsPersistent() bool                   { return true }
 func (tp *bcrTestPeer) Get(s string) interface{}             { return s }
 func (tp *bcrTestPeer) Set(string, interface{})              {}
 func (tp *bcrTestPeer) RemoteIP() net.IP                     { return []byte{127, 0, 0, 1} }
-func (tp *bcrTestPeer) OriginalAddr() *p2p.NetAddress        { return nil }

blockchain/store.go

@@ -63,7 +63,7 @@ func (bs *BlockStore) LoadBlock(height int64) *types.Block {
 		part := bs.LoadBlockPart(height, i)
 		buf = append(buf, part.Bytes...)
 	}
-	err := cdc.UnmarshalBinaryLengthPrefixed(buf, block)
+	err := cdc.UnmarshalBinary(buf, block)
 	if err != nil {
 		// NOTE: The existence of meta should imply the existence of the
 		// block. So, make sure meta is only saved after blocks are saved.

consensus/reactor.go

@@ -8,8 +8,7 @@ import (
 
 	"github.com/pkg/errors"
 
-	"github.com/tendermint/go-amino"
-
+	amino "github.com/tendermint/go-amino"
 	cstypes "github.com/tendermint/tendermint/consensus/types"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	tmevents "github.com/tendermint/tendermint/libs/events"
@@ -429,9 +428,9 @@ func (conR *ConsensusReactor) broadcastHasVoteMessage(vote *types.Vote) {
 
 func makeRoundStepMessages(rs *cstypes.RoundState) (nrsMsg *NewRoundStepMessage, csMsg *CommitStepMessage) {
 	nrsMsg = &NewRoundStepMessage{
-		Height: rs.Height,
-		Round:  rs.Round,
-		Step:   rs.Step,
+		Height:                rs.Height,
+		Round:                 rs.Round,
+		Step:                  rs.Step,
 		SecondsSinceStartTime: int(time.Since(rs.StartTime).Seconds()),
 		LastCommitRound:       rs.LastCommit.Round(),
 	}
@@ -948,8 +947,8 @@ func (ps *PeerState) ToJSON() ([]byte, error) {
 	return cdc.MarshalJSON(ps)
 }
 
-// GetHeight returns an atomic snapshot of the PeerRoundState's height
-// used by the mempool to ensure peers are caught up before broadcasting new txs
+// 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 {
 	ps.mtx.Lock()
 	defer ps.mtx.Unlock()

consensus/replay.go

@@ -11,7 +11,6 @@ import (
 	"time"
 
 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/version"
 	//auto "github.com/tendermint/tendermint/libs/autofile"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	dbm "github.com/tendermint/tendermint/libs/db"
@@ -20,6 +19,7 @@ import (
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
+	"github.com/tendermint/tendermint/version"
 )
 
 var crc32c = crc32.MakeTable(crc32.Castagnoli)
@@ -227,7 +227,7 @@ func (h *Handshaker) NBlocks() int {
 func (h *Handshaker) Handshake(proxyApp proxy.AppConns) error {
 
 	// Handshake is done via ABCI Info on the query conn.
-	res, err := proxyApp.Query().InfoSync(proxy.RequestInfo)
+	res, err := proxyApp.Query().InfoSync(abci.RequestInfo{Version: version.Version})
 	if err != nil {
 		return fmt.Errorf("Error calling Info: %v", err)
 	}
@@ -238,15 +238,9 @@ func (h *Handshaker) Handshake(proxyApp proxy.AppConns) error {
 	}
 	appHash := res.LastBlockAppHash
 
-	h.logger.Info("ABCI Handshake App Info",
-		"height", blockHeight,
-		"hash", fmt.Sprintf("%X", appHash),
-		"software-version", res.Version,
-		"protocol-version", res.AppVersion,
-	)
+	h.logger.Info("ABCI Handshake", "appHeight", blockHeight, "appHash", fmt.Sprintf("%X", appHash))
 
-	// Set AppVersion on the state.
-	h.initialState.Version.Consensus.App = version.Protocol(res.AppVersion)
+	// TODO: check app version.
 
 	// Replay blocks up to the latest in the blockstore.
 	_, err = h.ReplayBlocks(h.initialState, appHash, blockHeight, proxyApp)

consensus/replay_test.go

@@ -20,7 +20,6 @@ import (
 	crypto "github.com/tendermint/tendermint/crypto"
 	auto "github.com/tendermint/tendermint/libs/autofile"
 	dbm "github.com/tendermint/tendermint/libs/db"
-	"github.com/tendermint/tendermint/version"
 
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
@@ -338,7 +337,7 @@ func testHandshakeReplay(t *testing.T, nBlocks int, mode uint) {
 		t.Fatalf(err.Error())
 	}
 
-	stateDB, state, store := stateAndStore(config, privVal.GetPubKey(), kvstore.ProtocolVersion)
+	stateDB, state, store := stateAndStore(config, privVal.GetPubKey())
 	store.chain = chain
 	store.commits = commits
 
@@ -353,7 +352,7 @@ func testHandshakeReplay(t *testing.T, nBlocks int, mode uint) {
 		// run nBlocks against a new client to build up the app state.
 		// use a throwaway tendermint state
 		proxyApp := proxy.NewAppConns(clientCreator2)
-		stateDB, state, _ := stateAndStore(config, privVal.GetPubKey(), kvstore.ProtocolVersion)
+		stateDB, state, _ := stateAndStore(config, privVal.GetPubKey())
 		buildAppStateFromChain(proxyApp, stateDB, state, chain, nBlocks, mode)
 	}
 
@@ -443,7 +442,7 @@ func buildAppStateFromChain(proxyApp proxy.AppConns, stateDB dbm.DB,
 func buildTMStateFromChain(config *cfg.Config, stateDB dbm.DB, state sm.State, chain []*types.Block, mode uint) sm.State {
 	// run the whole chain against this client to build up the tendermint state
 	clientCreator := proxy.NewLocalClientCreator(kvstore.NewPersistentKVStoreApplication(path.Join(config.DBDir(), "1")))
-	proxyApp := proxy.NewAppConns(clientCreator)
+	proxyApp := proxy.NewAppConns(clientCreator) // sm.NewHandshaker(config, state, store, ReplayLastBlock))
 	if err := proxyApp.Start(); err != nil {
 		panic(err)
 	}
@@ -520,7 +519,7 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
 			// if its not the first one, we have a full block
 			if thisBlockParts != nil {
 				var block = new(types.Block)
-				_, err = cdc.UnmarshalBinaryLengthPrefixedReader(thisBlockParts.GetReader(), block, 0)
+				_, err = cdc.UnmarshalBinaryReader(thisBlockParts.GetReader(), block, 0)
 				if err != nil {
 					panic(err)
 				}
@@ -553,7 +552,7 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
 	}
 	// grab the last block too
 	var block = new(types.Block)
-	_, err = cdc.UnmarshalBinaryLengthPrefixedReader(thisBlockParts.GetReader(), block, 0)
+	_, err = cdc.UnmarshalBinaryReader(thisBlockParts.GetReader(), block, 0)
 	if err != nil {
 		panic(err)
 	}
@@ -589,10 +588,9 @@ func readPieceFromWAL(msg *TimedWALMessage) interface{} {
 }
 
 // fresh state and mock store
-func stateAndStore(config *cfg.Config, pubKey crypto.PubKey, appVersion version.Protocol) (dbm.DB, sm.State, *mockBlockStore) {
+func stateAndStore(config *cfg.Config, pubKey crypto.PubKey) (dbm.DB, sm.State, *mockBlockStore) {
 	stateDB := dbm.NewMemDB()
 	state, _ := sm.MakeGenesisStateFromFile(config.GenesisFile())
-	state.Version.Consensus.App = appVersion
 	store := NewMockBlockStore(config, state.ConsensusParams)
 	return stateDB, state, store
 }
@@ -641,7 +639,7 @@ func TestInitChainUpdateValidators(t *testing.T) {
 
 	config := ResetConfig("proxy_test_")
 	privVal := privval.LoadFilePV(config.PrivValidatorFile())
-	stateDB, state, store := stateAndStore(config, privVal.GetPubKey(), 0x0)
+	stateDB, state, store := stateAndStore(config, privVal.GetPubKey())
 
 	oldValAddr := state.Validators.Validators[0].Address
 

consensus/state.go

@@ -1468,7 +1468,7 @@ func (cs *ConsensusState) addProposalBlockPart(msg *BlockPartMessage, peerID p2p
 	}
 	if added && cs.ProposalBlockParts.IsComplete() {
 		// Added and completed!
-		_, err = cdc.UnmarshalBinaryLengthPrefixedReader(
+		_, err = cdc.UnmarshalBinaryReader(
 			cs.ProposalBlockParts.GetReader(),
 			&cs.ProposalBlock,
 			int64(cs.state.ConsensusParams.BlockSize.MaxBytes),

consensus/state_test.go

@@ -949,8 +949,6 @@ func TestProposeValidBlock(t *testing.T) {
 	round = round + 2 // moving to the next round
 
 	ensureNewRound(newRoundCh, height, round)
-	t.Log("### ONTO ROUND 3")
-
 	ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.TimeoutPrecommit.Nanoseconds())
 
 	round = round + 1 // moving to the next round

consensus/version.go

@@ -0,0 +1,11 @@
+package consensus
+
+import "fmt"
+
+// kind of arbitrary
+var Spec = "1"     // async
+var Major = "0"    //
+var Minor = "2"    // replay refactor
+var Revision = "2" // validation -> commit
+
+var Version = fmt.Sprintf("v%s/%s.%s.%s", Spec, Major, Minor, Revision)

consensus/wal_generator.go

@@ -38,8 +38,7 @@ func WALGenerateNBlocks(wr io.Writer, numBlocks int) (err error) {
 
 	/////////////////////////////////////////////////////////////////////////////
 	// COPY PASTE FROM node.go WITH A FEW MODIFICATIONS
-	// NOTE: we can't import node package because of circular dependency.
-	// NOTE: we don't do handshake so need to set state.Version.Consensus.App directly.
+	// NOTE: we can't import node package because of circular dependency
 	privValidatorFile := config.PrivValidatorFile()
 	privValidator := privval.LoadOrGenFilePV(privValidatorFile)
 	genDoc, err := types.GenesisDocFromFile(config.GenesisFile())
@@ -52,7 +51,6 @@ func WALGenerateNBlocks(wr io.Writer, numBlocks int) (err error) {
 	if err != nil {
 		return errors.Wrap(err, "failed to make genesis state")
 	}
-	state.Version.Consensus.App = kvstore.ProtocolVersion
 	blockStore := bc.NewBlockStore(blockStoreDB)
 	proxyApp := proxy.NewAppConns(proxy.NewLocalClientCreator(app))
 	proxyApp.SetLogger(logger.With("module", "proxy"))

crypto/merkle/proof_simple_value.go

@@ -42,7 +42,7 @@ func SimpleValueOpDecoder(pop ProofOp) (ProofOperator, error) {
 		return nil, cmn.NewError("unexpected ProofOp.Type; got %v, want %v", pop.Type, ProofOpSimpleValue)
 	}
 	var op SimpleValueOp // a bit strange as we'll discard this, but it works.
-	err := cdc.UnmarshalBinaryLengthPrefixed(pop.Data, &op)
+	err := cdc.UnmarshalBinary(pop.Data, &op)
 	if err != nil {
 		return nil, cmn.ErrorWrap(err, "decoding ProofOp.Data into SimpleValueOp")
 	}
@@ -50,7 +50,7 @@ func SimpleValueOpDecoder(pop ProofOp) (ProofOperator, error) {
 }
 
 func (op SimpleValueOp) ProofOp() ProofOp {
-	bz := cdc.MustMarshalBinaryLengthPrefixed(op)
+	bz := cdc.MustMarshalBinary(op)
 	return ProofOp{
 		Type: ProofOpSimpleValue,
 		Key:  op.key,

crypto/random.go

@@ -9,11 +9,10 @@ import (
 	"sync"
 
 	"golang.org/x/crypto/chacha20poly1305"
+
+	. "github.com/tendermint/tendermint/libs/common"
 )
 
-// NOTE: This is ignored for now until we have time
-// to properly review the MixEntropy function - https://github.com/tendermint/tendermint/issues/2099.
-//
 // The randomness here is derived from xoring a chacha20 keystream with
 // output from crypto/rand's OS Entropy Reader. (Due to fears of the OS'
 // entropy being backdoored)
@@ -24,13 +23,9 @@ var gRandInfo *randInfo
 
 func init() {
 	gRandInfo = &randInfo{}
-
-	// TODO: uncomment after reviewing MixEntropy -
-	// https://github.com/tendermint/tendermint/issues/2099
-	// gRandInfo.MixEntropy(randBytes(32)) // Init
+	gRandInfo.MixEntropy(randBytes(32)) // Init
 }
 
-// WARNING: This function needs review - https://github.com/tendermint/tendermint/issues/2099.
 // Mix additional bytes of randomness, e.g. from hardware, user-input, etc.
 // It is OK to call it multiple times.  It does not diminish security.
 func MixEntropy(seedBytes []byte) {
@@ -42,28 +37,20 @@ func randBytes(numBytes int) []byte {
 	b := make([]byte, numBytes)
 	_, err := crand.Read(b)
 	if err != nil {
-		panic(err)
+		PanicCrisis(err)
 	}
 	return b
 }
 
-// This only uses the OS's randomness
-func CRandBytes(numBytes int) []byte {
-	return randBytes(numBytes)
-}
-
-/* TODO: uncomment after reviewing MixEntropy - https://github.com/tendermint/tendermint/issues/2099
 // This uses the OS and the Seed(s).
 func CRandBytes(numBytes int) []byte {
-	return randBytes(numBytes)
-		b := make([]byte, numBytes)
-		_, err := gRandInfo.Read(b)
-		if err != nil {
-			panic(err)
-		}
-		return b
+	b := make([]byte, numBytes)
+	_, err := gRandInfo.Read(b)
+	if err != nil {
+		PanicCrisis(err)
+	}
+	return b
 }
-*/
 
 // CRandHex returns a hex encoded string that's floor(numDigits/2) * 2 long.
 //
@@ -73,17 +60,10 @@ func CRandHex(numDigits int) string {
 	return hex.EncodeToString(CRandBytes(numDigits / 2))
 }
 
-// Returns a crand.Reader.
-func CReader() io.Reader {
-	return crand.Reader
-}
-
-/* TODO: uncomment after reviewing MixEntropy - https://github.com/tendermint/tendermint/issues/2099
 // Returns a crand.Reader mixed with user-supplied entropy
 func CReader() io.Reader {
 	return gRandInfo
 }
-*/
 
 //--------------------------------------------------------------------------------
 
@@ -95,7 +75,7 @@ type randInfo struct {
 }
 
 // You can call this as many times as you'd like.
-// XXX/TODO: review - https://github.com/tendermint/tendermint/issues/2099
+// XXX TODO review
 func (ri *randInfo) MixEntropy(seedBytes []byte) {
 	ri.mtx.Lock()
 	defer ri.mtx.Unlock()

docs/app-dev/ecosystem.json

@@ -163,12 +163,6 @@
       "language": "Python",
       "author": "Dave Bryson"
     },
-    {
-      "name": "tm-abci",
-      "url": "https://github.com/SoftblocksCo/tm-abci",
-      "language": "Python",
-      "author": "Softblocks"
-    },
     {
       "name": "Spearmint",
       "url": "https://github.com/dennismckinnon/spearmint",

docs/architecture/adr-016-protocol-versions.md

@@ -96,7 +96,7 @@ Each component of the software is independently versioned in a modular way and i
 
 ## Proposal
 
-Each of BlockVersion, AppVersion, P2PVersion, is a monotonically increasing uint64.
+Each of BlockVersion, AppVersion, P2PVersion, is a monotonically increasing int64.
 
 To use these versions, we need to update the block Header, the p2p NodeInfo, and the ABCI.
 
@@ -106,8 +106,8 @@ Block Header should include a `Version` struct as its first field like:
 
 ```
 type Version struct {
-    Block uint64
-    App uint64
+    Block int64
+    App int64
 }
 ```
 
@@ -130,9 +130,9 @@ NodeInfo should include a Version struct as its first field like:
 
 ```
 type Version struct {
-    P2P uint64
-    Block uint64
-    App uint64
+    P2P int64
+    Block int64
+    App int64
 
     Other []string
 }
@@ -168,9 +168,9 @@ RequestInfo should add support for protocol versions like:
 
 ```
 message RequestInfo {
-  string version
-  uint64 block_version
-  uint64 p2p_version
+  string software_version
+  int64 block_version
+  int64 p2p_version
 }
 ```
 
@@ -180,46 +180,39 @@ Similarly, ResponseInfo should return the versions:
 message ResponseInfo {
   string data
 
-  string version
-  uint64 app_version
+  string software_version
+  int64 app_version
 
   int64 last_block_height
   bytes last_block_app_hash
 }
 ```
 
-The existing `version` fields should be called `software_version` but we leave
-them for now to reduce the number of breaking changes.
-
 #### EndBlock
 
 Updating the version could be done either with new fields or by using the
 existing `tags`. Since we're trying to communicate information that will be
 included in Tendermint block Headers, it should be native to the ABCI, and not
-something embedded through some scheme in the tags. Thus, version updates should
-be communicated through EndBlock.
+something embedded through some scheme in the tags.
 
-EndBlock already contains `ConsensusParams`. We can add version information to
-the ConsensusParams as well:
+ResponseEndBlock will include a new field `version_updates`:
 
 ```
-message ConsensusParams {
+message ResponseEndBlock {
+  repeated Validator validator_updates
+  ConsensusParams consensus_param_updates
+  repeated common.KVPair tags
 
-  BlockSize block_size
-  EvidenceParams evidence_params
-  VersionParams version
+  VersionUpdate version_update
 }
 
-message VersionParams {
-    uint64 block_version
-    uint64 app_version
+message VersionUpdate {
+    int64 app_version
 }
 ```
 
-For now, the `block_version` will be ignored, as we do not allow block version
-to be updated live. If the `app_version` is set, it signals that the app's
-protocol version has changed, and the new `app_version` will be included in the
-`Block.Header.Version.App` for the next block.
+Tendermint will use the information in VersionUpdate for the next block it
+proposes.
 
 ### BlockVersion
 

docs/spec/abci/abci.md

@@ -134,13 +134,10 @@ Commit are included in the header of the next block.
 ### Info
 
 - **Request**:
-  - `Version (string)`: The Tendermint software semantic version
-  - `BlockVersion (uint64)`: The Tendermint Block Protocol version
-  - `P2PVersion (uint64)`: The Tendermint P2P Protocol version
+  - `Version (string)`: The Tendermint version
 - **Response**:
   - `Data (string)`: Some arbitrary information
-  - `Version (string)`: The application software semantic version
-  - `AppVersion (uint64)`: The application protocol version
+  - `Version (Version)`: Version information
   - `LastBlockHeight (int64)`: Latest block for which the app has
     called Commit
   - `LastBlockAppHash ([]byte)`: Latest result of Commit
@@ -148,7 +145,6 @@ Commit are included in the header of the next block.
   - Return information about the application state.
   - Used to sync Tendermint with the application during a handshake
     that happens on startup.
-  - The returned `AppVersion` will be included in the Header of every block.
   - Tendermint expects `LastBlockAppHash` and `LastBlockHeight` to
     be updated during `Commit`, ensuring that `Commit` is never
     called twice for the same block height.
@@ -342,7 +338,6 @@ Commit are included in the header of the next block.
 ### Header
 
 - **Fields**:
-  - `Version (Version)`: Version of the blockchain and the application
   - `ChainID (string)`: ID of the blockchain
   - `Height (int64)`: Height of the block in the chain
   - `Time (google.protobuf.Timestamp)`: Time of the block. It is the proposer's
@@ -368,15 +363,6 @@ Commit are included in the header of the next block.
   - Provides the proposer of the current block, for use in proposer-based
     reward mechanisms.
 
-### Version
-
-- **Fields**:
-  - `Block (uint64)`: Protocol version of the blockchain data structures.
-  - `App (uint64)`: Protocol version of the application.
-- **Usage**:
-  - Block version should be static in the life of a blockchain.
-  - App version may be updated over time by the application.
-
 ### Validator
 
 - **Fields**:
@@ -457,11 +443,10 @@ Commit are included in the header of the next block.
 ### EvidenceParams
 
 - **Fields**:
-  - `MaxAge (int64)`: Max age of evidence, in blocks. Evidence older than this
-    is considered stale and ignored.
+  - `MaxAge (google.protobuf.Duration)`: Max age of evidence. Evidence older
+    than this is considered stale and ignored.
         - This should correspond with an app's "unbonding period" or other
           similar mechanism for handling Nothing-At-Stake attacks.
-        - NOTE: this should change to time (instead of blocks)!
 
 ### Proof
 

docs/spec/blockchain/blockchain.md

@@ -8,7 +8,6 @@ The Tendermint blockchains consists of a short list of basic data types:
 
 - `Block`
 - `Header`
-- `Version`
 - `BlockID`
 - `Time`
 - `Data` (for transactions)
@@ -39,7 +38,6 @@ the data in the current block, the previous block, and the results returned by t
 ```go
 type Header struct {
 	// basic block info
-	Version  Version
 	ChainID  string
 	Height   int64
 	Time     Time
@@ -67,19 +65,6 @@ type Header struct {
 
 Further details on each of these fields is described below.
 
-## Version
-
-The `Version` contains the protocol version for the blockchain and the
-application as two `uint64` values:
-
-```go
-type Version struct {
-    Block   uint64
-    App     uint64
-}
-```
-
-
 ## BlockID
 
 The `BlockID` contains two distinct Merkle roots of the block.
@@ -215,15 +200,6 @@ See [here](https://github.com/tendermint/tendermint/blob/master/docs/spec/blockc
 
 A Header is valid if its corresponding fields are valid.
 
-### Version
-
-```
-block.Version.Block == state.Version.Block
-block.Version.App == state.Version.App
-```
-
-The block version must match the state version.
-
 ### ChainID
 
 ```

docs/spec/blockchain/encoding.md

@@ -216,7 +216,7 @@ 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` containing the hash of each
-field in the struct, in the same order the fields appear in the struct.
+field in the struct sorted by the hash of the field name.
 For `[]struct` arguments, we compute a `[][]byte` by hashing the individual `struct` elements.
 
 ### Simple Merkle Proof
@@ -301,15 +301,16 @@ Where the `"value"` is the base64 encoding of the raw pubkey bytes, and the
 Signed messages (eg. votes, proposals) in the consensus are encoded using Amino.
 
 When signing, the elements of a message are re-ordered so the fixed-length fields
-are first, making it easy to quickly check the type, height, and round.
+are first, making it easy to quickly check the version, height, round, and type.
 The `ChainID` is also appended to the end.
 We call this encoding the SignBytes. For instance, SignBytes for a vote is the Amino encoding of the following struct:
 
 ```go
 type CanonicalVote struct {
-	Type      byte
+	Version   uint64           `binary:"fixed64"`
 	Height    int64            `binary:"fixed64"`
 	Round     int64            `binary:"fixed64"`
+	VoteType  byte
 	Timestamp time.Time
 	BlockID   CanonicalBlockID
 	ChainID   string

docs/spec/blockchain/state.md

@@ -15,7 +15,6 @@ validation.
 
 ```go
 type State struct {
-    Version     Version
     LastResults []Result
     AppHash []byte
 
@@ -102,7 +101,7 @@ type BlockGossip struct {
 }
 
 type EvidenceParams struct {
-	MaxAge int64
+	MaxAge time.Duration
 }
 ```
 
@@ -130,5 +129,5 @@ size of each part is `ConsensusParams.BlockGossip.BlockPartSizeBytes`.
 For evidence in a block to be valid, it must satisfy:
 
 ```
-block.Header.Height - evidence.Height < ConsensusParams.EvidenceParams.MaxAge
+block.Header.Time - evidence.Time < ConsensusParams.EvidenceParams.MaxAge
 ```

docs/spec/p2p/peer.md

@@ -75,25 +75,22 @@ The Tendermint Version Handshake allows the peers to exchange their NodeInfo:
 
 ```golang
 type NodeInfo struct {
-  Version    p2p.Version
   ID         p2p.ID
   ListenAddr string
 
   Network    string
-  SoftwareVersion    string
+  Version    string
   Channels   []int8
 
   Moniker    string
   Other      NodeInfoOther
 }
 
-type Version struct {
-	P2P uint64
-	Block uint64
-	App uint64
-}
-
 type NodeInfoOther struct {
+	AminoVersion     string
+	P2PVersion       string
+	ConsensusVersion string
+	RPCVersion       string
 	TxIndex          string
 	RPCAddress       string
 }
@@ -102,7 +99,8 @@ type NodeInfoOther struct {
 The connection is disconnected if:
 
 - `peer.NodeInfo.ID` is not equal `peerConn.ID`
-- `peer.NodeInfo.Version.Block` does not match ours
+- `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.Network` is not the same as ours
 - `peer.Channels` does not intersect with our known Channels.
 - `peer.NodeInfo.ListenAddr` is malformed or is a DNS host that cannot be

evidence/pool.go

@@ -3,6 +3,7 @@ package evidence
 import (
 	"fmt"
 	"sync"
+	"time"
 
 	clist "github.com/tendermint/tendermint/libs/clist"
 	dbm "github.com/tendermint/tendermint/libs/db"
@@ -84,7 +85,7 @@ func (evpool *EvidencePool) Update(block *types.Block, state sm.State) {
 	evpool.mtx.Unlock()
 
 	// remove evidence from pending and mark committed
-	evpool.MarkEvidenceAsCommitted(block.Height, block.Evidence.Evidence)
+	evpool.MarkEvidenceAsCommitted(block.Evidence.Evidence, block.Time)
 }
 
 // AddEvidence checks the evidence is valid and adds it to the pool.
@@ -117,8 +118,9 @@ func (evpool *EvidencePool) AddEvidence(evidence types.Evidence) (err error) {
 	return nil
 }
 
-// MarkEvidenceAsCommitted marks all the evidence as committed and removes it from the queue.
-func (evpool *EvidencePool) MarkEvidenceAsCommitted(height int64, evidence []types.Evidence) {
+// MarkEvidenceAsCommitted marks all the evidence as committed and removes it
+// from the queue.
+func (evpool *EvidencePool) MarkEvidenceAsCommitted(evidence []types.Evidence, lastBlockTime time.Time) {
 	// make a map of committed evidence to remove from the clist
 	blockEvidenceMap := make(map[string]struct{})
 	for _, ev := range evidence {
@@ -127,20 +129,22 @@ func (evpool *EvidencePool) MarkEvidenceAsCommitted(height int64, evidence []typ
 	}
 
 	// remove committed evidence from the clist
-	maxAge := evpool.State().ConsensusParams.EvidenceParams.MaxAge
-	evpool.removeEvidence(height, maxAge, blockEvidenceMap)
-
+	maxAge := evpool.State().ConsensusParams.EvidenceParams.MaxAge.Duration
+	evpool.removeEvidence(blockEvidenceMap, lastBlockTime, maxAge)
 }
 
-func (evpool *EvidencePool) removeEvidence(height, maxAge int64, blockEvidenceMap map[string]struct{}) {
+func (evpool *EvidencePool) removeEvidence(
+	blockEvidenceMap map[string]struct{},
+	lastBlockTime time.Time,
+	maxAge time.Duration,
+) {
 	for e := evpool.evidenceList.Front(); e != nil; e = e.Next() {
 		ev := e.Value.(types.Evidence)
+		evAge := lastBlockTime.Sub(ev.Time())
 
 		// Remove the evidence if it's already in a block
 		// or if it's now too old.
-		if _, ok := blockEvidenceMap[evMapKey(ev)]; ok ||
-			ev.Height() < height-maxAge {
-
+		if _, ok := blockEvidenceMap[evMapKey(ev)]; ok || evAge > maxAge {
 			// remove from clist
 			evpool.evidenceList.Remove(e)
 			e.DetachPrev()

evidence/pool_test.go

@@ -39,7 +39,7 @@ func initializeValidatorState(valAddr []byte, height int64) dbm.DB {
 		LastHeightValidatorsChanged: 1,
 		ConsensusParams: types.ConsensusParams{
 			EvidenceParams: types.EvidenceParams{
-				MaxAge: 1000000,
+				MaxAge: tmtime.DurationPretty{1000000},
 			},
 		},
 	}

evidence/reactor.go

@@ -91,7 +91,7 @@ func (evR *EvidenceReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
 	}
 }
 
-// SetEventSwitch implements events.Eventable.
+// SetEventBus implements events.Eventable.
 func (evR *EvidenceReactor) SetEventBus(b *types.EventBus) {
 	evR.eventBus = b
 }
@@ -153,28 +153,17 @@ func (evR *EvidenceReactor) broadcastEvidenceRoutine(peer p2p.Peer) {
 // Returns the message to send the peer, or nil if the evidence is invalid for the peer.
 // If message is nil, return true if we should sleep and try again.
 func (evR EvidenceReactor) checkSendEvidenceMessage(peer p2p.Peer, ev types.Evidence) (msg EvidenceMessage, retry bool) {
-
-	// make sure the peer is up to date
-	evHeight := ev.Height()
 	peerState, ok := peer.Get(types.PeerStateKey).(PeerState)
 	if !ok {
 		evR.Logger.Info("Found peer without PeerState", "peer", peer)
 		return nil, true
 	}
 
-	// NOTE: We only send evidence to peers where
-	// peerHeight - maxAge < evidenceHeight < peerHeight
-	maxAge := evR.evpool.State().ConsensusParams.EvidenceParams.MaxAge
+	// NOTE: We only send evidence to peers where evidenceHeight < peerHeight
 	peerHeight := peerState.GetHeight()
-	if peerHeight < evHeight {
+	if peerHeight < ev.Height() {
 		// peer is behind. sleep while he catches up
 		return nil, true
-	} else if peerHeight > evHeight+maxAge {
-		// evidence is too old, skip
-		// NOTE: if evidence is too old for an honest peer,
-		// then we're behind and either it already got committed or it never will!
-		evR.Logger.Info("Not sending peer old evidence", "peerHeight", peerHeight, "evHeight", evHeight, "maxAge", maxAge, "peer", peer)
-		return nil, false
 	}
 
 	// send evidence

evidence/reactor_test.go

@@ -132,7 +132,7 @@ func TestReactorBroadcastEvidence(t *testing.T) {
 	// set the peer height on each reactor
 	for _, r := range reactors {
 		for _, peer := range r.Switch.Peers().List() {
-			ps := peerState{height}
+			ps := testPeerState{height}
 			peer.Set(types.PeerStateKey, ps)
 		}
 	}
@@ -143,11 +143,13 @@ func TestReactorBroadcastEvidence(t *testing.T) {
 	waitForEvidence(t, evList, reactors)
 }
 
-type peerState struct {
+type testPeerState struct {
 	height int64
 }
 
-func (ps peerState) GetHeight() int64 {
+var _ PeerState = (*testPeerState)(nil)
+
+func (ps testPeerState) GetHeight() int64 {
 	return ps.height
 }
 
@@ -165,7 +167,7 @@ func TestReactorSelectiveBroadcast(t *testing.T) {
 	// make reactors from statedb
 	reactors := makeAndConnectEvidenceReactors(config, []dbm.DB{stateDB1, stateDB2})
 	peer := reactors[0].Switch.Peers().List()[0]
-	ps := peerState{height2}
+	ps := testPeerState{height2}
 	peer.Set(types.PeerStateKey, ps)
 
 	// send a bunch of valid evidence to the first reactor's evpool

libs/common/errors.go

@@ -146,7 +146,7 @@ func (err *cmnError) Format(s fmt.State, verb rune) {
 			s.Write([]byte("--= /Error =--\n"))
 		} else {
 			// Write msg.
-			s.Write([]byte(fmt.Sprintf("%v", err.data)))
+			s.Write([]byte(fmt.Sprintf("Error{%v}", err.data))) // TODO tick-esc?
 		}
 	}
 }

libs/common/errors_test.go

@@ -24,7 +24,7 @@ func TestErrorPanic(t *testing.T) {
 	var err = capturePanic()
 
 	assert.Equal(t, pnk{"something"}, err.Data())
-	assert.Equal(t, "{something}", fmt.Sprintf("%v", err))
+	assert.Equal(t, "Error{{something}}", fmt.Sprintf("%v", err))
 	assert.Contains(t, fmt.Sprintf("%#v", err), "This is the message in ErrorWrap(r, message).")
 	assert.Contains(t, fmt.Sprintf("%#v", err), "Stack Trace:\n    0")
 }
@@ -34,7 +34,7 @@ func TestErrorWrapSomething(t *testing.T) {
 	var err = ErrorWrap("something", "formatter%v%v", 0, 1)
 
 	assert.Equal(t, "something", err.Data())
-	assert.Equal(t, "something", fmt.Sprintf("%v", err))
+	assert.Equal(t, "Error{something}", fmt.Sprintf("%v", err))
 	assert.Regexp(t, `formatter01\n`, fmt.Sprintf("%#v", err))
 	assert.Contains(t, fmt.Sprintf("%#v", err), "Stack Trace:\n    0")
 }
@@ -46,7 +46,7 @@ func TestErrorWrapNothing(t *testing.T) {
 	assert.Equal(t,
 		FmtError{"formatter%v%v", []interface{}{0, 1}},
 		err.Data())
-	assert.Equal(t, "formatter01", fmt.Sprintf("%v", err))
+	assert.Equal(t, "Error{formatter01}", fmt.Sprintf("%v", err))
 	assert.Contains(t, fmt.Sprintf("%#v", err), `Data: common.FmtError{format:"formatter%v%v", args:[]interface {}{0, 1}}`)
 	assert.Contains(t, fmt.Sprintf("%#v", err), "Stack Trace:\n    0")
 }
@@ -58,7 +58,7 @@ func TestErrorNewError(t *testing.T) {
 	assert.Equal(t,
 		FmtError{"formatter%v%v", []interface{}{0, 1}},
 		err.Data())
-	assert.Equal(t, "formatter01", fmt.Sprintf("%v", err))
+	assert.Equal(t, "Error{formatter01}", fmt.Sprintf("%v", err))
 	assert.Contains(t, fmt.Sprintf("%#v", err), `Data: common.FmtError{format:"formatter%v%v", args:[]interface {}{0, 1}}`)
 	assert.NotContains(t, fmt.Sprintf("%#v", err), "Stack Trace")
 }
@@ -70,7 +70,7 @@ func TestErrorNewErrorWithStacktrace(t *testing.T) {
 	assert.Equal(t,
 		FmtError{"formatter%v%v", []interface{}{0, 1}},
 		err.Data())
-	assert.Equal(t, "formatter01", fmt.Sprintf("%v", err))
+	assert.Equal(t, "Error{formatter01}", fmt.Sprintf("%v", err))
 	assert.Contains(t, fmt.Sprintf("%#v", err), `Data: common.FmtError{format:"formatter%v%v", args:[]interface {}{0, 1}}`)
 	assert.Contains(t, fmt.Sprintf("%#v", err), "Stack Trace:\n    0")
 }
@@ -85,7 +85,7 @@ func TestErrorNewErrorWithTrace(t *testing.T) {
 	assert.Equal(t,
 		FmtError{"formatter%v%v", []interface{}{0, 1}},
 		err.Data())
-	assert.Equal(t, "formatter01", fmt.Sprintf("%v", err))
+	assert.Equal(t, "Error{formatter01}", fmt.Sprintf("%v", err))
 	assert.Contains(t, fmt.Sprintf("%#v", err), `Data: common.FmtError{format:"formatter%v%v", args:[]interface {}{0, 1}}`)
 	dump := fmt.Sprintf("%#v", err)
 	assert.NotContains(t, dump, "Stack Trace")

lite/dbprovider.go

@@ -56,7 +56,7 @@ func (dbp *DBProvider) SaveFullCommit(fc FullCommit) error {
 	// We might be overwriting what we already have, but
 	// it makes the logic easier for now.
 	vsKey := validatorSetKey(fc.ChainID(), fc.Height())
-	vsBz, err := dbp.cdc.MarshalBinaryLengthPrefixed(fc.Validators)
+	vsBz, err := dbp.cdc.MarshalBinary(fc.Validators)
 	if err != nil {
 		return err
 	}
@@ -64,7 +64,7 @@ func (dbp *DBProvider) SaveFullCommit(fc FullCommit) error {
 
 	// Save the fc.NextValidators.
 	nvsKey := validatorSetKey(fc.ChainID(), fc.Height()+1)
-	nvsBz, err := dbp.cdc.MarshalBinaryLengthPrefixed(fc.NextValidators)
+	nvsBz, err := dbp.cdc.MarshalBinary(fc.NextValidators)
 	if err != nil {
 		return err
 	}
@@ -72,7 +72,7 @@ func (dbp *DBProvider) SaveFullCommit(fc FullCommit) error {
 
 	// Save the fc.SignedHeader
 	shKey := signedHeaderKey(fc.ChainID(), fc.Height())
-	shBz, err := dbp.cdc.MarshalBinaryLengthPrefixed(fc.SignedHeader)
+	shBz, err := dbp.cdc.MarshalBinary(fc.SignedHeader)
 	if err != nil {
 		return err
 	}
@@ -121,7 +121,7 @@ func (dbp *DBProvider) LatestFullCommit(chainID string, minHeight, maxHeight int
 			// Found the latest full commit signed header.
 			shBz := itr.Value()
 			sh := types.SignedHeader{}
-			err := dbp.cdc.UnmarshalBinaryLengthPrefixed(shBz, &sh)
+			err := dbp.cdc.UnmarshalBinary(shBz, &sh)
 			if err != nil {
 				return FullCommit{}, err
 			} else {
@@ -150,7 +150,7 @@ func (dbp *DBProvider) getValidatorSet(chainID string, height int64) (valset *ty
 		err = lerr.ErrUnknownValidators(chainID, height)
 		return
 	}
-	err = dbp.cdc.UnmarshalBinaryLengthPrefixed(vsBz, &valset)
+	err = dbp.cdc.UnmarshalBinary(vsBz, &valset)
 	if err != nil {
 		return
 	}

node/node.go

@@ -32,6 +32,7 @@ import (
 	rpccore "github.com/tendermint/tendermint/rpc/core"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 	grpccore "github.com/tendermint/tendermint/rpc/grpc"
+	"github.com/tendermint/tendermint/rpc/lib"
 	"github.com/tendermint/tendermint/rpc/lib/server"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/state/txindex"
@@ -195,8 +196,8 @@ func NewNode(config *cfg.Config,
 		return nil, fmt.Errorf("Error starting proxy app connections: %v", err)
 	}
 
-	// Create the handshaker, which calls RequestInfo, sets the AppVersion on the state,
-	// and replays any blocks as necessary to sync tendermint with the app.
+	// Create the handshaker, which calls RequestInfo and replays any blocks
+	// as necessary to sync tendermint with the app.
 	consensusLogger := logger.With("module", "consensus")
 	handshaker := cs.NewHandshaker(stateDB, state, blockStore, genDoc)
 	handshaker.SetLogger(consensusLogger)
@@ -204,21 +205,9 @@ func NewNode(config *cfg.Config,
 		return nil, fmt.Errorf("Error during handshake: %v", err)
 	}
 
-	// Reload the state. It will have the Version.Consensus.App set by the
-	// Handshake, and may have other modifications as well (ie. depending on
-	// what happened during block replay).
+	// reload the state (it may have been updated by the handshake)
 	state = sm.LoadState(stateDB)
 
-	// Ensure the state's block version matches that of the software.
-	if state.Version.Consensus.Block != version.BlockProtocol {
-		return nil, fmt.Errorf(
-			"Block version of the software does not match that of the state.\n"+
-				"Got version.BlockProtocol=%v, state.Version.Consensus.Block=%v",
-			version.BlockProtocol,
-			state.Version.Consensus.Block,
-		)
-	}
-
 	// If an address is provided, listen on the socket for a
 	// connection from an external signing process.
 	if config.PrivValidatorListenAddr != "" {
@@ -226,7 +215,7 @@ func NewNode(config *cfg.Config,
 			// TODO: persist this key so external signer
 			// can actually authenticate us
 			privKey = ed25519.GenPrivKey()
-			pvsc    = privval.NewTCPVal(
+			pvsc    = privval.NewSocketPV(
 				logger.With("module", "privval"),
 				config.PrivValidatorListenAddr,
 				privKey,
@@ -362,17 +351,7 @@ func NewNode(config *cfg.Config,
 
 	var (
 		p2pLogger = logger.With("module", "p2p")
-		nodeInfo  = makeNodeInfo(
-			config,
-			nodeKey.ID(),
-			txIndexer,
-			genDoc.ChainID,
-			p2p.NewProtocolVersion(
-				version.P2PProtocol, // global
-				state.Version.Consensus.Block,
-				state.Version.Consensus.App,
-			),
-		)
+		nodeInfo  = makeNodeInfo(config, nodeKey.ID(), txIndexer, genDoc.ChainID)
 	)
 
 	// Setup Transport.
@@ -600,7 +579,7 @@ func (n *Node) OnStop() {
 		}
 	}
 
-	if pvsc, ok := n.privValidator.(*privval.TCPVal); ok {
+	if pvsc, ok := n.privValidator.(*privval.SocketPV); ok {
 		if err := pvsc.Stop(); err != nil {
 			n.Logger.Error("Error stopping priv validator socket client", "err", err)
 		}
@@ -777,17 +756,15 @@ func makeNodeInfo(
 	nodeID p2p.ID,
 	txIndexer txindex.TxIndexer,
 	chainID string,
-	protocolVersion p2p.ProtocolVersion,
 ) p2p.NodeInfo {
 	txIndexerStatus := "on"
 	if _, ok := txIndexer.(*null.TxIndex); ok {
 		txIndexerStatus = "off"
 	}
 	nodeInfo := p2p.DefaultNodeInfo{
-		ProtocolVersion: protocolVersion,
-		ID_:             nodeID,
-		Network:         chainID,
-		Version:         version.TMCoreSemVer,
+		ID_:     nodeID,
+		Network: chainID,
+		Version: version.Version,
 		Channels: []byte{
 			bc.BlockchainChannel,
 			cs.StateChannel, cs.DataChannel, cs.VoteChannel, cs.VoteSetBitsChannel,
@@ -796,8 +773,12 @@ func makeNodeInfo(
 		},
 		Moniker: config.Moniker,
 		Other: p2p.DefaultNodeInfoOther{
-			TxIndex:    txIndexerStatus,
-			RPCAddress: config.RPC.ListenAddress,
+			AminoVersion:     amino.Version,
+			P2PVersion:       p2p.Version,
+			ConsensusVersion: cs.Version,
+			RPCVersion:       fmt.Sprintf("%v/%v", rpc.Version, rpccore.Version),
+			TxIndex:          txIndexerStatus,
+			RPCAddress:       config.RPC.ListenAddress,
 		},
 	}
 

node/node_test.go

@@ -10,11 +10,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/p2p"
-	sm "github.com/tendermint/tendermint/state"
-	"github.com/tendermint/tendermint/version"
 
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/types"
@@ -95,21 +91,3 @@ func TestNodeDelayedStop(t *testing.T) {
 	startTime := tmtime.Now()
 	assert.Equal(t, true, startTime.After(n.GenesisDoc().GenesisTime))
 }
-
-func TestNodeSetAppVersion(t *testing.T) {
-	config := cfg.ResetTestRoot("node_app_version_test")
-
-	// create & start node
-	n, err := DefaultNewNode(config, log.TestingLogger())
-	assert.NoError(t, err, "expected no err on DefaultNewNode")
-
-	// default config uses the kvstore app
-	var appVersion version.Protocol = kvstore.ProtocolVersion
-
-	// check version is set in state
-	state := sm.LoadState(n.stateDB)
-	assert.Equal(t, state.Version.Consensus.App, appVersion)
-
-	// check version is set in node info
-	assert.Equal(t, n.nodeInfo.(p2p.DefaultNodeInfo).ProtocolVersion.App, appVersion)
-}

p2p/conn/connection.go

@@ -337,7 +337,7 @@ FOR_LOOP:
 			}
 		case <-c.pingTimer.Chan():
 			c.Logger.Debug("Send Ping")
-			_n, err = cdc.MarshalBinaryLengthPrefixedWriter(c.bufConnWriter, PacketPing{})
+			_n, err = cdc.MarshalBinaryWriter(c.bufConnWriter, PacketPing{})
 			if err != nil {
 				break SELECTION
 			}
@@ -359,7 +359,7 @@ FOR_LOOP:
 			}
 		case <-c.pong:
 			c.Logger.Debug("Send Pong")
-			_n, err = cdc.MarshalBinaryLengthPrefixedWriter(c.bufConnWriter, PacketPong{})
+			_n, err = cdc.MarshalBinaryWriter(c.bufConnWriter, PacketPong{})
 			if err != nil {
 				break SELECTION
 			}
@@ -477,7 +477,7 @@ FOR_LOOP:
 		var packet Packet
 		var _n int64
 		var err error
-		_n, err = cdc.UnmarshalBinaryLengthPrefixedReader(c.bufConnReader, &packet, int64(c._maxPacketMsgSize))
+		_n, err = cdc.UnmarshalBinaryReader(c.bufConnReader, &packet, int64(c._maxPacketMsgSize))
 		c.recvMonitor.Update(int(_n))
 		if err != nil {
 			if c.IsRunning() {
@@ -553,7 +553,7 @@ func (c *MConnection) stopPongTimer() {
 // maxPacketMsgSize returns a maximum size of PacketMsg, including the overhead
 // of amino encoding.
 func (c *MConnection) maxPacketMsgSize() int {
-	return len(cdc.MustMarshalBinaryLengthPrefixed(PacketMsg{
+	return len(cdc.MustMarshalBinary(PacketMsg{
 		ChannelID: 0x01,
 		EOF:       1,
 		Bytes:     make([]byte, c.config.MaxPacketMsgPayloadSize),
@@ -723,7 +723,7 @@ func (ch *Channel) nextPacketMsg() PacketMsg {
 // Not goroutine-safe
 func (ch *Channel) writePacketMsgTo(w io.Writer) (n int64, err error) {
 	var packet = ch.nextPacketMsg()
-	n, err = cdc.MarshalBinaryLengthPrefixedWriter(w, packet)
+	n, err = cdc.MarshalBinaryWriter(w, packet)
 	atomic.AddInt64(&ch.recentlySent, n)
 	return
 }

p2p/conn/connection_test.go

@@ -140,7 +140,7 @@ func TestMConnectionPongTimeoutResultsInError(t *testing.T) {
 	go func() {
 		// read ping
 		var pkt PacketPing
-		_, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
+		_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize)
 		assert.Nil(t, err)
 		serverGotPing <- struct{}{}
 	}()
@@ -176,22 +176,22 @@ func TestMConnectionMultiplePongsInTheBeginning(t *testing.T) {
 	defer mconn.Stop()
 
 	// sending 3 pongs in a row (abuse)
-	_, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
+	_, err = server.Write(cdc.MustMarshalBinary(PacketPong{}))
 	require.Nil(t, err)
-	_, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
+	_, err = server.Write(cdc.MustMarshalBinary(PacketPong{}))
 	require.Nil(t, err)
-	_, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
+	_, err = server.Write(cdc.MustMarshalBinary(PacketPong{}))
 	require.Nil(t, err)
 
 	serverGotPing := make(chan struct{})
 	go func() {
 		// read ping (one byte)
 		var packet, err = Packet(nil), error(nil)
-		_, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &packet, maxPingPongPacketSize)
+		_, err = cdc.UnmarshalBinaryReader(server, &packet, maxPingPongPacketSize)
 		require.Nil(t, err)
 		serverGotPing <- struct{}{}
 		// respond with pong
-		_, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
+		_, err = server.Write(cdc.MustMarshalBinary(PacketPong{}))
 		require.Nil(t, err)
 	}()
 	<-serverGotPing
@@ -227,18 +227,18 @@ func TestMConnectionMultiplePings(t *testing.T) {
 
 	// sending 3 pings in a row (abuse)
 	// see https://github.com/tendermint/tendermint/issues/1190
-	_, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPing{}))
+	_, err = server.Write(cdc.MustMarshalBinary(PacketPing{}))
 	require.Nil(t, err)
 	var pkt PacketPong
-	_, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
+	_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize)
 	require.Nil(t, err)
-	_, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPing{}))
+	_, err = server.Write(cdc.MustMarshalBinary(PacketPing{}))
 	require.Nil(t, err)
-	_, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
+	_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize)
 	require.Nil(t, err)
-	_, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPing{}))
+	_, err = server.Write(cdc.MustMarshalBinary(PacketPing{}))
 	require.Nil(t, err)
-	_, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
+	_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize)
 	require.Nil(t, err)
 
 	assert.True(t, mconn.IsRunning())
@@ -270,20 +270,20 @@ func TestMConnectionPingPongs(t *testing.T) {
 	go func() {
 		// read ping
 		var pkt PacketPing
-		_, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
+		_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize)
 		require.Nil(t, err)
 		serverGotPing <- struct{}{}
 		// respond with pong
-		_, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
+		_, err = server.Write(cdc.MustMarshalBinary(PacketPong{}))
 		require.Nil(t, err)
 
 		time.Sleep(mconn.config.PingInterval)
 
 		// read ping
-		_, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
+		_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize)
 		require.Nil(t, err)
 		// respond with pong
-		_, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
+		_, err = server.Write(cdc.MustMarshalBinary(PacketPong{}))
 		require.Nil(t, err)
 	}()
 	<-serverGotPing
@@ -380,7 +380,7 @@ func TestMConnectionReadErrorBadEncoding(t *testing.T) {
 	client := mconnClient.conn
 
 	// send badly encoded msgPacket
-	bz := cdc.MustMarshalBinaryLengthPrefixed(PacketMsg{})
+	bz := cdc.MustMarshalBinary(PacketMsg{})
 	bz[4] += 0x01 // Invalid prefix bytes.
 
 	// Write it.
@@ -428,7 +428,7 @@ func TestMConnectionReadErrorLongMessage(t *testing.T) {
 		EOF:       1,
 		Bytes:     make([]byte, mconnClient.config.MaxPacketMsgPayloadSize),
 	}
-	_, err = cdc.MarshalBinaryLengthPrefixedWriter(buf, packet)
+	_, err = cdc.MarshalBinaryWriter(buf, packet)
 	assert.Nil(t, err)
 	_, err = client.Write(buf.Bytes())
 	assert.Nil(t, err)
@@ -441,7 +441,7 @@ func TestMConnectionReadErrorLongMessage(t *testing.T) {
 		EOF:       1,
 		Bytes:     make([]byte, mconnClient.config.MaxPacketMsgPayloadSize+100),
 	}
-	_, err = cdc.MarshalBinaryLengthPrefixedWriter(buf, packet)
+	_, err = cdc.MarshalBinaryWriter(buf, packet)
 	assert.Nil(t, err)
 	_, err = client.Write(buf.Bytes())
 	assert.NotNil(t, err)

p2p/conn/secret_connection.go

@@ -211,7 +211,7 @@ func shareEphPubKey(conn io.ReadWriteCloser, locEphPub *[32]byte) (remEphPub *[3
 	// Send our pubkey and receive theirs in tandem.
 	var trs, _ = cmn.Parallel(
 		func(_ int) (val interface{}, err error, abort bool) {
-			var _, err1 = cdc.MarshalBinaryLengthPrefixedWriter(conn, locEphPub)
+			var _, err1 = cdc.MarshalBinaryWriter(conn, locEphPub)
 			if err1 != nil {
 				return nil, err1, true // abort
 			}
@@ -219,7 +219,7 @@ func shareEphPubKey(conn io.ReadWriteCloser, locEphPub *[32]byte) (remEphPub *[3
 		},
 		func(_ int) (val interface{}, err error, abort bool) {
 			var _remEphPub [32]byte
-			var _, err2 = cdc.UnmarshalBinaryLengthPrefixedReader(conn, &_remEphPub, 1024*1024) // TODO
+			var _, err2 = cdc.UnmarshalBinaryReader(conn, &_remEphPub, 1024*1024) // TODO
 			if err2 != nil {
 				return nil, err2, true // abort
 			}
@@ -305,7 +305,7 @@ func shareAuthSignature(sc *SecretConnection, pubKey crypto.PubKey, signature []
 	// Send our info and receive theirs in tandem.
 	var trs, _ = cmn.Parallel(
 		func(_ int) (val interface{}, err error, abort bool) {
-			var _, err1 = cdc.MarshalBinaryLengthPrefixedWriter(sc, authSigMessage{pubKey, signature})
+			var _, err1 = cdc.MarshalBinaryWriter(sc, authSigMessage{pubKey, signature})
 			if err1 != nil {
 				return nil, err1, true // abort
 			}
@@ -313,7 +313,7 @@ func shareAuthSignature(sc *SecretConnection, pubKey crypto.PubKey, signature []
 		},
 		func(_ int) (val interface{}, err error, abort bool) {
 			var _recvMsg authSigMessage
-			var _, err2 = cdc.UnmarshalBinaryLengthPrefixedReader(sc, &_recvMsg, 1024*1024) // TODO
+			var _, err2 = cdc.UnmarshalBinaryReader(sc, &_recvMsg, 1024*1024) // TODO
 			if err2 != nil {
 				return nil, err2, true // abort
 			}

p2p/dummy/peer.go

@@ -78,8 +78,3 @@ func (p *peer) Get(key string) interface{} {
 	}
 	return nil
 }
-
-// OriginalAddr always returns nil.
-func (p *peer) OriginalAddr() *p2p.NetAddress {
-	return nil
-}

p2p/metrics.go

@@ -62,7 +62,7 @@ func PrometheusMetrics(namespace string) *Metrics {
 // NopMetrics returns no-op Metrics.
 func NopMetrics() *Metrics {
 	return &Metrics{
-		Peers: discard.NewGauge(),
+		Peers:                 discard.NewGauge(),
 		PeerReceiveBytesTotal: discard.NewCounter(),
 		PeerSendBytesTotal:    discard.NewCounter(),
 		PeerPendingSendBytes:  discard.NewGauge(),

p2p/node_info.go

@@ -3,9 +3,9 @@ package p2p
 import (
 	"fmt"
 	"reflect"
+	"strings"
 
 	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/version"
 )
 
 const (
@@ -18,10 +18,8 @@ func MaxNodeInfoSize() int {
 	return maxNodeInfoSize
 }
 
-//-------------------------------------------------------------
-
 // NodeInfo exposes basic info of a node
-// and determines if we're compatible.
+// and determines if we're compatible
 type NodeInfo interface {
 	nodeInfoAddress
 	nodeInfoTransport
@@ -33,49 +31,16 @@ type nodeInfoAddress interface {
 	NetAddress() *NetAddress
 }
 
-// nodeInfoTransport validates a nodeInfo and checks
+// nodeInfoTransport is validates a nodeInfo and checks
 // our compatibility with it. It's for use in the handshake.
 type nodeInfoTransport interface {
 	ValidateBasic() error
 	CompatibleWith(other NodeInfo) error
 }
 
-//-------------------------------------------------------------
-
-// ProtocolVersion contains the protocol versions for the software.
-type ProtocolVersion struct {
-	P2P   version.Protocol `json:"p2p"`
-	Block version.Protocol `json:"block"`
-	App   version.Protocol `json:"app"`
-}
-
-// defaultProtocolVersion populates the Block and P2P versions using
-// the global values, but not the App.
-var defaultProtocolVersion = NewProtocolVersion(
-	version.P2PProtocol,
-	version.BlockProtocol,
-	0,
-)
-
-// NewProtocolVersion returns a fully populated ProtocolVersion.
-func NewProtocolVersion(p2p, block, app version.Protocol) ProtocolVersion {
-	return ProtocolVersion{
-		P2P:   p2p,
-		Block: block,
-		App:   app,
-	}
-}
-
-//-------------------------------------------------------------
-
-// Assert DefaultNodeInfo satisfies NodeInfo
-var _ NodeInfo = DefaultNodeInfo{}
-
 // DefaultNodeInfo is the basic node information exchanged
 // between two peers during the Tendermint P2P handshake.
 type DefaultNodeInfo struct {
-	ProtocolVersion ProtocolVersion `json:"protocol_version"`
-
 	// Authenticate
 	// TODO: replace with NetAddress
 	ID_        ID     `json:"id"`          // authenticated identifier
@@ -94,8 +59,12 @@ type DefaultNodeInfo struct {
 
 // DefaultNodeInfoOther is the misc. applcation specific data
 type DefaultNodeInfoOther struct {
-	TxIndex    string `json:"tx_index"`
-	RPCAddress string `json:"rpc_address"`
+	AminoVersion     string `json:"amino_version"`
+	P2PVersion       string `json:"p2p_version"`
+	ConsensusVersion string `json:"consensus_version"`
+	RPCVersion       string `json:"rpc_version"`
+	TxIndex          string `json:"tx_index"`
+	RPCAddress       string `json:"rpc_address"`
 }
 
 // ID returns the node's peer ID.
@@ -117,28 +86,35 @@ func (info DefaultNodeInfo) ID() ID {
 // url-encoding), and we just need to be careful with how we handle that in our
 // clients. (e.g. off by default).
 func (info DefaultNodeInfo) ValidateBasic() error {
-
-	// ID is already validated.
-
-	// Validate ListenAddr.
-	_, err := NewNetAddressString(IDAddressString(info.ID(), info.ListenAddr))
-	if err != nil {
-		return err
-	}
-
-	// Network is validated in CompatibleWith.
-
-	// Validate Version
-	if len(info.Version) > 0 &&
-		(!cmn.IsASCIIText(info.Version) || cmn.ASCIITrim(info.Version) == "") {
-
-		return fmt.Errorf("info.Version must be valid ASCII text without tabs, but got %v", info.Version)
-	}
-
-	// Validate Channels - ensure max and check for duplicates.
 	if len(info.Channels) > maxNumChannels {
 		return fmt.Errorf("info.Channels is too long (%v). Max is %v", len(info.Channels), maxNumChannels)
 	}
+
+	// Sanitize ASCII text fields.
+	if !cmn.IsASCIIText(info.Moniker) || cmn.ASCIITrim(info.Moniker) == "" {
+		return fmt.Errorf("info.Moniker must be valid non-empty ASCII text without tabs, but got %v", info.Moniker)
+	}
+
+	// Sanitize versions
+	// XXX: Should we be more strict about version and address formats?
+	other := info.Other
+	versions := []string{
+		other.AminoVersion,
+		other.P2PVersion,
+		other.ConsensusVersion,
+		other.RPCVersion}
+	for i, v := range versions {
+		if cmn.ASCIITrim(v) != "" && !cmn.IsASCIIText(v) {
+			return fmt.Errorf("info.Other[%d]=%v must be valid non-empty ASCII text without tabs", i, v)
+		}
+	}
+	if cmn.ASCIITrim(other.TxIndex) != "" && (other.TxIndex != "on" && other.TxIndex != "off") {
+		return fmt.Errorf("info.Other.TxIndex should be either 'on' or 'off', got '%v'", other.TxIndex)
+	}
+	if cmn.ASCIITrim(other.RPCAddress) != "" && !cmn.IsASCIIText(other.RPCAddress) {
+		return fmt.Errorf("info.Other.RPCAddress=%v must be valid non-empty ASCII text without tabs", other.RPCAddress)
+	}
+
 	channels := make(map[byte]struct{})
 	for _, ch := range info.Channels {
 		_, ok := channels[ch]
@@ -148,30 +124,13 @@ func (info DefaultNodeInfo) ValidateBasic() error {
 		channels[ch] = struct{}{}
 	}
 
-	// Validate Moniker.
-	if !cmn.IsASCIIText(info.Moniker) || cmn.ASCIITrim(info.Moniker) == "" {
-		return fmt.Errorf("info.Moniker must be valid non-empty ASCII text without tabs, but got %v", info.Moniker)
-	}
-
-	// Validate Other.
-	other := info.Other
-	txIndex := other.TxIndex
-	switch txIndex {
-	case "", "on", "off":
-	default:
-		return fmt.Errorf("info.Other.TxIndex should be either 'on', 'off', or empty string, got '%v'", txIndex)
-	}
-	// XXX: Should we be more strict about address formats?
-	rpcAddr := other.RPCAddress
-	if len(rpcAddr) > 0 && (!cmn.IsASCIIText(rpcAddr) || cmn.ASCIITrim(rpcAddr) == "") {
-		return fmt.Errorf("info.Other.RPCAddress=%v must be valid ASCII text without tabs", rpcAddr)
-	}
-
-	return nil
+	// ensure ListenAddr is good
+	_, err := NewNetAddressString(IDAddressString(info.ID(), info.ListenAddr))
+	return err
 }
 
 // CompatibleWith checks if two DefaultNodeInfo are compatible with eachother.
-// CONTRACT: two nodes are compatible if the Block version and network match
+// CONTRACT: two nodes are compatible if the major version matches and network match
 // and they have at least one channel in common.
 func (info DefaultNodeInfo) CompatibleWith(other_ NodeInfo) error {
 	other, ok := other_.(DefaultNodeInfo)
@@ -179,9 +138,22 @@ func (info DefaultNodeInfo) CompatibleWith(other_ NodeInfo) error {
 		return fmt.Errorf("wrong NodeInfo type. Expected DefaultNodeInfo, got %v", reflect.TypeOf(other_))
 	}
 
-	if info.ProtocolVersion.Block != other.ProtocolVersion.Block {
-		return fmt.Errorf("Peer is on a different Block version. Got %v, expected %v",
-			other.ProtocolVersion.Block, info.ProtocolVersion.Block)
+	iMajor, _, _, iErr := splitVersion(info.Version)
+	oMajor, _, _, oErr := splitVersion(other.Version)
+
+	// if our own version number is not formatted right, we messed up
+	if iErr != nil {
+		return iErr
+	}
+
+	// version number must be formatted correctly ("x.x.x")
+	if oErr != nil {
+		return oErr
+	}
+
+	// major version must match
+	if iMajor != oMajor {
+		return fmt.Errorf("Peer is on a different major version. Got %v, expected %v", oMajor, iMajor)
 	}
 
 	// nodes must be on the same network
@@ -229,3 +201,11 @@ func (info DefaultNodeInfo) NetAddress() *NetAddress {
 	}
 	return netAddr
 }
+
+func splitVersion(version string) (string, string, string, error) {
+	spl := strings.Split(version, ".")
+	if len(spl) != 3 {
+		return "", "", "", fmt.Errorf("Invalid version format %v", version)
+	}
+	return spl[0], spl[1], spl[2], nil
+}

p2p/node_info_test.go

@@ -1,123 +0,0 @@
-package p2p
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/tendermint/tendermint/crypto/ed25519"
-)
-
-func TestNodeInfoValidate(t *testing.T) {
-
-	// empty fails
-	ni := DefaultNodeInfo{}
-	assert.Error(t, ni.ValidateBasic())
-
-	channels := make([]byte, maxNumChannels)
-	for i := 0; i < maxNumChannels; i++ {
-		channels[i] = byte(i)
-	}
-	dupChannels := make([]byte, 5)
-	copy(dupChannels[:], channels[:5])
-	dupChannels = append(dupChannels, testCh)
-
-	nonAscii := "¢§µ"
-	emptyTab := fmt.Sprintf("\t")
-	emptySpace := fmt.Sprintf("  ")
-
-	testCases := []struct {
-		testName         string
-		malleateNodeInfo func(*DefaultNodeInfo)
-		expectErr        bool
-	}{
-		{"Too Many Channels", func(ni *DefaultNodeInfo) { ni.Channels = append(channels, byte(maxNumChannels)) }, true},
-		{"Duplicate Channel", func(ni *DefaultNodeInfo) { ni.Channels = dupChannels }, true},
-		{"Good Channels", func(ni *DefaultNodeInfo) { ni.Channels = ni.Channels[:5] }, false},
-
-		{"Invalid NetAddress", func(ni *DefaultNodeInfo) { ni.ListenAddr = "not-an-address" }, true},
-		{"Good NetAddress", func(ni *DefaultNodeInfo) { ni.ListenAddr = "0.0.0.0:26656" }, false},
-
-		{"Non-ASCII Version", func(ni *DefaultNodeInfo) { ni.Version = nonAscii }, true},
-		{"Empty tab Version", func(ni *DefaultNodeInfo) { ni.Version = emptyTab }, true},
-		{"Empty space Version", func(ni *DefaultNodeInfo) { ni.Version = emptySpace }, true},
-		{"Empty Version", func(ni *DefaultNodeInfo) { ni.Version = "" }, false},
-
-		{"Non-ASCII Moniker", func(ni *DefaultNodeInfo) { ni.Moniker = nonAscii }, true},
-		{"Empty tab Moniker", func(ni *DefaultNodeInfo) { ni.Moniker = emptyTab }, true},
-		{"Empty space Moniker", func(ni *DefaultNodeInfo) { ni.Moniker = emptySpace }, true},
-		{"Empty Moniker", func(ni *DefaultNodeInfo) { ni.Moniker = "" }, true},
-		{"Good Moniker", func(ni *DefaultNodeInfo) { ni.Moniker = "hey its me" }, false},
-
-		{"Non-ASCII TxIndex", func(ni *DefaultNodeInfo) { ni.Other.TxIndex = nonAscii }, true},
-		{"Empty tab TxIndex", func(ni *DefaultNodeInfo) { ni.Other.TxIndex = emptyTab }, true},
-		{"Empty space TxIndex", func(ni *DefaultNodeInfo) { ni.Other.TxIndex = emptySpace }, true},
-		{"Empty TxIndex", func(ni *DefaultNodeInfo) { ni.Other.TxIndex = "" }, false},
-		{"Off TxIndex", func(ni *DefaultNodeInfo) { ni.Other.TxIndex = "off" }, false},
-
-		{"Non-ASCII RPCAddress", func(ni *DefaultNodeInfo) { ni.Other.RPCAddress = nonAscii }, true},
-		{"Empty tab RPCAddress", func(ni *DefaultNodeInfo) { ni.Other.RPCAddress = emptyTab }, true},
-		{"Empty space RPCAddress", func(ni *DefaultNodeInfo) { ni.Other.RPCAddress = emptySpace }, true},
-		{"Empty RPCAddress", func(ni *DefaultNodeInfo) { ni.Other.RPCAddress = "" }, false},
-		{"Good RPCAddress", func(ni *DefaultNodeInfo) { ni.Other.RPCAddress = "0.0.0.0:26657" }, false},
-	}
-
-	nodeKey := NodeKey{PrivKey: ed25519.GenPrivKey()}
-	name := "testing"
-
-	// test case passes
-	ni = testNodeInfo(nodeKey.ID(), name).(DefaultNodeInfo)
-	ni.Channels = channels
-	assert.NoError(t, ni.ValidateBasic())
-
-	for _, tc := range testCases {
-		ni := testNodeInfo(nodeKey.ID(), name).(DefaultNodeInfo)
-		ni.Channels = channels
-		tc.malleateNodeInfo(&ni)
-		err := ni.ValidateBasic()
-		if tc.expectErr {
-			assert.Error(t, err, tc.testName)
-		} else {
-			assert.NoError(t, err, tc.testName)
-		}
-	}
-
-}
-
-func TestNodeInfoCompatible(t *testing.T) {
-
-	nodeKey1 := NodeKey{PrivKey: ed25519.GenPrivKey()}
-	nodeKey2 := NodeKey{PrivKey: ed25519.GenPrivKey()}
-	name := "testing"
-
-	var newTestChannel byte = 0x2
-
-	// test NodeInfo is compatible
-	ni1 := testNodeInfo(nodeKey1.ID(), name).(DefaultNodeInfo)
-	ni2 := testNodeInfo(nodeKey2.ID(), name).(DefaultNodeInfo)
-	assert.NoError(t, ni1.CompatibleWith(ni2))
-
-	// add another channel; still compatible
-	ni2.Channels = []byte{newTestChannel, testCh}
-	assert.NoError(t, ni1.CompatibleWith(ni2))
-
-	// wrong NodeInfo type is not compatible
-	_, netAddr := CreateRoutableAddr()
-	ni3 := mockNodeInfo{netAddr}
-	assert.Error(t, ni1.CompatibleWith(ni3))
-
-	testCases := []struct {
-		testName         string
-		malleateNodeInfo func(*DefaultNodeInfo)
-	}{
-		{"Wrong block version", func(ni *DefaultNodeInfo) { ni.ProtocolVersion.Block += 1 }},
-		{"Wrong network", func(ni *DefaultNodeInfo) { ni.Network += "-wrong" }},
-		{"No common channels", func(ni *DefaultNodeInfo) { ni.Channels = []byte{newTestChannel} }},
-	}
-
-	for _, tc := range testCases {
-		ni := testNodeInfo(nodeKey2.ID(), name).(DefaultNodeInfo)
-		tc.malleateNodeInfo(&ni)
-		assert.Error(t, ni1.CompatibleWith(ni))
-	}
-}

p2p/peer.go

@@ -26,7 +26,6 @@ type Peer interface {
 
 	NodeInfo() NodeInfo // peer's info
 	Status() tmconn.ConnectionStatus
-	OriginalAddr() *NetAddress
 
 	Send(byte, []byte) bool
 	TrySend(byte, []byte) bool
@@ -44,28 +43,10 @@ type peerConn struct {
 	config     *config.P2PConfig
 	conn       net.Conn // source connection
 
-	originalAddr *NetAddress // nil for inbound connections
-
 	// cached RemoteIP()
 	ip net.IP
 }
 
-func newPeerConn(
-	outbound, persistent bool,
-	config *config.P2PConfig,
-	conn net.Conn,
-	originalAddr *NetAddress,
-) peerConn {
-
-	return peerConn{
-		outbound:     outbound,
-		persistent:   persistent,
-		config:       config,
-		conn:         conn,
-		originalAddr: originalAddr,
-	}
-}
-
 // ID only exists for SecretConnection.
 // NOTE: Will panic if conn is not *SecretConnection.
 func (pc peerConn) ID() ID {
@@ -214,15 +195,6 @@ func (p *peer) NodeInfo() NodeInfo {
 	return p.nodeInfo
 }
 
-// OriginalAddr returns the original address, which was used to connect with
-// the peer. Returns nil for inbound peers.
-func (p *peer) OriginalAddr() *NetAddress {
-	if p.peerConn.outbound {
-		return p.peerConn.originalAddr
-	}
-	return nil
-}
-
 // Status returns the peer's ConnectionStatus.
 func (p *peer) Status() tmconn.ConnectionStatus {
 	return p.mconn.Status()

p2p/peer_set_test.go

@@ -28,7 +28,6 @@ func (mp *mockPeer) IsPersistent() bool                      { return true }
 func (mp *mockPeer) Get(s string) interface{}                { return s }
 func (mp *mockPeer) Set(string, interface{})                 {}
 func (mp *mockPeer) RemoteIP() net.IP                        { return mp.ip }
-func (mp *mockPeer) OriginalAddr() *NetAddress               { return nil }
 
 // Returns a mock peer
 func newMockPeer(ip net.IP) *mockPeer {

p2p/peer_test.go

@@ -114,7 +114,7 @@ func testOutboundPeerConn(
 		return peerConn{}, cmn.ErrorWrap(err, "Error creating peer")
 	}
 
-	pc, err := testPeerConn(conn, config, true, persistent, ourNodePrivKey, addr)
+	pc, err := testPeerConn(conn, config, true, persistent, ourNodePrivKey)
 	if err != nil {
 		if cerr := conn.Close(); cerr != nil {
 			return peerConn{}, cmn.ErrorWrap(err, cerr.Error())
@@ -207,12 +207,11 @@ func (rp *remotePeer) accept(l net.Listener) {
 
 func (rp *remotePeer) nodeInfo(l net.Listener) NodeInfo {
 	return DefaultNodeInfo{
-		ProtocolVersion: defaultProtocolVersion,
-		ID_:             rp.Addr().ID,
-		ListenAddr:      l.Addr().String(),
-		Network:         "testing",
-		Version:         "1.2.3-rc0-deadbeef",
-		Channels:        rp.channels,
-		Moniker:         "remote_peer",
+		ID_:        rp.Addr().ID,
+		Moniker:    "remote_peer",
+		Network:    "testing",
+		Version:    "123.123.123",
+		ListenAddr: l.Addr().String(),
+		Channels:   rp.channels,
 	}
 }

p2p/pex/pex_reactor_test.go

@@ -402,7 +402,6 @@ func (mockPeer) Send(byte, []byte) bool        { return false }
 func (mockPeer) TrySend(byte, []byte) bool     { return false }
 func (mockPeer) Set(string, interface{})       {}
 func (mockPeer) Get(string) interface{}        { return nil }
-func (mockPeer) OriginalAddr() *p2p.NetAddress { return nil }
 
 func assertPeersWithTimeout(
 	t *testing.T,

p2p/switch.go

@@ -280,12 +280,9 @@ func (sw *Switch) StopPeerForError(peer Peer, reason interface{}) {
 	sw.stopAndRemovePeer(peer, reason)
 
 	if peer.IsPersistent() {
-		addr := peer.OriginalAddr()
-		if addr == nil {
-			// FIXME: persistent peers can't be inbound right now.
-			// self-reported address for inbound persistent peers
-			addr = peer.NodeInfo().NetAddress()
-		}
+		// TODO: use the original address dialed, not the self reported one
+		// See #2618.
+		addr := peer.NodeInfo().NetAddress()
 		go sw.reconnectToPeer(addr)
 	}
 }

p2p/test_util.go

@@ -206,7 +206,7 @@ func testInboundPeerConn(
 	config *config.P2PConfig,
 	ourNodePrivKey crypto.PrivKey,
 ) (peerConn, error) {
-	return testPeerConn(conn, config, false, false, ourNodePrivKey, nil)
+	return testPeerConn(conn, config, false, false, ourNodePrivKey)
 }
 
 func testPeerConn(
@@ -214,7 +214,6 @@ func testPeerConn(
 	cfg *config.P2PConfig,
 	outbound, persistent bool,
 	ourNodePrivKey crypto.PrivKey,
-	originalAddr *NetAddress,
 ) (pc peerConn, err error) {
 	conn := rawConn
 
@@ -232,11 +231,10 @@ func testPeerConn(
 
 	// Only the information we already have
 	return peerConn{
-		config:       cfg,
-		outbound:     outbound,
-		persistent:   persistent,
-		conn:         conn,
-		originalAddr: originalAddr,
+		config:     cfg,
+		outbound:   outbound,
+		persistent: persistent,
+		conn:       conn,
 	}, nil
 }
 
@@ -249,16 +247,11 @@ func testNodeInfo(id ID, name string) NodeInfo {
 
 func testNodeInfoWithNetwork(id ID, name, network string) NodeInfo {
 	return DefaultNodeInfo{
-		ProtocolVersion: defaultProtocolVersion,
-		ID_:             id,
-		ListenAddr:      fmt.Sprintf("127.0.0.1:%d", cmn.RandIntn(64512)+1023),
-		Network:         network,
-		Version:         "1.2.3-rc0-deadbeef",
-		Channels:        []byte{testCh},
-		Moniker:         name,
-		Other: DefaultNodeInfoOther{
-			TxIndex:    "on",
-			RPCAddress: fmt.Sprintf("127.0.0.1:%d", cmn.RandIntn(64512)+1023),
-		},
+		ID_:        id,
+		ListenAddr: fmt.Sprintf("127.0.0.1:%d", cmn.RandIntn(64512)+1023),
+		Moniker:    name,
+		Network:    network,
+		Version:    "123.123.123",
+		Channels:   []byte{testCh},
 	}
 }

p2p/transport.go

@@ -171,7 +171,7 @@ func (mt *MultiplexTransport) Accept(cfg peerConfig) (Peer, error) {
 
 		cfg.outbound = false
 
-		return mt.wrapPeer(a.conn, a.nodeInfo, cfg, nil), nil
+		return mt.wrapPeer(a.conn, a.nodeInfo, cfg), nil
 	case <-mt.closec:
 		return nil, &ErrTransportClosed{}
 	}
@@ -199,7 +199,7 @@ func (mt *MultiplexTransport) Dial(
 
 	cfg.outbound = true
 
-	p := mt.wrapPeer(secretConn, nodeInfo, cfg, &addr)
+	p := mt.wrapPeer(secretConn, nodeInfo, cfg)
 
 	return p, nil
 }
@@ -399,19 +399,14 @@ func (mt *MultiplexTransport) wrapPeer(
 	c net.Conn,
 	ni NodeInfo,
 	cfg peerConfig,
-	dialedAddr *NetAddress,
 ) Peer {
-
-	peerConn := newPeerConn(
-		cfg.outbound,
-		cfg.persistent,
-		&mt.p2pConfig,
-		c,
-		dialedAddr,
-	)
-
 	p := newPeer(
-		peerConn,
+		peerConn{
+			conn:       c,
+			config:     &mt.p2pConfig,
+			outbound:   cfg.outbound,
+			persistent: cfg.persistent,
+		},
 		mt.mConfig,
 		ni,
 		cfg.reactorsByCh,
@@ -446,11 +441,11 @@ func handshake(
 	)
 
 	go func(errc chan<- error, c net.Conn) {
-		_, err := cdc.MarshalBinaryLengthPrefixedWriter(c, ourNodeInfo)
+		_, err := cdc.MarshalBinaryWriter(c, ourNodeInfo)
 		errc <- err
 	}(errc, c)
 	go func(errc chan<- error, c net.Conn) {
-		_, err := cdc.UnmarshalBinaryLengthPrefixedReader(
+		_, err := cdc.UnmarshalBinaryReader(
 			c,
 			&peerNodeInfo,
 			int64(MaxNodeInfoSize()),

p2p/transport_test.go

@@ -516,7 +516,7 @@ func TestTransportHandshake(t *testing.T) {
 		}
 
 		go func(c net.Conn) {
-			_, err := cdc.MarshalBinaryLengthPrefixedWriter(c, peerNodeInfo.(DefaultNodeInfo))
+			_, err := cdc.MarshalBinaryWriter(c, peerNodeInfo.(DefaultNodeInfo))
 			if err != nil {
 				t.Error(err)
 			}
@@ -524,7 +524,7 @@ func TestTransportHandshake(t *testing.T) {
 		go func(c net.Conn) {
 			var ni DefaultNodeInfo
 
-			_, err := cdc.UnmarshalBinaryLengthPrefixedReader(
+			_, err := cdc.UnmarshalBinaryReader(
 				c,
 				&ni,
 				int64(MaxNodeInfoSize()),

p2p/version.go

@@ -0,0 +1,3 @@
+package p2p
+
+const Version = "0.5.0"

privval/ipc.go

@@ -1,120 +0,0 @@
-package privval
-
-import (
-	"net"
-	"time"
-
-	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/types"
-)
-
-// IPCValOption sets an optional parameter on the SocketPV.
-type IPCValOption func(*IPCVal)
-
-// IPCValConnTimeout sets the read and write timeout for connections
-// from external signing processes.
-func IPCValConnTimeout(timeout time.Duration) IPCValOption {
-	return func(sc *IPCVal) { sc.connTimeout = timeout }
-}
-
-// IPCValHeartbeat sets the period on which to check the liveness of the
-// connected Signer connections.
-func IPCValHeartbeat(period time.Duration) IPCValOption {
-	return func(sc *IPCVal) { sc.connHeartbeat = period }
-}
-
-// IPCVal implements PrivValidator, it uses a unix socket to request signatures
-// from an external process.
-type IPCVal struct {
-	cmn.BaseService
-	*RemoteSignerClient
-
-	addr string
-
-	connTimeout   time.Duration
-	connHeartbeat time.Duration
-
-	conn       net.Conn
-	cancelPing chan struct{}
-	pingTicker *time.Ticker
-}
-
-// Check that IPCVal implements PrivValidator.
-var _ types.PrivValidator = (*IPCVal)(nil)
-
-// NewIPCVal returns an instance of IPCVal.
-func NewIPCVal(
-	logger log.Logger,
-	socketAddr string,
-) *IPCVal {
-	sc := &IPCVal{
-		addr:          socketAddr,
-		connTimeout:   connTimeout,
-		connHeartbeat: connHeartbeat,
-	}
-
-	sc.BaseService = *cmn.NewBaseService(logger, "IPCVal", sc)
-
-	return sc
-}
-
-// OnStart implements cmn.Service.
-func (sc *IPCVal) OnStart() error {
-	err := sc.connect()
-	if err != nil {
-		sc.Logger.Error("OnStart", "err", err)
-		return err
-	}
-
-	sc.RemoteSignerClient = NewRemoteSignerClient(sc.conn)
-
-	// Start a routine to keep the connection alive
-	sc.cancelPing = make(chan struct{}, 1)
-	sc.pingTicker = time.NewTicker(sc.connHeartbeat)
-	go func() {
-		for {
-			select {
-			case <-sc.pingTicker.C:
-				err := sc.Ping()
-				if err != nil {
-					sc.Logger.Error("Ping", "err", err)
-				}
-			case <-sc.cancelPing:
-				sc.pingTicker.Stop()
-				return
-			}
-		}
-	}()
-
-	return nil
-}
-
-// OnStop implements cmn.Service.
-func (sc *IPCVal) OnStop() {
-	if sc.cancelPing != nil {
-		close(sc.cancelPing)
-	}
-
-	if sc.conn != nil {
-		if err := sc.conn.Close(); err != nil {
-			sc.Logger.Error("OnStop", "err", err)
-		}
-	}
-}
-
-func (sc *IPCVal) connect() error {
-	la, err := net.ResolveUnixAddr("unix", sc.addr)
-	if err != nil {
-		return err
-	}
-
-	conn, err := net.DialUnix("unix", nil, la)
-	if err != nil {
-		return err
-	}
-
-	sc.conn = newTimeoutConn(conn, sc.connTimeout)
-
-	return nil
-}

privval/ipc_server.go

@@ -1,131 +0,0 @@
-package privval
-
-import (
-	"io"
-	"net"
-	"time"
-
-	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/types"
-)
-
-// IPCRemoteSignerOption sets an optional parameter on the IPCRemoteSigner.
-type IPCRemoteSignerOption func(*IPCRemoteSigner)
-
-// IPCRemoteSignerConnDeadline sets the read and write deadline for connections
-// from external signing processes.
-func IPCRemoteSignerConnDeadline(deadline time.Duration) IPCRemoteSignerOption {
-	return func(ss *IPCRemoteSigner) { ss.connDeadline = deadline }
-}
-
-// IPCRemoteSignerConnRetries sets the amount of attempted retries to connect.
-func IPCRemoteSignerConnRetries(retries int) IPCRemoteSignerOption {
-	return func(ss *IPCRemoteSigner) { ss.connRetries = retries }
-}
-
-// IPCRemoteSigner is a RPC implementation of PrivValidator that listens on a unix socket.
-type IPCRemoteSigner struct {
-	cmn.BaseService
-
-	addr         string
-	chainID      string
-	connDeadline time.Duration
-	connRetries  int
-	privVal      types.PrivValidator
-
-	listener *net.UnixListener
-}
-
-// NewIPCRemoteSigner returns an instance of IPCRemoteSigner.
-func NewIPCRemoteSigner(
-	logger log.Logger,
-	chainID, socketAddr string,
-	privVal types.PrivValidator,
-) *IPCRemoteSigner {
-	rs := &IPCRemoteSigner{
-		addr:         socketAddr,
-		chainID:      chainID,
-		connDeadline: time.Second * defaultConnDeadlineSeconds,
-		connRetries:  defaultDialRetries,
-		privVal:      privVal,
-	}
-
-	rs.BaseService = *cmn.NewBaseService(logger, "IPCRemoteSigner", rs)
-
-	return rs
-}
-
-// OnStart implements cmn.Service.
-func (rs *IPCRemoteSigner) OnStart() error {
-	err := rs.listen()
-	if err != nil {
-		err = cmn.ErrorWrap(err, "listen")
-		rs.Logger.Error("OnStart", "err", err)
-		return err
-	}
-
-	go func() {
-		for {
-			conn, err := rs.listener.AcceptUnix()
-			if err != nil {
-				return
-			}
-			go rs.handleConnection(conn)
-		}
-	}()
-
-	return nil
-}
-
-// OnStop implements cmn.Service.
-func (rs *IPCRemoteSigner) OnStop() {
-	if rs.listener != nil {
-		if err := rs.listener.Close(); err != nil {
-			rs.Logger.Error("OnStop", "err", cmn.ErrorWrap(err, "closing listener failed"))
-		}
-	}
-}
-
-func (rs *IPCRemoteSigner) listen() error {
-	la, err := net.ResolveUnixAddr("unix", rs.addr)
-	if err != nil {
-		return err
-	}
-
-	rs.listener, err = net.ListenUnix("unix", la)
-
-	return err
-}
-
-func (rs *IPCRemoteSigner) handleConnection(conn net.Conn) {
-	for {
-		if !rs.IsRunning() {
-			return // Ignore error from listener closing.
-		}
-
-		// Reset the connection deadline
-		conn.SetDeadline(time.Now().Add(rs.connDeadline))
-
-		req, err := readMsg(conn)
-		if err != nil {
-			if err != io.EOF {
-				rs.Logger.Error("handleConnection", "err", err)
-			}
-			return
-		}
-
-		res, err := handleRequest(req, rs.chainID, rs.privVal)
-
-		if err != nil {
-			// only log the error; we'll reply with an error in res
-			rs.Logger.Error("handleConnection", "err", err)
-		}
-
-		err = writeMsg(conn, res)
-		if err != nil {
-			rs.Logger.Error("handleConnection", "err", err)
-			return
-		}
-	}
-}

privval/ipc_test.go

@@ -1,147 +0,0 @@
-package privval
-
-import (
-	"io/ioutil"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/types"
-)
-
-func TestIPCPVVote(t *testing.T) {
-	var (
-		chainID = cmn.RandStr(12)
-		sc, rs  = testSetupIPCSocketPair(t, chainID, types.NewMockPV())
-
-		ts    = time.Now()
-		vType = types.PrecommitType
-		want  = &types.Vote{Timestamp: ts, Type: vType}
-		have  = &types.Vote{Timestamp: ts, Type: vType}
-	)
-	defer sc.Stop()
-	defer rs.Stop()
-
-	require.NoError(t, rs.privVal.SignVote(chainID, want))
-	require.NoError(t, sc.SignVote(chainID, have))
-	assert.Equal(t, want.Signature, have.Signature)
-}
-
-func TestIPCPVVoteResetDeadline(t *testing.T) {
-	var (
-		chainID = cmn.RandStr(12)
-		sc, rs  = testSetupIPCSocketPair(t, chainID, types.NewMockPV())
-
-		ts    = time.Now()
-		vType = types.PrecommitType
-		want  = &types.Vote{Timestamp: ts, Type: vType}
-		have  = &types.Vote{Timestamp: ts, Type: vType}
-	)
-	defer sc.Stop()
-	defer rs.Stop()
-
-	time.Sleep(3 * time.Millisecond)
-
-	require.NoError(t, rs.privVal.SignVote(chainID, want))
-	require.NoError(t, sc.SignVote(chainID, have))
-	assert.Equal(t, want.Signature, have.Signature)
-
-	// This would exceed the deadline if it was not extended by the previous message
-	time.Sleep(3 * time.Millisecond)
-
-	require.NoError(t, rs.privVal.SignVote(chainID, want))
-	require.NoError(t, sc.SignVote(chainID, have))
-	assert.Equal(t, want.Signature, have.Signature)
-}
-
-func TestIPCPVVoteKeepalive(t *testing.T) {
-	var (
-		chainID = cmn.RandStr(12)
-		sc, rs  = testSetupIPCSocketPair(t, chainID, types.NewMockPV())
-
-		ts    = time.Now()
-		vType = types.PrecommitType
-		want  = &types.Vote{Timestamp: ts, Type: vType}
-		have  = &types.Vote{Timestamp: ts, Type: vType}
-	)
-	defer sc.Stop()
-	defer rs.Stop()
-
-	time.Sleep(10 * time.Millisecond)
-
-	require.NoError(t, rs.privVal.SignVote(chainID, want))
-	require.NoError(t, sc.SignVote(chainID, have))
-	assert.Equal(t, want.Signature, have.Signature)
-}
-
-func testSetupIPCSocketPair(
-	t *testing.T,
-	chainID string,
-	privValidator types.PrivValidator,
-) (*IPCVal, *IPCRemoteSigner) {
-	addr, err := testUnixAddr()
-	require.NoError(t, err)
-
-	var (
-		logger  = log.TestingLogger()
-		privVal = privValidator
-		readyc  = make(chan struct{})
-		rs      = NewIPCRemoteSigner(
-			logger,
-			chainID,
-			addr,
-			privVal,
-		)
-		sc = NewIPCVal(
-			logger,
-			addr,
-		)
-	)
-
-	IPCValConnTimeout(5 * time.Millisecond)(sc)
-	IPCValHeartbeat(time.Millisecond)(sc)
-
-	IPCRemoteSignerConnDeadline(time.Millisecond * 5)(rs)
-
-	testStartIPCRemoteSigner(t, readyc, rs)
-
-	<-readyc
-
-	require.NoError(t, sc.Start())
-	assert.True(t, sc.IsRunning())
-
-	return sc, rs
-}
-
-func testStartIPCRemoteSigner(t *testing.T, readyc chan struct{}, rs *IPCRemoteSigner) {
-	go func(rs *IPCRemoteSigner) {
-		require.NoError(t, rs.Start())
-		assert.True(t, rs.IsRunning())
-
-		readyc <- struct{}{}
-	}(rs)
-}
-
-func testUnixAddr() (string, error) {
-	f, err := ioutil.TempFile("/tmp", "nettest")
-	if err != nil {
-		return "", err
-	}
-
-	addr := f.Name()
-	err = f.Close()
-	if err != nil {
-		return "", err
-	}
-	err = os.Remove(addr)
-	if err != nil {
-		return "", err
-	}
-
-	return addr, nil
-}

privval/priv_validator.go

@@ -314,10 +314,10 @@ func (pv *FilePV) String() string {
 // returns true if the only difference in the votes is their timestamp.
 func checkVotesOnlyDifferByTimestamp(lastSignBytes, newSignBytes []byte) (time.Time, bool) {
 	var lastVote, newVote types.CanonicalVote
-	if err := cdc.UnmarshalBinaryLengthPrefixed(lastSignBytes, &lastVote); err != nil {
+	if err := cdc.UnmarshalBinary(lastSignBytes, &lastVote); err != nil {
 		panic(fmt.Sprintf("LastSignBytes cannot be unmarshalled into vote: %v", err))
 	}
-	if err := cdc.UnmarshalBinaryLengthPrefixed(newSignBytes, &newVote); err != nil {
+	if err := cdc.UnmarshalBinary(newSignBytes, &newVote); err != nil {
 		panic(fmt.Sprintf("signBytes cannot be unmarshalled into vote: %v", err))
 	}
 
@@ -337,10 +337,10 @@ func checkVotesOnlyDifferByTimestamp(lastSignBytes, newSignBytes []byte) (time.T
 // returns true if the only difference in the proposals is their timestamp
 func checkProposalsOnlyDifferByTimestamp(lastSignBytes, newSignBytes []byte) (time.Time, bool) {
 	var lastProposal, newProposal types.CanonicalProposal
-	if err := cdc.UnmarshalBinaryLengthPrefixed(lastSignBytes, &lastProposal); err != nil {
+	if err := cdc.UnmarshalBinary(lastSignBytes, &lastProposal); err != nil {
 		panic(fmt.Sprintf("LastSignBytes cannot be unmarshalled into proposal: %v", err))
 	}
-	if err := cdc.UnmarshalBinaryLengthPrefixed(newSignBytes, &newProposal); err != nil {
+	if err := cdc.UnmarshalBinary(newSignBytes, &newProposal); err != nil {
 		panic(fmt.Sprintf("signBytes cannot be unmarshalled into proposal: %v", err))
 	}
 
@@ -349,8 +349,8 @@ func checkProposalsOnlyDifferByTimestamp(lastSignBytes, newSignBytes []byte) (ti
 	now := tmtime.Now()
 	lastProposal.Timestamp = now
 	newProposal.Timestamp = now
-	lastProposalBytes, _ := cdc.MarshalBinaryLengthPrefixed(lastProposal)
-	newProposalBytes, _ := cdc.MarshalBinaryLengthPrefixed(newProposal)
+	lastProposalBytes, _ := cdc.MarshalBinary(lastProposal)
+	newProposalBytes, _ := cdc.MarshalBinary(newProposal)
 
 	return lastTime, bytes.Equal(newProposalBytes, lastProposalBytes)
 }

privval/remote_signer.go

@@ -1,303 +0,0 @@
-package privval
-
-import (
-	"fmt"
-	"io"
-	"net"
-	"sync"
-
-	"github.com/tendermint/go-amino"
-	"github.com/tendermint/tendermint/crypto"
-	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/types"
-)
-
-// RemoteSignerClient implements PrivValidator, it uses a socket to request signatures
-// from an external process.
-type RemoteSignerClient struct {
-	conn net.Conn
-	lock sync.Mutex
-}
-
-// Check that RemoteSignerClient implements PrivValidator.
-var _ types.PrivValidator = (*RemoteSignerClient)(nil)
-
-// NewRemoteSignerClient returns an instance of RemoteSignerClient.
-func NewRemoteSignerClient(
-	conn net.Conn,
-) *RemoteSignerClient {
-	sc := &RemoteSignerClient{
-		conn: conn,
-	}
-	return sc
-}
-
-// GetAddress implements PrivValidator.
-func (sc *RemoteSignerClient) GetAddress() types.Address {
-	pubKey, err := sc.getPubKey()
-	if err != nil {
-		panic(err)
-	}
-
-	return pubKey.Address()
-}
-
-// GetPubKey implements PrivValidator.
-func (sc *RemoteSignerClient) GetPubKey() crypto.PubKey {
-	pubKey, err := sc.getPubKey()
-	if err != nil {
-		panic(err)
-	}
-
-	return pubKey
-}
-
-func (sc *RemoteSignerClient) getPubKey() (crypto.PubKey, error) {
-	sc.lock.Lock()
-	defer sc.lock.Unlock()
-
-	err := writeMsg(sc.conn, &PubKeyMsg{})
-	if err != nil {
-		return nil, err
-	}
-
-	res, err := readMsg(sc.conn)
-	if err != nil {
-		return nil, err
-	}
-
-	return res.(*PubKeyMsg).PubKey, nil
-}
-
-// SignVote implements PrivValidator.
-func (sc *RemoteSignerClient) SignVote(chainID string, vote *types.Vote) error {
-	sc.lock.Lock()
-	defer sc.lock.Unlock()
-
-	err := writeMsg(sc.conn, &SignVoteRequest{Vote: vote})
-	if err != nil {
-		return err
-	}
-
-	res, err := readMsg(sc.conn)
-	if err != nil {
-		return err
-	}
-
-	resp, ok := res.(*SignedVoteResponse)
-	if !ok {
-		return ErrUnexpectedResponse
-	}
-	if resp.Error != nil {
-		return resp.Error
-	}
-	*vote = *resp.Vote
-
-	return nil
-}
-
-// SignProposal implements PrivValidator.
-func (sc *RemoteSignerClient) SignProposal(
-	chainID string,
-	proposal *types.Proposal,
-) error {
-	sc.lock.Lock()
-	defer sc.lock.Unlock()
-
-	err := writeMsg(sc.conn, &SignProposalRequest{Proposal: proposal})
-	if err != nil {
-		return err
-	}
-
-	res, err := readMsg(sc.conn)
-	if err != nil {
-		return err
-	}
-	resp, ok := res.(*SignedProposalResponse)
-	if !ok {
-		return ErrUnexpectedResponse
-	}
-	if resp.Error != nil {
-		return resp.Error
-	}
-	*proposal = *resp.Proposal
-
-	return nil
-}
-
-// SignHeartbeat implements PrivValidator.
-func (sc *RemoteSignerClient) SignHeartbeat(
-	chainID string,
-	heartbeat *types.Heartbeat,
-) error {
-	sc.lock.Lock()
-	defer sc.lock.Unlock()
-
-	err := writeMsg(sc.conn, &SignHeartbeatRequest{Heartbeat: heartbeat})
-	if err != nil {
-		return err
-	}
-
-	res, err := readMsg(sc.conn)
-	if err != nil {
-		return err
-	}
-	resp, ok := res.(*SignedHeartbeatResponse)
-	if !ok {
-		return ErrUnexpectedResponse
-	}
-	if resp.Error != nil {
-		return resp.Error
-	}
-	*heartbeat = *resp.Heartbeat
-
-	return nil
-}
-
-// Ping is used to check connection health.
-func (sc *RemoteSignerClient) Ping() error {
-	sc.lock.Lock()
-	defer sc.lock.Unlock()
-
-	err := writeMsg(sc.conn, &PingRequest{})
-	if err != nil {
-		return err
-	}
-
-	res, err := readMsg(sc.conn)
-	if err != nil {
-		return err
-	}
-	_, ok := res.(*PingResponse)
-	if !ok {
-		return ErrUnexpectedResponse
-	}
-
-	return nil
-}
-
-// RemoteSignerMsg is sent between RemoteSigner and the RemoteSigner client.
-type RemoteSignerMsg interface{}
-
-func RegisterRemoteSignerMsg(cdc *amino.Codec) {
-	cdc.RegisterInterface((*RemoteSignerMsg)(nil), nil)
-	cdc.RegisterConcrete(&PubKeyMsg{}, "tendermint/remotesigner/PubKeyMsg", nil)
-	cdc.RegisterConcrete(&SignVoteRequest{}, "tendermint/remotesigner/SignVoteRequest", nil)
-	cdc.RegisterConcrete(&SignedVoteResponse{}, "tendermint/remotesigner/SignedVoteResponse", nil)
-	cdc.RegisterConcrete(&SignProposalRequest{}, "tendermint/remotesigner/SignProposalRequest", nil)
-	cdc.RegisterConcrete(&SignedProposalResponse{}, "tendermint/remotesigner/SignedProposalResponse", nil)
-	cdc.RegisterConcrete(&SignHeartbeatRequest{}, "tendermint/remotesigner/SignHeartbeatRequest", nil)
-	cdc.RegisterConcrete(&SignedHeartbeatResponse{}, "tendermint/remotesigner/SignedHeartbeatResponse", nil)
-	cdc.RegisterConcrete(&PingRequest{}, "tendermint/remotesigner/PingRequest", nil)
-	cdc.RegisterConcrete(&PingResponse{}, "tendermint/remotesigner/PingResponse", nil)
-}
-
-// PubKeyMsg is a PrivValidatorSocket message containing the public key.
-type PubKeyMsg struct {
-	PubKey crypto.PubKey
-}
-
-// SignVoteRequest is a PrivValidatorSocket message containing a vote.
-type SignVoteRequest struct {
-	Vote *types.Vote
-}
-
-// SignedVoteResponse is a PrivValidatorSocket message containing a signed vote along with a potenial error message.
-type SignedVoteResponse struct {
-	Vote  *types.Vote
-	Error *RemoteSignerError
-}
-
-// SignProposalRequest is a PrivValidatorSocket message containing a Proposal.
-type SignProposalRequest struct {
-	Proposal *types.Proposal
-}
-
-type SignedProposalResponse struct {
-	Proposal *types.Proposal
-	Error    *RemoteSignerError
-}
-
-// SignHeartbeatRequest is a PrivValidatorSocket message containing a Heartbeat.
-type SignHeartbeatRequest struct {
-	Heartbeat *types.Heartbeat
-}
-
-type SignedHeartbeatResponse struct {
-	Heartbeat *types.Heartbeat
-	Error     *RemoteSignerError
-}
-
-// PingRequest is a PrivValidatorSocket message to keep the connection alive.
-type PingRequest struct {
-}
-
-type PingResponse struct {
-}
-
-// RemoteSignerError allows (remote) validators to include meaningful error descriptions in their reply.
-type RemoteSignerError struct {
-	// TODO(ismail): create an enum of known errors
-	Code        int
-	Description string
-}
-
-func (e *RemoteSignerError) Error() string {
-	return fmt.Sprintf("RemoteSigner returned error #%d: %s", e.Code, e.Description)
-}
-
-func readMsg(r io.Reader) (msg RemoteSignerMsg, err error) {
-	const maxRemoteSignerMsgSize = 1024 * 10
-	_, err = cdc.UnmarshalBinaryLengthPrefixedReader(r, &msg, maxRemoteSignerMsgSize)
-	if _, ok := err.(timeoutError); ok {
-		err = cmn.ErrorWrap(ErrConnTimeout, err.Error())
-	}
-	return
-}
-
-func writeMsg(w io.Writer, msg interface{}) (err error) {
-	_, err = cdc.MarshalBinaryLengthPrefixedWriter(w, msg)
-	if _, ok := err.(timeoutError); ok {
-		err = cmn.ErrorWrap(ErrConnTimeout, err.Error())
-	}
-	return
-}
-
-func handleRequest(req RemoteSignerMsg, chainID string, privVal types.PrivValidator) (RemoteSignerMsg, error) {
-	var res RemoteSignerMsg
-	var err error
-
-	switch r := req.(type) {
-	case *PubKeyMsg:
-		var p crypto.PubKey
-		p = privVal.GetPubKey()
-		res = &PubKeyMsg{p}
-	case *SignVoteRequest:
-		err = privVal.SignVote(chainID, r.Vote)
-		if err != nil {
-			res = &SignedVoteResponse{nil, &RemoteSignerError{0, err.Error()}}
-		} else {
-			res = &SignedVoteResponse{r.Vote, nil}
-		}
-	case *SignProposalRequest:
-		err = privVal.SignProposal(chainID, r.Proposal)
-		if err != nil {
-			res = &SignedProposalResponse{nil, &RemoteSignerError{0, err.Error()}}
-		} else {
-			res = &SignedProposalResponse{r.Proposal, nil}
-		}
-	case *SignHeartbeatRequest:
-		err = privVal.SignHeartbeat(chainID, r.Heartbeat)
-		if err != nil {
-			res = &SignedHeartbeatResponse{nil, &RemoteSignerError{0, err.Error()}}
-		} else {
-			res = &SignedHeartbeatResponse{r.Heartbeat, nil}
-		}
-	case *PingRequest:
-		res = &PingResponse{}
-	default:
-		err = fmt.Errorf("unknown msg: %v", r)
-	}
-
-	return res, err
-}

privval/socket.go

@@ -0,0 +1,605 @@
+package privval
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"time"
+
+	"github.com/tendermint/go-amino"
+
+	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/crypto/ed25519"
+	cmn "github.com/tendermint/tendermint/libs/common"
+	"github.com/tendermint/tendermint/libs/log"
+	p2pconn "github.com/tendermint/tendermint/p2p/conn"
+	"github.com/tendermint/tendermint/types"
+)
+
+const (
+	defaultAcceptDeadlineSeconds = 30 // tendermint waits this long for remote val to connect
+	defaultConnDeadlineSeconds   = 3  // must be set before each read
+	defaultConnHeartBeatSeconds  = 30 // tcp keep-alive period
+	defaultConnWaitSeconds       = 60 // XXX: is this redundant with the accept deadline?
+	defaultDialRetries           = 10 // try to connect to tendermint this many times
+)
+
+// Socket errors.
+var (
+	ErrDialRetryMax       = errors.New("dialed maximum retries")
+	ErrConnWaitTimeout    = errors.New("waited for remote signer for too long")
+	ErrConnTimeout        = errors.New("remote signer timed out")
+	ErrUnexpectedResponse = errors.New("received unexpected response")
+)
+
+// SocketPVOption sets an optional parameter on the SocketPV.
+type SocketPVOption func(*SocketPV)
+
+// SocketPVAcceptDeadline sets the deadline for the SocketPV listener.
+// A zero time value disables the deadline.
+func SocketPVAcceptDeadline(deadline time.Duration) SocketPVOption {
+	return func(sc *SocketPV) { sc.acceptDeadline = deadline }
+}
+
+// SocketPVConnDeadline sets the read and write deadline for connections
+// from external signing processes.
+func SocketPVConnDeadline(deadline time.Duration) SocketPVOption {
+	return func(sc *SocketPV) { sc.connDeadline = deadline }
+}
+
+// SocketPVHeartbeat sets the period on which to check the liveness of the
+// connected Signer connections.
+func SocketPVHeartbeat(period time.Duration) SocketPVOption {
+	return func(sc *SocketPV) { sc.connHeartbeat = period }
+}
+
+// SocketPVConnWait sets the timeout duration before connection of external
+// signing processes are considered to be unsuccessful.
+func SocketPVConnWait(timeout time.Duration) SocketPVOption {
+	return func(sc *SocketPV) { sc.connWaitTimeout = timeout }
+}
+
+// SocketPV implements PrivValidator, it uses a socket to request signatures
+// from an external process.
+type SocketPV struct {
+	cmn.BaseService
+
+	addr            string
+	acceptDeadline  time.Duration
+	connDeadline    time.Duration
+	connHeartbeat   time.Duration
+	connWaitTimeout time.Duration
+	privKey         ed25519.PrivKeyEd25519
+
+	conn     net.Conn
+	listener net.Listener
+}
+
+// Check that SocketPV implements PrivValidator.
+var _ types.PrivValidator = (*SocketPV)(nil)
+
+// NewSocketPV returns an instance of SocketPV.
+func NewSocketPV(
+	logger log.Logger,
+	socketAddr string,
+	privKey ed25519.PrivKeyEd25519,
+) *SocketPV {
+	sc := &SocketPV{
+		addr:            socketAddr,
+		acceptDeadline:  time.Second * defaultAcceptDeadlineSeconds,
+		connDeadline:    time.Second * defaultConnDeadlineSeconds,
+		connHeartbeat:   time.Second * defaultConnHeartBeatSeconds,
+		connWaitTimeout: time.Second * defaultConnWaitSeconds,
+		privKey:         privKey,
+	}
+
+	sc.BaseService = *cmn.NewBaseService(logger, "SocketPV", sc)
+
+	return sc
+}
+
+// GetAddress implements PrivValidator.
+func (sc *SocketPV) GetAddress() types.Address {
+	addr, err := sc.getAddress()
+	if err != nil {
+		panic(err)
+	}
+
+	return addr
+}
+
+// Address is an alias for PubKey().Address().
+func (sc *SocketPV) getAddress() (cmn.HexBytes, error) {
+	p, err := sc.getPubKey()
+	if err != nil {
+		return nil, err
+	}
+
+	return p.Address(), nil
+}
+
+// GetPubKey implements PrivValidator.
+func (sc *SocketPV) GetPubKey() crypto.PubKey {
+	pubKey, err := sc.getPubKey()
+	if err != nil {
+		panic(err)
+	}
+
+	return pubKey
+}
+
+func (sc *SocketPV) getPubKey() (crypto.PubKey, error) {
+	err := writeMsg(sc.conn, &PubKeyMsg{})
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := readMsg(sc.conn)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.(*PubKeyMsg).PubKey, nil
+}
+
+// SignVote implements PrivValidator.
+func (sc *SocketPV) SignVote(chainID string, vote *types.Vote) error {
+	err := writeMsg(sc.conn, &SignVoteRequest{Vote: vote})
+	if err != nil {
+		return err
+	}
+
+	res, err := readMsg(sc.conn)
+	if err != nil {
+		return err
+	}
+
+	resp, ok := res.(*SignedVoteResponse)
+	if !ok {
+		return ErrUnexpectedResponse
+	}
+	if resp.Error != nil {
+		return fmt.Errorf("remote error occurred: code: %v, description: %s",
+			resp.Error.Code,
+			resp.Error.Description)
+	}
+	*vote = *resp.Vote
+
+	return nil
+}
+
+// SignProposal implements PrivValidator.
+func (sc *SocketPV) SignProposal(
+	chainID string,
+	proposal *types.Proposal,
+) error {
+	err := writeMsg(sc.conn, &SignProposalRequest{Proposal: proposal})
+	if err != nil {
+		return err
+	}
+
+	res, err := readMsg(sc.conn)
+	if err != nil {
+		return err
+	}
+	resp, ok := res.(*SignedProposalResponse)
+	if !ok {
+		return ErrUnexpectedResponse
+	}
+	if resp.Error != nil {
+		return fmt.Errorf("remote error occurred: code: %v, description: %s",
+			resp.Error.Code,
+			resp.Error.Description)
+	}
+	*proposal = *resp.Proposal
+
+	return nil
+}
+
+// SignHeartbeat implements PrivValidator.
+func (sc *SocketPV) SignHeartbeat(
+	chainID string,
+	heartbeat *types.Heartbeat,
+) error {
+	err := writeMsg(sc.conn, &SignHeartbeatRequest{Heartbeat: heartbeat})
+	if err != nil {
+		return err
+	}
+
+	res, err := readMsg(sc.conn)
+	if err != nil {
+		return err
+	}
+	resp, ok := res.(*SignedHeartbeatResponse)
+	if !ok {
+		return ErrUnexpectedResponse
+	}
+	if resp.Error != nil {
+		return fmt.Errorf("remote error occurred: code: %v, description: %s",
+			resp.Error.Code,
+			resp.Error.Description)
+	}
+	*heartbeat = *resp.Heartbeat
+
+	return nil
+}
+
+// OnStart implements cmn.Service.
+func (sc *SocketPV) OnStart() error {
+	if err := sc.listen(); err != nil {
+		err = cmn.ErrorWrap(err, "failed to listen")
+		sc.Logger.Error(
+			"OnStart",
+			"err", err,
+		)
+		return err
+	}
+
+	conn, err := sc.waitConnection()
+	if err != nil {
+		err = cmn.ErrorWrap(err, "failed to accept connection")
+		sc.Logger.Error(
+			"OnStart",
+			"err", err,
+		)
+
+		return err
+	}
+
+	sc.conn = conn
+
+	return nil
+}
+
+// OnStop implements cmn.Service.
+func (sc *SocketPV) OnStop() {
+	if sc.conn != nil {
+		if err := sc.conn.Close(); err != nil {
+			err = cmn.ErrorWrap(err, "failed to close connection")
+			sc.Logger.Error(
+				"OnStop",
+				"err", err,
+			)
+		}
+	}
+
+	if sc.listener != nil {
+		if err := sc.listener.Close(); err != nil {
+			err = cmn.ErrorWrap(err, "failed to close listener")
+			sc.Logger.Error(
+				"OnStop",
+				"err", err,
+			)
+		}
+	}
+}
+
+func (sc *SocketPV) acceptConnection() (net.Conn, error) {
+	conn, err := sc.listener.Accept()
+	if err != nil {
+		if !sc.IsRunning() {
+			return nil, nil // Ignore error from listener closing.
+		}
+		return nil, err
+
+	}
+
+	conn, err = p2pconn.MakeSecretConnection(conn, sc.privKey)
+	if err != nil {
+		return nil, err
+	}
+
+	return conn, nil
+}
+
+func (sc *SocketPV) listen() error {
+	ln, err := net.Listen(cmn.ProtocolAndAddress(sc.addr))
+	if err != nil {
+		return err
+	}
+
+	sc.listener = newTCPTimeoutListener(
+		ln,
+		sc.acceptDeadline,
+		sc.connDeadline,
+		sc.connHeartbeat,
+	)
+
+	return nil
+}
+
+// waitConnection uses the configured wait timeout to error if no external
+// process connects in the time period.
+func (sc *SocketPV) waitConnection() (net.Conn, error) {
+	var (
+		connc = make(chan net.Conn, 1)
+		errc  = make(chan error, 1)
+	)
+
+	go func(connc chan<- net.Conn, errc chan<- error) {
+		conn, err := sc.acceptConnection()
+		if err != nil {
+			errc <- err
+			return
+		}
+
+		connc <- conn
+	}(connc, errc)
+
+	select {
+	case conn := <-connc:
+		return conn, nil
+	case err := <-errc:
+		if _, ok := err.(timeoutError); ok {
+			return nil, cmn.ErrorWrap(ErrConnWaitTimeout, err.Error())
+		}
+		return nil, err
+	case <-time.After(sc.connWaitTimeout):
+		return nil, ErrConnWaitTimeout
+	}
+}
+
+//---------------------------------------------------------
+
+// RemoteSignerOption sets an optional parameter on the RemoteSigner.
+type RemoteSignerOption func(*RemoteSigner)
+
+// RemoteSignerConnDeadline sets the read and write deadline for connections
+// from external signing processes.
+func RemoteSignerConnDeadline(deadline time.Duration) RemoteSignerOption {
+	return func(ss *RemoteSigner) { ss.connDeadline = deadline }
+}
+
+// RemoteSignerConnRetries sets the amount of attempted retries to connect.
+func RemoteSignerConnRetries(retries int) RemoteSignerOption {
+	return func(ss *RemoteSigner) { ss.connRetries = retries }
+}
+
+// RemoteSigner implements PrivValidator by dialing to a socket.
+type RemoteSigner struct {
+	cmn.BaseService
+
+	addr         string
+	chainID      string
+	connDeadline time.Duration
+	connRetries  int
+	privKey      ed25519.PrivKeyEd25519
+	privVal      types.PrivValidator
+
+	conn net.Conn
+}
+
+// NewRemoteSigner returns an instance of RemoteSigner.
+func NewRemoteSigner(
+	logger log.Logger,
+	chainID, socketAddr string,
+	privVal types.PrivValidator,
+	privKey ed25519.PrivKeyEd25519,
+) *RemoteSigner {
+	rs := &RemoteSigner{
+		addr:         socketAddr,
+		chainID:      chainID,
+		connDeadline: time.Second * defaultConnDeadlineSeconds,
+		connRetries:  defaultDialRetries,
+		privKey:      privKey,
+		privVal:      privVal,
+	}
+
+	rs.BaseService = *cmn.NewBaseService(logger, "RemoteSigner", rs)
+
+	return rs
+}
+
+// OnStart implements cmn.Service.
+func (rs *RemoteSigner) OnStart() error {
+	conn, err := rs.connect()
+	if err != nil {
+		err = cmn.ErrorWrap(err, "connect")
+		rs.Logger.Error("OnStart", "err", err)
+		return err
+	}
+
+	go rs.handleConnection(conn)
+
+	return nil
+}
+
+// OnStop implements cmn.Service.
+func (rs *RemoteSigner) OnStop() {
+	if rs.conn == nil {
+		return
+	}
+
+	if err := rs.conn.Close(); err != nil {
+		rs.Logger.Error("OnStop", "err", cmn.ErrorWrap(err, "closing listener failed"))
+	}
+}
+
+func (rs *RemoteSigner) connect() (net.Conn, error) {
+	for retries := rs.connRetries; retries > 0; retries-- {
+		// Don't sleep if it is the first retry.
+		if retries != rs.connRetries {
+			time.Sleep(rs.connDeadline)
+		}
+
+		conn, err := cmn.Connect(rs.addr)
+		if err != nil {
+			err = cmn.ErrorWrap(err, "connection failed")
+			rs.Logger.Error(
+				"connect",
+				"addr", rs.addr,
+				"err", err,
+			)
+
+			continue
+		}
+
+		if err := conn.SetDeadline(time.Now().Add(time.Second * defaultConnDeadlineSeconds)); err != nil {
+			err = cmn.ErrorWrap(err, "setting connection timeout failed")
+			rs.Logger.Error(
+				"connect",
+				"err", err,
+			)
+			continue
+		}
+
+		conn, err = p2pconn.MakeSecretConnection(conn, rs.privKey)
+		if err != nil {
+			err = cmn.ErrorWrap(err, "encrypting connection failed")
+			rs.Logger.Error(
+				"connect",
+				"err", err,
+			)
+
+			continue
+		}
+
+		return conn, nil
+	}
+
+	return nil, ErrDialRetryMax
+}
+
+func (rs *RemoteSigner) handleConnection(conn net.Conn) {
+	for {
+		if !rs.IsRunning() {
+			return // Ignore error from listener closing.
+		}
+
+		req, err := readMsg(conn)
+		if err != nil {
+			if err != io.EOF {
+				rs.Logger.Error("handleConnection", "err", err)
+			}
+			return
+		}
+
+		var res SocketPVMsg
+
+		switch r := req.(type) {
+		case *PubKeyMsg:
+			var p crypto.PubKey
+			p = rs.privVal.GetPubKey()
+			res = &PubKeyMsg{p}
+		case *SignVoteRequest:
+			err = rs.privVal.SignVote(rs.chainID, r.Vote)
+			if err != nil {
+				res = &SignedVoteResponse{nil, &RemoteSignerError{0, err.Error()}}
+			} else {
+				res = &SignedVoteResponse{r.Vote, nil}
+			}
+		case *SignProposalRequest:
+			err = rs.privVal.SignProposal(rs.chainID, r.Proposal)
+			if err != nil {
+				res = &SignedProposalResponse{nil, &RemoteSignerError{0, err.Error()}}
+			} else {
+				res = &SignedProposalResponse{r.Proposal, nil}
+			}
+		case *SignHeartbeatRequest:
+			err = rs.privVal.SignHeartbeat(rs.chainID, r.Heartbeat)
+			if err != nil {
+				res = &SignedHeartbeatResponse{nil, &RemoteSignerError{0, err.Error()}}
+			} else {
+				res = &SignedHeartbeatResponse{r.Heartbeat, nil}
+			}
+		default:
+			err = fmt.Errorf("unknown msg: %v", r)
+		}
+
+		if err != nil {
+			// only log the error; we'll reply with an error in res
+			rs.Logger.Error("handleConnection", "err", err)
+		}
+
+		err = writeMsg(conn, res)
+		if err != nil {
+			rs.Logger.Error("handleConnection", "err", err)
+			return
+		}
+	}
+}
+
+//---------------------------------------------------------
+
+// SocketPVMsg is sent between RemoteSigner and SocketPV.
+type SocketPVMsg interface{}
+
+func RegisterSocketPVMsg(cdc *amino.Codec) {
+	cdc.RegisterInterface((*SocketPVMsg)(nil), nil)
+	cdc.RegisterConcrete(&PubKeyMsg{}, "tendermint/socketpv/PubKeyMsg", nil)
+	cdc.RegisterConcrete(&SignVoteRequest{}, "tendermint/socketpv/SignVoteRequest", nil)
+	cdc.RegisterConcrete(&SignedVoteResponse{}, "tendermint/socketpv/SignedVoteResponse", nil)
+	cdc.RegisterConcrete(&SignProposalRequest{}, "tendermint/socketpv/SignProposalRequest", nil)
+	cdc.RegisterConcrete(&SignedProposalResponse{}, "tendermint/socketpv/SignedProposalResponse", nil)
+	cdc.RegisterConcrete(&SignHeartbeatRequest{}, "tendermint/socketpv/SignHeartbeatRequest", nil)
+	cdc.RegisterConcrete(&SignedHeartbeatResponse{}, "tendermint/socketpv/SignedHeartbeatResponse", nil)
+}
+
+// PubKeyMsg is a PrivValidatorSocket message containing the public key.
+type PubKeyMsg struct {
+	PubKey crypto.PubKey
+}
+
+// SignVoteRequest is a PrivValidatorSocket message containing a vote.
+type SignVoteRequest struct {
+	Vote *types.Vote
+}
+
+// SignedVoteResponse is a PrivValidatorSocket message containing a signed vote along with a potenial error message.
+type SignedVoteResponse struct {
+	Vote  *types.Vote
+	Error *RemoteSignerError
+}
+
+// SignProposalRequest is a PrivValidatorSocket message containing a Proposal.
+type SignProposalRequest struct {
+	Proposal *types.Proposal
+}
+
+type SignedProposalResponse struct {
+	Proposal *types.Proposal
+	Error    *RemoteSignerError
+}
+
+// SignHeartbeatRequest is a PrivValidatorSocket message containing a Heartbeat.
+type SignHeartbeatRequest struct {
+	Heartbeat *types.Heartbeat
+}
+
+type SignedHeartbeatResponse struct {
+	Heartbeat *types.Heartbeat
+	Error     *RemoteSignerError
+}
+
+// RemoteSignerError allows (remote) validators to include meaningful error descriptions in their reply.
+type RemoteSignerError struct {
+	// TODO(ismail): create an enum of known errors
+	Code        int
+	Description string
+}
+
+func readMsg(r io.Reader) (msg SocketPVMsg, err error) {
+	const maxSocketPVMsgSize = 1024 * 10
+
+	// set deadline before trying to read
+	conn := r.(net.Conn)
+	if err := conn.SetDeadline(time.Now().Add(time.Second * defaultConnDeadlineSeconds)); err != nil {
+		err = cmn.ErrorWrap(err, "setting connection timeout failed in readMsg")
+		return msg, err
+	}
+
+	_, err = cdc.UnmarshalBinaryReader(r, &msg, maxSocketPVMsgSize)
+	if _, ok := err.(timeoutError); ok {
+		err = cmn.ErrorWrap(ErrConnTimeout, err.Error())
+	}
+	return
+}
+
+func writeMsg(w io.Writer, msg interface{}) (err error) {
+	_, err = cdc.MarshalBinaryWriter(w, msg)
+	if _, ok := err.(timeoutError); ok {
+		err = cmn.ErrorWrap(ErrConnTimeout, err.Error())
+	}
+	return
+}

privval/socket_tcp.go

@@ -24,13 +24,6 @@ type tcpTimeoutListener struct {
 	period         time.Duration
 }
 
-// timeoutConn wraps a net.Conn to standardise protocol timeouts / deadline resets.
-type timeoutConn struct {
-	net.Conn
-
-	connDeadline time.Duration
-}
-
 // newTCPTimeoutListener returns an instance of tcpTimeoutListener.
 func newTCPTimeoutListener(
 	ln net.Listener,
@@ -45,16 +38,6 @@ func newTCPTimeoutListener(
 	}
 }
 
-// newTimeoutConn returns an instance of newTCPTimeoutConn.
-func newTimeoutConn(
-	conn net.Conn,
-	connDeadline time.Duration) *timeoutConn {
-	return &timeoutConn{
-		conn,
-		connDeadline,
-	}
-}
-
 // Accept implements net.Listener.
 func (ln tcpTimeoutListener) Accept() (net.Conn, error) {
 	err := ln.SetDeadline(time.Now().Add(ln.acceptDeadline))
@@ -67,24 +50,17 @@ func (ln tcpTimeoutListener) Accept() (net.Conn, error) {
 		return nil, err
 	}
 
-	// Wrap the conn in our timeout wrapper
-	conn := newTimeoutConn(tc, ln.connDeadline)
+	if err := tc.SetDeadline(time.Now().Add(ln.connDeadline)); err != nil {
+		return nil, err
+	}
 
-	return conn, nil
-}
-
-// Read implements net.Listener.
-func (c timeoutConn) Read(b []byte) (n int, err error) {
-	// Reset deadline
-	c.Conn.SetReadDeadline(time.Now().Add(c.connDeadline))
-
-	return c.Conn.Read(b)
-}
-
-// Write implements net.Listener.
-func (c timeoutConn) Write(b []byte) (n int, err error) {
-	// Reset deadline
-	c.Conn.SetWriteDeadline(time.Now().Add(c.connDeadline))
-
-	return c.Conn.Write(b)
+	if err := tc.SetKeepAlive(true); err != nil {
+		return nil, err
+	}
+
+	if err := tc.SetKeepAlivePeriod(ln.period); err != nil {
+		return nil, err
+	}
+
+	return tc, nil
 }

privval/socket_tcp_test.go

@@ -44,14 +44,13 @@ func TestTCPTimeoutListenerConnDeadline(t *testing.T) {
 
 		time.Sleep(2 * time.Millisecond)
 
-		msg := make([]byte, 200)
-		_, err = c.Read(msg)
+		_, err = c.Write([]byte("foo"))
 		opErr, ok := err.(*net.OpError)
 		if !ok {
 			t.Fatalf("have %v, want *net.OpError", err)
 		}
 
-		if have, want := opErr.Op, "read"; have != want {
+		if have, want := opErr.Op, "write"; have != want {
 			t.Errorf("have %v, want %v", have, want)
 		}
 	}(ln)

privval/socket_test.go

@@ -27,7 +27,8 @@ func TestSocketPVAddress(t *testing.T) {
 
 	serverAddr := rs.privVal.GetAddress()
 
-	clientAddr := sc.GetAddress()
+	clientAddr, err := sc.getAddress()
+	require.NoError(t, err)
 
 	assert.Equal(t, serverAddr, clientAddr)
 
@@ -90,53 +91,6 @@ func TestSocketPVVote(t *testing.T) {
 	assert.Equal(t, want.Signature, have.Signature)
 }
 
-func TestSocketPVVoteResetDeadline(t *testing.T) {
-	var (
-		chainID = cmn.RandStr(12)
-		sc, rs  = testSetupSocketPair(t, chainID, types.NewMockPV())
-
-		ts    = time.Now()
-		vType = types.PrecommitType
-		want  = &types.Vote{Timestamp: ts, Type: vType}
-		have  = &types.Vote{Timestamp: ts, Type: vType}
-	)
-	defer sc.Stop()
-	defer rs.Stop()
-
-	time.Sleep(3 * time.Millisecond)
-
-	require.NoError(t, rs.privVal.SignVote(chainID, want))
-	require.NoError(t, sc.SignVote(chainID, have))
-	assert.Equal(t, want.Signature, have.Signature)
-
-	// This would exceed the deadline if it was not extended by the previous message
-	time.Sleep(3 * time.Millisecond)
-
-	require.NoError(t, rs.privVal.SignVote(chainID, want))
-	require.NoError(t, sc.SignVote(chainID, have))
-	assert.Equal(t, want.Signature, have.Signature)
-}
-
-func TestSocketPVVoteKeepalive(t *testing.T) {
-	var (
-		chainID = cmn.RandStr(12)
-		sc, rs  = testSetupSocketPair(t, chainID, types.NewMockPV())
-
-		ts    = time.Now()
-		vType = types.PrecommitType
-		want  = &types.Vote{Timestamp: ts, Type: vType}
-		have  = &types.Vote{Timestamp: ts, Type: vType}
-	)
-	defer sc.Stop()
-	defer rs.Stop()
-
-	time.Sleep(10 * time.Millisecond)
-
-	require.NoError(t, rs.privVal.SignVote(chainID, want))
-	require.NoError(t, sc.SignVote(chainID, have))
-	assert.Equal(t, want.Signature, have.Signature)
-}
-
 func TestSocketPVHeartbeat(t *testing.T) {
 	var (
 		chainID = cmn.RandStr(12)
@@ -153,20 +107,36 @@ func TestSocketPVHeartbeat(t *testing.T) {
 	assert.Equal(t, want.Signature, have.Signature)
 }
 
+func TestSocketPVAcceptDeadline(t *testing.T) {
+	var (
+		sc = NewSocketPV(
+			log.TestingLogger(),
+			"127.0.0.1:0",
+			ed25519.GenPrivKey(),
+		)
+	)
+	defer sc.Stop()
+
+	SocketPVAcceptDeadline(time.Millisecond)(sc)
+
+	assert.Equal(t, sc.Start().(cmn.Error).Data(), ErrConnWaitTimeout)
+}
+
 func TestSocketPVDeadline(t *testing.T) {
 	var (
 		addr    = testFreeAddr(t)
 		listenc = make(chan struct{})
-		sc      = NewTCPVal(
+		sc      = NewSocketPV(
 			log.TestingLogger(),
 			addr,
 			ed25519.GenPrivKey(),
 		)
 	)
 
-	TCPValConnTimeout(100 * time.Millisecond)(sc)
+	SocketPVConnDeadline(100 * time.Millisecond)(sc)
+	SocketPVConnWait(500 * time.Millisecond)(sc)
 
-	go func(sc *TCPVal) {
+	go func(sc *SocketPV) {
 		defer close(listenc)
 
 		require.NoError(t, sc.Start())
@@ -191,10 +161,26 @@ func TestSocketPVDeadline(t *testing.T) {
 
 	<-listenc
 
+	// Sleep to guarantee deadline has been hit.
+	time.Sleep(20 * time.Microsecond)
+
 	_, err := sc.getPubKey()
 	assert.Equal(t, err.(cmn.Error).Data(), ErrConnTimeout)
 }
 
+func TestSocketPVWait(t *testing.T) {
+	sc := NewSocketPV(
+		log.TestingLogger(),
+		"127.0.0.1:0",
+		ed25519.GenPrivKey(),
+	)
+	defer sc.Stop()
+
+	SocketPVConnWait(time.Millisecond)(sc)
+
+	assert.Equal(t, sc.Start().(cmn.Error).Data(), ErrConnWaitTimeout)
+}
+
 func TestRemoteSignerRetry(t *testing.T) {
 	var (
 		attemptc = make(chan int)
@@ -235,7 +221,7 @@ func TestRemoteSignerRetry(t *testing.T) {
 	RemoteSignerConnDeadline(time.Millisecond)(rs)
 	RemoteSignerConnRetries(retries)(rs)
 
-	assert.Equal(t, rs.Start(), ErrDialRetryMax)
+	assert.Equal(t, rs.Start().(cmn.Error).Data(), ErrDialRetryMax)
 
 	select {
 	case attempts := <-attemptc:
@@ -342,7 +328,7 @@ func TestErrUnexpectedResponse(t *testing.T) {
 			types.NewMockPV(),
 			ed25519.GenPrivKey(),
 		)
-		sc = NewTCPVal(
+		sc = NewSocketPV(
 			logger,
 			addr,
 			ed25519.GenPrivKey(),
@@ -397,7 +383,7 @@ func testSetupSocketPair(
 	t *testing.T,
 	chainID string,
 	privValidator types.PrivValidator,
-) (*TCPVal, *RemoteSigner) {
+) (*SocketPV, *RemoteSigner) {
 	var (
 		addr    = testFreeAddr(t)
 		logger  = log.TestingLogger()
@@ -410,20 +396,18 @@ func testSetupSocketPair(
 			privVal,
 			ed25519.GenPrivKey(),
 		)
-		sc = NewTCPVal(
+		sc = NewSocketPV(
 			logger,
 			addr,
 			ed25519.GenPrivKey(),
 		)
 	)
 
-	TCPValConnTimeout(5 * time.Millisecond)(sc)
-	TCPValHeartbeat(2 * time.Millisecond)(sc)
-	RemoteSignerConnDeadline(5 * time.Millisecond)(rs)
-	RemoteSignerConnRetries(1e6)(rs)
-
 	testStartSocketPV(t, readyc, sc)
 
+	RemoteSignerConnDeadline(time.Millisecond)(rs)
+	RemoteSignerConnRetries(1e6)(rs)
+
 	require.NoError(t, rs.Start())
 	assert.True(t, rs.IsRunning())
 
@@ -432,7 +416,7 @@ func testSetupSocketPair(
 	return sc, rs
 }
 
-func testReadWriteResponse(t *testing.T, resp RemoteSignerMsg, rsConn net.Conn) {
+func testReadWriteResponse(t *testing.T, resp SocketPVMsg, rsConn net.Conn) {
 	_, err := readMsg(rsConn)
 	require.NoError(t, err)
 
@@ -440,8 +424,8 @@ func testReadWriteResponse(t *testing.T, resp RemoteSignerMsg, rsConn net.Conn)
 	require.NoError(t, err)
 }
 
-func testStartSocketPV(t *testing.T, readyc chan struct{}, sc *TCPVal) {
-	go func(sc *TCPVal) {
+func testStartSocketPV(t *testing.T, readyc chan struct{}, sc *SocketPV) {
+	go func(sc *SocketPV) {
 		require.NoError(t, sc.Start())
 		assert.True(t, sc.IsRunning())
 

privval/tcp.go

@@ -1,214 +0,0 @@
-package privval
-
-import (
-	"errors"
-	"net"
-	"time"
-
-	"github.com/tendermint/tendermint/crypto/ed25519"
-	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/libs/log"
-	p2pconn "github.com/tendermint/tendermint/p2p/conn"
-	"github.com/tendermint/tendermint/types"
-)
-
-const (
-	defaultAcceptDeadlineSeconds = 3
-	defaultConnDeadlineSeconds   = 3
-	defaultConnHeartBeatSeconds  = 2
-	defaultDialRetries           = 10
-)
-
-// Socket errors.
-var (
-	ErrDialRetryMax       = errors.New("dialed maximum retries")
-	ErrConnTimeout        = errors.New("remote signer timed out")
-	ErrUnexpectedResponse = errors.New("received unexpected response")
-)
-
-var (
-	acceptDeadline = time.Second * defaultAcceptDeadlineSeconds
-	connTimeout    = time.Second * defaultConnDeadlineSeconds
-	connHeartbeat  = time.Second * defaultConnHeartBeatSeconds
-)
-
-// TCPValOption sets an optional parameter on the SocketPV.
-type TCPValOption func(*TCPVal)
-
-// TCPValAcceptDeadline sets the deadline for the TCPVal listener.
-// A zero time value disables the deadline.
-func TCPValAcceptDeadline(deadline time.Duration) TCPValOption {
-	return func(sc *TCPVal) { sc.acceptDeadline = deadline }
-}
-
-// TCPValConnTimeout sets the read and write timeout for connections
-// from external signing processes.
-func TCPValConnTimeout(timeout time.Duration) TCPValOption {
-	return func(sc *TCPVal) { sc.connTimeout = timeout }
-}
-
-// TCPValHeartbeat sets the period on which to check the liveness of the
-// connected Signer connections.
-func TCPValHeartbeat(period time.Duration) TCPValOption {
-	return func(sc *TCPVal) { sc.connHeartbeat = period }
-}
-
-// TCPVal implements PrivValidator, it uses a socket to request signatures
-// from an external process.
-type TCPVal struct {
-	cmn.BaseService
-	*RemoteSignerClient
-
-	addr           string
-	acceptDeadline time.Duration
-	connTimeout    time.Duration
-	connHeartbeat  time.Duration
-	privKey        ed25519.PrivKeyEd25519
-
-	conn       net.Conn
-	listener   net.Listener
-	cancelPing chan struct{}
-	pingTicker *time.Ticker
-}
-
-// Check that TCPVal implements PrivValidator.
-var _ types.PrivValidator = (*TCPVal)(nil)
-
-// NewTCPVal returns an instance of TCPVal.
-func NewTCPVal(
-	logger log.Logger,
-	socketAddr string,
-	privKey ed25519.PrivKeyEd25519,
-) *TCPVal {
-	sc := &TCPVal{
-		addr:           socketAddr,
-		acceptDeadline: acceptDeadline,
-		connTimeout:    connTimeout,
-		connHeartbeat:  connHeartbeat,
-		privKey:        privKey,
-	}
-
-	sc.BaseService = *cmn.NewBaseService(logger, "TCPVal", sc)
-
-	return sc
-}
-
-// OnStart implements cmn.Service.
-func (sc *TCPVal) OnStart() error {
-	if err := sc.listen(); err != nil {
-		sc.Logger.Error("OnStart", "err", err)
-		return err
-	}
-
-	conn, err := sc.waitConnection()
-	if err != nil {
-		sc.Logger.Error("OnStart", "err", err)
-		return err
-	}
-
-	sc.conn = conn
-
-	sc.RemoteSignerClient = NewRemoteSignerClient(sc.conn)
-
-	// Start a routine to keep the connection alive
-	sc.cancelPing = make(chan struct{}, 1)
-	sc.pingTicker = time.NewTicker(sc.connHeartbeat)
-	go func() {
-		for {
-			select {
-			case <-sc.pingTicker.C:
-				err := sc.Ping()
-				if err != nil {
-					sc.Logger.Error(
-						"Ping",
-						"err", err,
-					)
-				}
-			case <-sc.cancelPing:
-				sc.pingTicker.Stop()
-				return
-			}
-		}
-	}()
-
-	return nil
-}
-
-// OnStop implements cmn.Service.
-func (sc *TCPVal) OnStop() {
-	if sc.cancelPing != nil {
-		close(sc.cancelPing)
-	}
-
-	if sc.conn != nil {
-		if err := sc.conn.Close(); err != nil {
-			sc.Logger.Error("OnStop", "err", err)
-		}
-	}
-
-	if sc.listener != nil {
-		if err := sc.listener.Close(); err != nil {
-			sc.Logger.Error("OnStop", "err", err)
-		}
-	}
-}
-
-func (sc *TCPVal) acceptConnection() (net.Conn, error) {
-	conn, err := sc.listener.Accept()
-	if err != nil {
-		if !sc.IsRunning() {
-			return nil, nil // Ignore error from listener closing.
-		}
-		return nil, err
-
-	}
-
-	conn, err = p2pconn.MakeSecretConnection(conn, sc.privKey)
-	if err != nil {
-		return nil, err
-	}
-
-	return conn, nil
-}
-
-func (sc *TCPVal) listen() error {
-	ln, err := net.Listen(cmn.ProtocolAndAddress(sc.addr))
-	if err != nil {
-		return err
-	}
-
-	sc.listener = newTCPTimeoutListener(
-		ln,
-		sc.acceptDeadline,
-		sc.connTimeout,
-		sc.connHeartbeat,
-	)
-
-	return nil
-}
-
-// waitConnection uses the configured wait timeout to error if no external
-// process connects in the time period.
-func (sc *TCPVal) waitConnection() (net.Conn, error) {
-	var (
-		connc = make(chan net.Conn, 1)
-		errc  = make(chan error, 1)
-	)
-
-	go func(connc chan<- net.Conn, errc chan<- error) {
-		conn, err := sc.acceptConnection()
-		if err != nil {
-			errc <- err
-			return
-		}
-
-		connc <- conn
-	}(connc, errc)
-
-	select {
-	case conn := <-connc:
-		return conn, nil
-	case err := <-errc:
-		return nil, err
-	}
-}

privval/tcp_server.go

@@ -1,160 +0,0 @@
-package privval
-
-import (
-	"io"
-	"net"
-	"time"
-
-	"github.com/tendermint/tendermint/crypto/ed25519"
-	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/libs/log"
-	p2pconn "github.com/tendermint/tendermint/p2p/conn"
-	"github.com/tendermint/tendermint/types"
-)
-
-// RemoteSignerOption sets an optional parameter on the RemoteSigner.
-type RemoteSignerOption func(*RemoteSigner)
-
-// RemoteSignerConnDeadline sets the read and write deadline for connections
-// from external signing processes.
-func RemoteSignerConnDeadline(deadline time.Duration) RemoteSignerOption {
-	return func(ss *RemoteSigner) { ss.connDeadline = deadline }
-}
-
-// RemoteSignerConnRetries sets the amount of attempted retries to connect.
-func RemoteSignerConnRetries(retries int) RemoteSignerOption {
-	return func(ss *RemoteSigner) { ss.connRetries = retries }
-}
-
-// RemoteSigner implements PrivValidator by dialing to a socket.
-type RemoteSigner struct {
-	cmn.BaseService
-
-	addr         string
-	chainID      string
-	connDeadline time.Duration
-	connRetries  int
-	privKey      ed25519.PrivKeyEd25519
-	privVal      types.PrivValidator
-
-	conn net.Conn
-}
-
-// NewRemoteSigner returns an instance of RemoteSigner.
-func NewRemoteSigner(
-	logger log.Logger,
-	chainID, socketAddr string,
-	privVal types.PrivValidator,
-	privKey ed25519.PrivKeyEd25519,
-) *RemoteSigner {
-	rs := &RemoteSigner{
-		addr:         socketAddr,
-		chainID:      chainID,
-		connDeadline: time.Second * defaultConnDeadlineSeconds,
-		connRetries:  defaultDialRetries,
-		privKey:      privKey,
-		privVal:      privVal,
-	}
-
-	rs.BaseService = *cmn.NewBaseService(logger, "RemoteSigner", rs)
-
-	return rs
-}
-
-// OnStart implements cmn.Service.
-func (rs *RemoteSigner) OnStart() error {
-	conn, err := rs.connect()
-	if err != nil {
-		rs.Logger.Error("OnStart", "err", err)
-		return err
-	}
-
-	go rs.handleConnection(conn)
-
-	return nil
-}
-
-// OnStop implements cmn.Service.
-func (rs *RemoteSigner) OnStop() {
-	if rs.conn == nil {
-		return
-	}
-
-	if err := rs.conn.Close(); err != nil {
-		rs.Logger.Error("OnStop", "err", cmn.ErrorWrap(err, "closing listener failed"))
-	}
-}
-
-func (rs *RemoteSigner) connect() (net.Conn, error) {
-	for retries := rs.connRetries; retries > 0; retries-- {
-		// Don't sleep if it is the first retry.
-		if retries != rs.connRetries {
-			time.Sleep(rs.connDeadline)
-		}
-
-		conn, err := cmn.Connect(rs.addr)
-		if err != nil {
-			rs.Logger.Error(
-				"connect",
-				"addr", rs.addr,
-				"err", err,
-			)
-
-			continue
-		}
-
-		if err := conn.SetDeadline(time.Now().Add(connTimeout)); err != nil {
-			rs.Logger.Error(
-				"connect",
-				"err", err,
-			)
-			continue
-		}
-
-		conn, err = p2pconn.MakeSecretConnection(conn, rs.privKey)
-		if err != nil {
-			rs.Logger.Error(
-				"connect",
-				"err", err,
-			)
-
-			continue
-		}
-
-		return conn, nil
-	}
-
-	return nil, ErrDialRetryMax
-}
-
-func (rs *RemoteSigner) handleConnection(conn net.Conn) {
-	for {
-		if !rs.IsRunning() {
-			return // Ignore error from listener closing.
-		}
-
-		// Reset the connection deadline
-		conn.SetDeadline(time.Now().Add(rs.connDeadline))
-
-		req, err := readMsg(conn)
-		if err != nil {
-			if err != io.EOF {
-				rs.Logger.Error("handleConnection", "err", err)
-			}
-			return
-		}
-
-		res, err := handleRequest(req, rs.chainID, rs.privVal)
-
-		if err != nil {
-			// only log the error; we'll reply with an error in res
-			rs.Logger.Error("handleConnection", "err", err)
-		}
-
-		err = writeMsg(conn, res)
-		if err != nil {
-			rs.Logger.Error("handleConnection", "err", err)
-			return
-		}
-	}
-}

privval/wire.go

@@ -9,5 +9,5 @@ var cdc = amino.NewCodec()
 
 func init() {
 	cryptoAmino.RegisterAmino(cdc)
-	RegisterRemoteSignerMsg(cdc)
+	RegisterSocketPVMsg(cdc)
 }

proxy/app_conn_test.go

@@ -143,7 +143,7 @@ func TestInfo(t *testing.T) {
 	proxy := NewAppConnTest(cli)
 	t.Log("Connected")
 
-	resInfo, err := proxy.InfoSync(RequestInfo)
+	resInfo, err := proxy.InfoSync(types.RequestInfo{Version: ""})
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}

proxy/version.go

@@ -1,15 +0,0 @@
-package proxy
-
-import (
-	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/version"
-)
-
-// RequestInfo contains all the information for sending
-// the abci.RequestInfo message during handshake with the app.
-// It contains only compile-time version information.
-var RequestInfo = abci.RequestInfo{
-	Version:      version.Version,
-	BlockVersion: version.BlockProtocol.Uint64(),
-	P2PVersion:   version.P2PProtocol.Uint64(),
-}

rpc/client/mock/abci.go

@@ -3,10 +3,10 @@ package mock
 import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/rpc/client"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 	"github.com/tendermint/tendermint/types"
+	"github.com/tendermint/tendermint/version"
 )
 
 // ABCIApp will send all abci related request to the named app,
@@ -23,7 +23,7 @@ var (
 )
 
 func (a ABCIApp) ABCIInfo() (*ctypes.ResultABCIInfo, error) {
-	return &ctypes.ResultABCIInfo{a.App.Info(proxy.RequestInfo)}, nil
+	return &ctypes.ResultABCIInfo{a.App.Info(abci.RequestInfo{Version: version.Version})}, nil
 }
 
 func (a ABCIApp) ABCIQuery(path string, data cmn.HexBytes) (*ctypes.ResultABCIQuery, error) {

rpc/core/abci.go

@@ -3,8 +3,8 @@ package core
 import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/proxy"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
+	"github.com/tendermint/tendermint/version"
 )
 
 // Query the application for some information.
@@ -87,7 +87,7 @@ func ABCIQuery(path string, data cmn.HexBytes, height int64, prove bool) (*ctype
 // }
 // ```
 func ABCIInfo() (*ctypes.ResultABCIInfo, error) {
-	resInfo, err := proxyAppQuery.InfoSync(proxy.RequestInfo)
+	resInfo, err := proxyAppQuery.InfoSync(abci.RequestInfo{Version: version.Version})
 	if err != nil {
 		return nil, err
 	}

rpc/core/status.go

@@ -31,11 +31,6 @@ import (
 // "id": "",
 // "result": {
 //   "node_info": {
-//   		"protocol_version": {
-//   			"p2p": "4",
-//   			"block": "7",
-//   			"app": "0"
-//   		},
 //   		"id": "53729852020041b956e86685e24394e0bee4373f",
 //   		"listen_addr": "10.0.2.15:26656",
 //   		"network": "test-chain-Y1OHx6",
@@ -43,6 +38,10 @@ import (
 //   		"channels": "4020212223303800",
 //   		"moniker": "ubuntu-xenial",
 //   		"other": {
+//   			"amino_version": "0.12.0",
+//   			"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:26657"
 //   		}

rpc/core/version.go

@@ -0,0 +1,5 @@
+package core
+
+// a single integer is sufficient here
+
+const Version = "3" // rpc routes for profiling, setting config

rpc/lib/server/http_server.go

@@ -173,7 +173,8 @@ func RecoverAndLogHandler(handler http.Handler, logger log.Logger) http.Handler
 						"Panic in RPC HTTP handler", "err", e, "stack",
 						string(debug.Stack()),
 					)
-					WriteRPCResponseHTTPError(rww, http.StatusInternalServerError, types.RPCInternalError("", e.(error)))
+					rww.WriteHeader(http.StatusInternalServerError)
+					WriteRPCResponseHTTP(rww, types.RPCInternalError("", e.(error)))
 				}
 			}
 

rpc/lib/version.go

@@ -0,0 +1,7 @@
+package rpc
+
+const Maj = "0"
+const Min = "7"
+const Fix = "0"
+
+const Version = Maj + "." + Min + "." + Fix

scripts/authors.sh

@@ -1,16 +0,0 @@
-#! /bin/bash
-
-# Usage:
-#   `./authors.sh`
-#		Print a list of all authors who have committed to develop since master.
-#
-#   `./authors.sh <email address>`
-#		Lookup the email address on Github and print the associated username
-
-author=$1
-
-if [[ "$author" == "" ]]; then
-	git log master..develop | grep Author | sort | uniq
-else
-	curl -s "https://api.github.com/search/users?q=$author+in%3Aemail&type=Users&utf8=%E2%9C%93" | jq .items[0].login
-fi

scripts/install/install_tendermint_bsd.sh

@@ -17,15 +17,16 @@ set BRANCH=master
 
 sudo pkg update
 
+sudo pkg upgrade -y
 sudo pkg install -y gmake
 sudo pkg install -y git
 
 # get and unpack golang
-curl -O https://storage.googleapis.com/golang/go1.11.freebsd-amd64.tar.gz
-tar -xvf go1.11.freebsd-amd64.tar.gz
+curl -O https://storage.googleapis.com/golang/go1.10.freebsd-amd64.tar.gz
+tar -xvf go1.10.freebsd-amd64.tar.gz
 
-# move go folder and add go binary to path
-sudo mv go /usr/local
+# move go binary and add to path
+mv go /usr/local
 set path=($path /usr/local/go/bin)
 
 
@@ -40,7 +41,7 @@ source ~/.tcshrc
 # get the code and move into repo
 set REPO=github.com/tendermint/tendermint
 go get $REPO
-cd "$GOPATH/src/$REPO"
+cd $GOPATH/src/$REPO
 
 # build & install master
 git checkout $BRANCH

scripts/install/install_tendermint_ubuntu.sh

@@ -14,25 +14,27 @@ REPO=github.com/tendermint/tendermint
 BRANCH=master
 
 sudo apt-get update -y
+sudo apt-get upgrade -y
 sudo apt-get install -y make
 
 # get and unpack golang
-curl -O https://storage.googleapis.com/golang/go1.11.linux-amd64.tar.gz
-tar -xvf go1.11.linux-amd64.tar.gz
+curl -O https://storage.googleapis.com/golang/go1.10.linux-amd64.tar.gz
+tar -xvf go1.10.linux-amd64.tar.gz
 
-# move go folder and add go binary to path
-sudo mv go /usr/local
+# move go binary and add to path
+mv go /usr/local
 echo "export PATH=\$PATH:/usr/local/go/bin" >> ~/.profile
 
 # create the goApps directory, set GOPATH, and put it on PATH
 mkdir goApps
-echo "export GOPATH=$HOME/goApps" >> ~/.profile
+echo "export GOPATH=/root/goApps" >> ~/.profile
 echo "export PATH=\$PATH:\$GOPATH/bin" >> ~/.profile
+
 source ~/.profile
 
 # get the code and move into repo
 go get $REPO
-cd "$GOPATH/src/$REPO"
+cd $GOPATH/src/$REPO
 
 # build & install
 git checkout $BRANCH

state/execution.go

@@ -398,13 +398,9 @@ func updateState(
 		lastHeightParamsChanged = header.Height + 1
 	}
 
-	// TODO: allow app to upgrade version
-	nextVersion := state.Version
-
 	// NOTE: the AppHash has not been populated.
 	// It will be filled on state.Save.
 	return State{
-		Version:                          nextVersion,
 		ChainID:                          state.ChainID,
 		LastBlockHeight:                  header.Height,
 		LastBlockTotalTx:                 state.LastBlockTotalTx + header.NumTxs,

state/state.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
-	"github.com/tendermint/tendermint/version"
 )
 
 // database keys
@@ -18,29 +17,6 @@ var (
 
 //-----------------------------------------------------------------------------
 
-// Version is for versioning the State.
-// It holds the Block and App version needed for making blocks,
-// and the software version to support upgrades to the format of
-// the State as stored on disk.
-type Version struct {
-	Consensus version.Consensus
-	Software  string
-}
-
-// initStateVersion sets the Consensus.Block and Software versions,
-// but leaves the Consensus.App version blank.
-// The Consensus.App version will be set during the Handshake, once
-// we hear from the app what protocol version it is running.
-var initStateVersion = Version{
-	Consensus: version.Consensus{
-		Block: version.BlockProtocol,
-		App:   0,
-	},
-	Software: version.TMCoreSemVer,
-}
-
-//-----------------------------------------------------------------------------
-
 // State is a short description of the latest committed block of the Tendermint consensus.
 // It keeps all information necessary to validate new blocks,
 // including the last validator set and the consensus params.
@@ -49,8 +25,6 @@ var initStateVersion = Version{
 // Instead, use state.Copy() or state.NextState(...).
 // NOTE: not goroutine-safe.
 type State struct {
-	Version Version
-
 	// immutable
 	ChainID string
 
@@ -85,7 +59,6 @@ type State struct {
 // Copy makes a copy of the State for mutating.
 func (state State) Copy() State {
 	return State{
-		Version: state.Version,
 		ChainID: state.ChainID,
 
 		LastBlockHeight:  state.LastBlockHeight,
@@ -128,7 +101,7 @@ func (state State) IsEmpty() bool {
 
 // MakeBlock builds a block from the current state with the given txs, commit,
 // and evidence. Note it also takes a proposerAddress because the state does not
-// track rounds, and hence does not know the correct proposer. TODO: fix this!
+// track rounds, and hence doesn't know the correct proposer. TODO: alleviate this!
 func (state State) MakeBlock(
 	height int64,
 	txs []types.Tx,
@@ -140,22 +113,28 @@ func (state State) MakeBlock(
 	// Build base block with block data.
 	block := types.MakeBlock(height, txs, commit, evidence)
 
-	// Set time.
-	var timestamp time.Time
+	// Fill rest of header with state data.
+	block.ChainID = state.ChainID
+
+	// Set time
 	if height == 1 {
-		timestamp = state.LastBlockTime // genesis time
+		block.Time = state.LastBlockTime // genesis time
 	} else {
-		timestamp = MedianTime(commit, state.LastValidators)
+		block.Time = MedianTime(commit, state.LastValidators)
 	}
 
-	// Fill rest of header with state data.
-	block.Header.Populate(
-		state.Version.Consensus, state.ChainID,
-		timestamp, state.LastBlockID, state.LastBlockTotalTx+block.NumTxs,
-		state.Validators.Hash(), state.NextValidators.Hash(),
-		state.ConsensusParams.Hash(), state.AppHash, state.LastResultsHash,
-		proposerAddress,
-	)
+	block.LastBlockID = state.LastBlockID
+	block.TotalTxs = state.LastBlockTotalTx + block.NumTxs
+
+	block.ValidatorsHash = state.Validators.Hash()
+	block.NextValidatorsHash = state.NextValidators.Hash()
+	block.ConsensusHash = state.ConsensusParams.Hash()
+	block.AppHash = state.AppHash
+	block.LastResultsHash = state.LastResultsHash
+
+	// NOTE: we can't use the state.Validators because we don't
+	// IncrementAccum for rounds there.
+	block.ProposerAddress = proposerAddress
 
 	return block, block.MakePartSet(types.BlockPartSizeBytes)
 }
@@ -215,6 +194,7 @@ func MakeGenesisState(genDoc *types.GenesisDoc) (State, error) {
 		return State{}, fmt.Errorf("Error in genesis file: %v", err)
 	}
 
+	// Make validators slice
 	var validatorSet, nextValidatorSet *types.ValidatorSet
 	if genDoc.Validators == nil {
 		validatorSet = types.NewValidatorSet(nil)
@@ -222,14 +202,22 @@ func MakeGenesisState(genDoc *types.GenesisDoc) (State, error) {
 	} else {
 		validators := make([]*types.Validator, len(genDoc.Validators))
 		for i, val := range genDoc.Validators {
-			validators[i] = types.NewValidator(val.PubKey, val.Power)
+			pubKey := val.PubKey
+			address := pubKey.Address()
+
+			// Make validator
+			validators[i] = &types.Validator{
+				Address:     address,
+				PubKey:      pubKey,
+				VotingPower: val.Power,
+			}
 		}
 		validatorSet = types.NewValidatorSet(validators)
 		nextValidatorSet = types.NewValidatorSet(validators).CopyIncrementAccum(1)
 	}
 
 	return State{
-		Version: initStateVersion,
+
 		ChainID: genDoc.ChainID,
 
 		LastBlockHeight: 0,

state/state_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"fmt"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -12,6 +13,7 @@ import (
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	dbm "github.com/tendermint/tendermint/libs/db"
+	tmtime "github.com/tendermint/tendermint/types/time"
 
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/types"
@@ -319,11 +321,9 @@ func TestStateMakeBlock(t *testing.T) {
 	defer tearDown(t)
 
 	proposerAddress := state.Validators.GetProposer().Address
-	stateVersion := state.Version.Consensus
 	block := makeBlock(state, 2)
 
-	// test we set some fields
-	assert.Equal(t, stateVersion, block.Version)
+	// test we set proposer address
 	assert.Equal(t, proposerAddress, block.ProposerAddress)
 }
 
@@ -388,14 +388,14 @@ func TestConsensusParamsChangesSaveLoad(t *testing.T) {
 	}
 }
 
-func makeParams(blockBytes, blockGas, evidenceAge int64) types.ConsensusParams {
+func makeParams(blockBytes, blockGas int64, evidenceAge time.Duration) types.ConsensusParams {
 	return types.ConsensusParams{
 		BlockSize: types.BlockSize{
 			MaxBytes: blockBytes,
 			MaxGas:   blockGas,
 		},
 		EvidenceParams: types.EvidenceParams{
-			MaxAge: evidenceAge,
+			MaxAge: tmtime.DurationPretty{evidenceAge},
 		},
 	}
 }
@@ -405,7 +405,7 @@ func pk() []byte {
 }
 
 func TestApplyUpdates(t *testing.T) {
-	initParams := makeParams(1, 2, 3)
+	initParams := makeParams(1, 2, 3*time.Second)
 
 	cases := [...]struct {
 		init     types.ConsensusParams
@@ -421,14 +421,14 @@ func TestApplyUpdates(t *testing.T) {
 					MaxGas:   55,
 				},
 			},
-			makeParams(44, 55, 3)},
+			makeParams(44, 55, 3*time.Second)},
 		3: {initParams,
 			abci.ConsensusParams{
 				EvidenceParams: &abci.EvidenceParams{
-					MaxAge: 66,
+					MaxAge: 66 * time.Second,
 				},
 			},
-			makeParams(1, 2, 66)},
+			makeParams(1, 2, 66*time.Second)},
 	}
 
 	for i, tc := range cases {

state/validation.go

@@ -20,13 +20,6 @@ func validateBlock(stateDB dbm.DB, state State, block *types.Block) error {
 	}
 
 	// Validate basic info.
-	if block.Version != state.Version.Consensus {
-		return fmt.Errorf(
-			"Wrong Block.Header.Version. Expected %v, got %v",
-			state.Version.Consensus,
-			block.Version,
-		)
-	}
 	if block.ChainID != state.ChainID {
 		return fmt.Errorf(
 			"Wrong Block.Header.ChainID. Expected %v, got %v",
@@ -175,13 +168,11 @@ func validateBlock(stateDB dbm.DB, state State, block *types.Block) error {
 // - it is internally consistent
 // - it was properly signed by the alleged equivocator
 func VerifyEvidence(stateDB dbm.DB, state State, evidence types.Evidence) error {
-	height := state.LastBlockHeight
-
-	evidenceAge := height - evidence.Height()
-	maxAge := state.ConsensusParams.EvidenceParams.MaxAge
+	evidenceAge := state.LastBlockTime.Sub(evidence.Time())
+	maxAge := state.ConsensusParams.EvidenceParams.MaxAge.Duration
 	if evidenceAge > maxAge {
-		return fmt.Errorf("Evidence from height %d is too old. Min height is %d",
-			evidence.Height(), height-maxAge)
+		return fmt.Errorf("Evidence from %v is too old. Expecting evidence no older than %v",
+			evidence.Time(), state.LastBlockTime.Add(-maxAge))
 	}
 
 	valset, err := LoadValidators(stateDB, evidence.Height())

state/validation_test.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/require"
-
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	"github.com/tendermint/tendermint/libs/log"
@@ -27,20 +26,13 @@ func TestValidateBlockHeader(t *testing.T) {
 	err := blockExec.ValidateBlock(state, block)
 	require.NoError(t, err)
 
-	// some bad values
 	wrongHash := tmhash.Sum([]byte("this hash is wrong"))
-	wrongVersion1 := state.Version.Consensus
-	wrongVersion1.Block += 1
-	wrongVersion2 := state.Version.Consensus
-	wrongVersion2.App += 1
 
 	// Manipulation of any header field causes failure.
 	testCases := []struct {
 		name          string
 		malleateBlock func(block *types.Block)
 	}{
-		{"Version wrong1", func(block *types.Block) { block.Version = wrongVersion1 }},
-		{"Version wrong2", func(block *types.Block) { block.Version = wrongVersion2 }},
 		{"ChainID wrong", func(block *types.Block) { block.ChainID = "not-the-real-one" }},
 		{"Height wrong", func(block *types.Block) { block.Height += 10 }},
 		{"Time wrong", func(block *types.Block) { block.Time = block.Time.Add(-time.Second * 3600 * 24) }},

tools/tm-monitor/monitor/network.go

@@ -140,22 +140,14 @@ func (n *Network) NodeIsOnline(name string) {
 
 // NewNode is called when the new node is added to the monitor.
 func (n *Network) NewNode(name string) {
-	n.mu.Lock()
-	defer n.mu.Unlock()
-
 	n.NumNodesMonitored++
 	n.NumNodesMonitoredOnline++
-	n.updateHealth()
 }
 
 // NodeDeleted is called when the node is deleted from under the monitor.
 func (n *Network) NodeDeleted(name string) {
-	n.mu.Lock()
-	defer n.mu.Unlock()
-
 	n.NumNodesMonitored--
 	n.NumNodesMonitoredOnline--
-	n.updateHealth()
 }
 
 func (n *Network) updateHealth() {

types/block.go

@@ -10,12 +10,11 @@ import (
 
 	"github.com/tendermint/tendermint/crypto/merkle"
 	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/version"
 )
 
 const (
 	// MaxHeaderBytes is a maximum header size (including amino overhead).
-	MaxHeaderBytes int64 = 537
+	MaxHeaderBytes int64 = 511
 
 	// MaxAminoOverheadForBlock - maximum amino overhead to encode a block (up to
 	// MaxBlockSizeBytes in size) not including it's parts except Data.
@@ -28,6 +27,7 @@ const (
 )
 
 // Block defines the atomic unit of a Tendermint blockchain.
+// TODO: add Version byte
 type Block struct {
 	mtx        sync.Mutex
 	Header     `json:"header"`
@@ -149,7 +149,7 @@ func (b *Block) MakePartSet(partSize int) *PartSet {
 
 	// We prefix the byte length, so that unmarshaling
 	// can easily happen via a reader.
-	bz, err := cdc.MarshalBinaryLengthPrefixed(b)
+	bz, err := cdc.MarshalBinary(b)
 	if err != nil {
 		panic(err)
 	}
@@ -257,19 +257,17 @@ func MaxDataBytesUnknownEvidence(maxBytes int64, valsCount int) int64 {
 
 //-----------------------------------------------------------------------------
 
-// Header defines the structure of a Tendermint block header.
-// NOTE: changes to the Header should be duplicated in:
-// - header.Hash()
-// - abci.Header
-// - /docs/spec/blockchain/blockchain.md
+// Header defines the structure of a Tendermint block header
+// TODO: limit header size
+// NOTE: changes to the Header should be duplicated in the abci Header
+// and in /docs/spec/blockchain/blockchain.md
 type Header struct {
 	// basic block info
-	Version  version.Consensus `json:"version"`
-	ChainID  string            `json:"chain_id"`
-	Height   int64             `json:"height"`
-	Time     time.Time         `json:"time"`
-	NumTxs   int64             `json:"num_txs"`
-	TotalTxs int64             `json:"total_txs"`
+	ChainID  string    `json:"chain_id"`
+	Height   int64     `json:"height"`
+	Time     time.Time `json:"time"`
+	NumTxs   int64     `json:"num_txs"`
+	TotalTxs int64     `json:"total_txs"`
 
 	// prev block info
 	LastBlockID BlockID `json:"last_block_id"`
@@ -290,31 +288,7 @@ type Header struct {
 	ProposerAddress Address      `json:"proposer_address"` // original proposer of the block
 }
 
-// Populate the Header with state-derived data.
-// Call this after MakeBlock to complete the Header.
-func (h *Header) Populate(
-	version version.Consensus, chainID string,
-	timestamp time.Time, lastBlockID BlockID, totalTxs int64,
-	valHash, nextValHash []byte,
-	consensusHash, appHash, lastResultsHash []byte,
-	proposerAddress Address,
-) {
-	h.Version = version
-	h.ChainID = chainID
-	h.Time = timestamp
-	h.LastBlockID = lastBlockID
-	h.TotalTxs = totalTxs
-	h.ValidatorsHash = valHash
-	h.NextValidatorsHash = nextValHash
-	h.ConsensusHash = consensusHash
-	h.AppHash = appHash
-	h.LastResultsHash = lastResultsHash
-	h.ProposerAddress = proposerAddress
-}
-
 // Hash returns the hash of the header.
-// It computes a Merkle tree from the header fields
-// ordered as they appear in the Header.
 // Returns nil if ValidatorHash is missing,
 // since a Header is not valid unless there is
 // a ValidatorsHash (corresponding to the validator set).
@@ -322,23 +296,22 @@ func (h *Header) Hash() cmn.HexBytes {
 	if h == nil || len(h.ValidatorsHash) == 0 {
 		return nil
 	}
-	return merkle.SimpleHashFromByteSlices([][]byte{
-		cdcEncode(h.Version),
-		cdcEncode(h.ChainID),
-		cdcEncode(h.Height),
-		cdcEncode(h.Time),
-		cdcEncode(h.NumTxs),
-		cdcEncode(h.TotalTxs),
-		cdcEncode(h.LastBlockID),
-		cdcEncode(h.LastCommitHash),
-		cdcEncode(h.DataHash),
-		cdcEncode(h.ValidatorsHash),
-		cdcEncode(h.NextValidatorsHash),
-		cdcEncode(h.ConsensusHash),
-		cdcEncode(h.AppHash),
-		cdcEncode(h.LastResultsHash),
-		cdcEncode(h.EvidenceHash),
-		cdcEncode(h.ProposerAddress),
+	return merkle.SimpleHashFromMap(map[string][]byte{
+		"ChainID":            cdcEncode(h.ChainID),
+		"Height":             cdcEncode(h.Height),
+		"Time":               cdcEncode(h.Time),
+		"NumTxs":             cdcEncode(h.NumTxs),
+		"TotalTxs":           cdcEncode(h.TotalTxs),
+		"LastBlockID":        cdcEncode(h.LastBlockID),
+		"LastCommitHash":     cdcEncode(h.LastCommitHash),
+		"DataHash":           cdcEncode(h.DataHash),
+		"ValidatorsHash":     cdcEncode(h.ValidatorsHash),
+		"NextValidatorsHash": cdcEncode(h.NextValidatorsHash),
+		"AppHash":            cdcEncode(h.AppHash),
+		"ConsensusHash":      cdcEncode(h.ConsensusHash),
+		"LastResultsHash":    cdcEncode(h.LastResultsHash),
+		"EvidenceHash":       cdcEncode(h.EvidenceHash),
+		"ProposerAddress":    cdcEncode(h.ProposerAddress),
 	})
 }
 
@@ -348,7 +321,6 @@ func (h *Header) StringIndented(indent string) string {
 		return "nil-Header"
 	}
 	return fmt.Sprintf(`Header{
-%s  Version:        %v
 %s  ChainID:        %v
 %s  Height:         %v
 %s  Time:           %v
@@ -365,7 +337,6 @@ func (h *Header) StringIndented(indent string) string {
 %s  Evidence:       %v
 %s  Proposer:       %v
 %s}#%v`,
-		indent, h.Version,
 		indent, h.ChainID,
 		indent, h.Height,
 		indent, h.Time,
@@ -567,7 +538,6 @@ func (sh SignedHeader) ValidateBasic(chainID string) error {
 	if sh.Commit == nil {
 		return errors.New("SignedHeader missing commit (precommit votes).")
 	}
-
 	// Check ChainID.
 	if sh.ChainID != chainID {
 		return fmt.Errorf("Header belongs to another chain '%s' not '%s'",

types/block_test.go

@@ -12,7 +12,6 @@ import (
 
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/version"
 )
 
 func TestMain(m *testing.M) {
@@ -242,15 +241,10 @@ func TestMaxHeaderBytes(t *testing.T) {
 		maxChainID += "𠜎"
 	}
 
-	// time is varint encoded so need to pick the max.
-	// year int, month Month, day, hour, min, sec, nsec int, loc *Location
-	timestamp := time.Date(math.MaxInt64, 0, 0, 0, 0, 0, math.MaxInt64, time.UTC)
-
 	h := Header{
-		Version:            version.Consensus{math.MaxInt64, math.MaxInt64},
 		ChainID:            maxChainID,
 		Height:             math.MaxInt64,
-		Time:               timestamp,
+		Time:               time.Now().UTC(),
 		NumTxs:             math.MaxInt64,
 		TotalTxs:           math.MaxInt64,
 		LastBlockID:        makeBlockID(make([]byte, tmhash.Size), math.MaxInt64, make([]byte, tmhash.Size)),
@@ -265,7 +259,7 @@ func TestMaxHeaderBytes(t *testing.T) {
 		ProposerAddress:    tmhash.Sum([]byte("proposer_address")),
 	}
 
-	bz, err := cdc.MarshalBinaryLengthPrefixed(h)
+	bz, err := cdc.MarshalBinary(h)
 	require.NoError(t, err)
 
 	assert.EqualValues(t, MaxHeaderBytes, len(bz))
@@ -292,9 +286,9 @@ func TestBlockMaxDataBytes(t *testing.T) {
 	}{
 		0: {-10, 1, 0, true, 0},
 		1: {10, 1, 0, true, 0},
-		2: {750, 1, 0, true, 0},
-		3: {751, 1, 0, false, 0},
-		4: {752, 1, 0, false, 1},
+		2: {721, 1, 0, true, 0},
+		3: {722, 1, 0, false, 0},
+		4: {723, 1, 0, false, 1},
 	}
 
 	for i, tc := range testCases {
@@ -320,9 +314,9 @@ func TestBlockMaxDataBytesUnknownEvidence(t *testing.T) {
 	}{
 		0: {-10, 1, true, 0},
 		1: {10, 1, true, 0},
-		2: {833, 1, true, 0},
-		3: {834, 1, false, 0},
-		4: {835, 1, false, 1},
+		2: {801, 1, true, 0},
+		3: {802, 1, false, 0},
+		4: {803, 1, false, 1},
 	}
 
 	for i, tc := range testCases {

types/canonical.go

@@ -23,9 +23,10 @@ type CanonicalPartSetHeader struct {
 }
 
 type CanonicalProposal struct {
-	Type             SignedMsgType // type alias for byte
+	Version          uint64        `binary:"fixed64"`
 	Height           int64         `binary:"fixed64"`
 	Round            int64         `binary:"fixed64"`
+	Type             SignedMsgType // type alias for byte
 	POLRound         int64         `binary:"fixed64"`
 	Timestamp        time.Time
 	BlockPartsHeader CanonicalPartSetHeader
@@ -34,19 +35,21 @@ type CanonicalProposal struct {
 }
 
 type CanonicalVote struct {
-	Type      SignedMsgType // type alias for byte
+	Version   uint64        `binary:"fixed64"`
 	Height    int64         `binary:"fixed64"`
 	Round     int64         `binary:"fixed64"`
+	Type      SignedMsgType // type alias for byte
 	Timestamp time.Time
 	BlockID   CanonicalBlockID
 	ChainID   string
 }
 
 type CanonicalHeartbeat struct {
+	Version          uint64 `binary:"fixed64"`
+	Height           int64  `binary:"fixed64"`
+	Round            int    `binary:"fixed64"`
 	Type             byte
-	Height           int64 `binary:"fixed64"`
-	Round            int   `binary:"fixed64"`
-	Sequence         int   `binary:"fixed64"`
+	Sequence         int `binary:"fixed64"`
 	ValidatorAddress Address
 	ValidatorIndex   int
 	ChainID          string
@@ -71,9 +74,10 @@ func CanonicalizePartSetHeader(psh PartSetHeader) CanonicalPartSetHeader {
 
 func CanonicalizeProposal(chainID string, proposal *Proposal) CanonicalProposal {
 	return CanonicalProposal{
-		Type:             ProposalType,
+		Version:          0, // TODO
 		Height:           proposal.Height,
 		Round:            int64(proposal.Round), // cast int->int64 to make amino encode it fixed64 (does not work for int)
+		Type:             ProposalType,
 		POLRound:         int64(proposal.POLRound),
 		Timestamp:        proposal.Timestamp,
 		BlockPartsHeader: CanonicalizePartSetHeader(proposal.BlockPartsHeader),
@@ -84,9 +88,10 @@ func CanonicalizeProposal(chainID string, proposal *Proposal) CanonicalProposal
 
 func CanonicalizeVote(chainID string, vote *Vote) CanonicalVote {
 	return CanonicalVote{
-		Type:      vote.Type,
+		Version:   0, // TODO
 		Height:    vote.Height,
 		Round:     int64(vote.Round), // cast int->int64 to make amino encode it fixed64 (does not work for int)
+		Type:      vote.Type,
 		Timestamp: vote.Timestamp,
 		BlockID:   CanonicalizeBlockID(vote.BlockID),
 		ChainID:   chainID,
@@ -95,9 +100,10 @@ func CanonicalizeVote(chainID string, vote *Vote) CanonicalVote {
 
 func CanonicalizeHeartbeat(chainID string, heartbeat *Heartbeat) CanonicalHeartbeat {
 	return CanonicalHeartbeat{
-		Type:             byte(HeartbeatType),
+		Version:          0, // TODO
 		Height:           heartbeat.Height,
 		Round:            heartbeat.Round,
+		Type:             byte(HeartbeatType),
 		Sequence:         heartbeat.Sequence,
 		ValidatorAddress: heartbeat.ValidatorAddress,
 		ValidatorIndex:   heartbeat.ValidatorIndex,

types/checked_ints.go

@@ -1,33 +0,0 @@
-package types
-
-import (
-	"errors"
-	"math"
-)
-
-var ErrOverflowInt = errors.New("integer overflow")
-
-type CheckedInt32 int32
-type CheckedUint32 uint32
-
-type CheckedInt64 int64
-type CheckedUint64 int64
-
-func (i32 CheckedInt32) CheckedAdd(otherI32 CheckedInt32) (CheckedInt32, error) {
-	if otherI32 > 0 && (i32 > math.MaxInt32-otherI32) {
-		return 0, ErrOverflowInt
-	} else if otherI32 < 0 && (i32 < math.MinInt32-otherI32) {
-		return 0, ErrOverflowInt
-	}
-	return i32 + otherI32, nil
-}
-
-func (i32 CheckedInt32) CheckedSub(otherI32 CheckedInt32) (CheckedInt32, error) {
-	if otherI32 > 0 && (i32 < math.MinInt32+otherI32) {
-		return 0, ErrOverflowInt
-	} else if otherI32 < 0 && (i32 > math.MaxInt32+otherI32) {
-		return 0, ErrOverflowInt
-	}
-	return i32 - otherI32, nil
-
-}

types/checked_ints_test.go

@@ -1,61 +0,0 @@
-package types
-
-import (
-	"math"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestCheckedInt32_CheckedAdd(t *testing.T) {
-	tcs := []struct {
-		val1    int32
-		val2    int32
-		sum     int32
-		wantErr bool
-	}{
-		0: {math.MaxInt32, 1, 0, true},
-		1: {math.MinInt32, 1, math.MinInt32 + 1, false},
-		2: {math.MaxInt32, math.MaxInt32, 0, true},
-		3: {0, math.MaxInt32, math.MaxInt32, false},
-		4: {0, 1, 1, false},
-		5: {1, 1, 2, false},
-	}
-	for i, tc := range tcs {
-		v1 := CheckedInt32(tc.val1)
-		v2 := CheckedInt32(tc.val2)
-		sum, err := v1.CheckedAdd(v2)
-		if tc.wantErr {
-			assert.Error(t, err, "Should fail: %v", i)
-			assert.Zero(t, sum, "Got invalid sum for case %v", i)
-		} else {
-			assert.EqualValues(t, tc.sum, sum)
-		}
-	}
-}
-
-func TestCheckedInt32_CheckedSub(t *testing.T) {
-	tcs := []struct {
-		val1    int32
-		val2    int32
-		sum     int32
-		wantErr bool
-	}{
-		0: {math.MaxInt32, math.MaxInt32, 0, false},
-		1: {math.MinInt32, 1, 0, true},
-		2: {math.MinInt32 + 1, 1, math.MinInt32, false},
-		3: {1, 1, 0, false},
-		4: {1, 2, -1, false},
-	}
-	for i, tc := range tcs {
-		v1 := CheckedInt32(tc.val1)
-		v2 := CheckedInt32(tc.val2)
-		sum, err := v1.CheckedSub(v2)
-		if tc.wantErr {
-			assert.Error(t, err, "Should fail: %v", i)
-			assert.Zero(t, sum, "Got invalid sum for case %v", i)
-		} else {
-			assert.EqualValues(t, tc.sum, sum, "failed: %v", i)
-		}
-	}
-}

types/evidence.go

@@ -3,8 +3,10 @@ package types
 import (
 	"bytes"
 	"fmt"
+	"time"
 
 	"github.com/tendermint/tendermint/crypto/tmhash"
+	tmtime "github.com/tendermint/tendermint/types/time"
 
 	amino "github.com/tendermint/go-amino"
 
@@ -14,7 +16,7 @@ import (
 
 const (
 	// MaxEvidenceBytes is a maximum size of any evidence (including amino overhead).
-	MaxEvidenceBytes int64 = 444
+	MaxEvidenceBytes int64 = 440
 )
 
 // ErrEvidenceInvalid wraps a piece of evidence and the error denoting how or why it is invalid.
@@ -54,6 +56,7 @@ func (err *ErrEvidenceOverflow) Error() string {
 // Evidence represents any provable malicious activity by a validator
 type Evidence interface {
 	Height() int64                                     // height of the equivocation
+	Time() time.Time                                   // when the evidence was created
 	Address() []byte                                   // address of the equivocating validator
 	Bytes() []byte                                     // bytes which compromise the evidence
 	Hash() []byte                                      // hash of the evidence
@@ -102,6 +105,11 @@ func (dve *DuplicateVoteEvidence) Height() int64 {
 	return dve.VoteA.Height
 }
 
+// Time returns the time when the evidence was created.
+func (dve *DuplicateVoteEvidence) Time() time.Time {
+	return dve.VoteA.Timestamp
+}
+
 // Address returns the address of the validator.
 func (dve *DuplicateVoteEvidence) Address() []byte {
 	return dve.PubKey.Address()
@@ -188,6 +196,7 @@ func NewMockGoodEvidence(height int64, idx int, address []byte) MockGoodEvidence
 }
 
 func (e MockGoodEvidence) Height() int64   { return e.Height_ }
+func (e MockGoodEvidence) Time() time.Time { return tmtime.Now() }
 func (e MockGoodEvidence) Address() []byte { return e.Address_ }
 func (e MockGoodEvidence) Hash() []byte {
 	return []byte(fmt.Sprintf("%d-%x", e.Height_, e.Address_))

types/evidence_test.go

@@ -61,7 +61,7 @@ func TestEvidence(t *testing.T) {
 		{vote1, makeVote(val, chainID, 0, 10, 3, 1, blockID2), false},    // wrong round
 		{vote1, makeVote(val, chainID, 0, 10, 2, 2, blockID2), false},    // wrong step
 		{vote1, makeVote(val2, chainID, 0, 10, 2, 1, blockID), false},    // wrong validator
-		{vote1, badVote, false},                                          // signed by wrong key
+		{vote1, badVote, false}, // signed by wrong key
 	}
 
 	pubKey := val.GetPubKey()
@@ -105,7 +105,7 @@ func TestMaxEvidenceBytes(t *testing.T) {
 		VoteB:  makeVote(val, chainID, math.MaxInt64, math.MaxInt64, math.MaxInt64, math.MaxInt64, blockID2),
 	}
 
-	bz, err := cdc.MarshalBinaryLengthPrefixed(ev)
+	bz, err := cdc.MarshalBinary(ev)
 	require.NoError(t, err)
 
 	assert.EqualValues(t, MaxEvidenceBytes, len(bz))

types/heartbeat.go

@@ -23,7 +23,7 @@ type Heartbeat struct {
 // SignBytes returns the Heartbeat bytes for signing.
 // It panics if the Heartbeat is nil.
 func (heartbeat *Heartbeat) SignBytes(chainID string) []byte {
-	bz, err := cdc.MarshalBinaryLengthPrefixed(CanonicalizeHeartbeat(chainID, heartbeat))
+	bz, err := cdc.MarshalBinary(CanonicalizeHeartbeat(chainID, heartbeat))
 	if err != nil {
 		panic(err)
 	}

types/heartbeat_test.go

@@ -39,7 +39,7 @@ func TestHeartbeatWriteSignBytes(t *testing.T) {
 	{
 		testHeartbeat := &Heartbeat{ValidatorIndex: 1, Height: 10, Round: 1}
 		signBytes := testHeartbeat.SignBytes(chainID)
-		expected, err := cdc.MarshalBinaryLengthPrefixed(CanonicalizeHeartbeat(chainID, testHeartbeat))
+		expected, err := cdc.MarshalBinary(CanonicalizeHeartbeat(chainID, testHeartbeat))
 		require.NoError(t, err)
 		require.Equal(t, expected, signBytes, "Got unexpected sign bytes for Heartbeat")
 	}
@@ -47,7 +47,7 @@ func TestHeartbeatWriteSignBytes(t *testing.T) {
 	{
 		testHeartbeat := &Heartbeat{}
 		signBytes := testHeartbeat.SignBytes(chainID)
-		expected, err := cdc.MarshalBinaryLengthPrefixed(CanonicalizeHeartbeat(chainID, testHeartbeat))
+		expected, err := cdc.MarshalBinary(CanonicalizeHeartbeat(chainID, testHeartbeat))
 		require.NoError(t, err)
 		require.Equal(t, expected, signBytes, "Got unexpected sign bytes for Heartbeat")
 	}

types/params.go

@@ -1,9 +1,12 @@
 package types
 
 import (
+	"time"
+
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	cmn "github.com/tendermint/tendermint/libs/common"
+	tmtime "github.com/tendermint/tendermint/types/time"
 )
 
 const (
@@ -29,7 +32,7 @@ type BlockSize struct {
 
 // EvidenceParams determine how we handle evidence of malfeasance
 type EvidenceParams struct {
-	MaxAge int64 `json:"max_age"` // only accept new evidence more recent than this
+	MaxAge tmtime.DurationPretty `json:"max_age"` // only accept new evidence more recent than this
 }
 
 // DefaultConsensusParams returns a default ConsensusParams.
@@ -51,7 +54,7 @@ func DefaultBlockSize() BlockSize {
 // DefaultEvidenceParams Params returns a default EvidenceParams.
 func DefaultEvidenceParams() EvidenceParams {
 	return EvidenceParams{
-		MaxAge: 100000, // 27.8 hrs at 1block/s
+		MaxAge: tmtime.DurationPretty{48 * time.Hour},
 	}
 }
 
@@ -72,9 +75,9 @@ func (params *ConsensusParams) Validate() error {
 			params.BlockSize.MaxGas)
 	}
 
-	if params.EvidenceParams.MaxAge <= 0 {
+	if params.EvidenceParams.MaxAge.Duration <= 0 {
 		return cmn.NewError("EvidenceParams.MaxAge must be greater than 0. Got %d",
-			params.EvidenceParams.MaxAge)
+			params.EvidenceParams.MaxAge.Duration)
 	}
 
 	return nil
@@ -109,7 +112,7 @@ func (params ConsensusParams) Update(params2 *abci.ConsensusParams) ConsensusPar
 		res.BlockSize.MaxGas = params2.BlockSize.MaxGas
 	}
 	if params2.EvidenceParams != nil {
-		res.EvidenceParams.MaxAge = params2.EvidenceParams.MaxAge
+		res.EvidenceParams.MaxAge = tmtime.DurationPretty{params2.EvidenceParams.MaxAge}
 	}
 	return res
 }

types/params_test.go

@@ -4,9 +4,11 @@ import (
 	"bytes"
 	"sort"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	abci "github.com/tendermint/tendermint/abci/types"
+	tmtime "github.com/tendermint/tendermint/types/time"
 )
 
 func TestConsensusParamsValidation(t *testing.T) {
@@ -15,17 +17,17 @@ func TestConsensusParamsValidation(t *testing.T) {
 		valid  bool
 	}{
 		// test block size
-		0: {makeParams(1, 0, 1), true},
-		1: {makeParams(0, 0, 1), false},
-		2: {makeParams(47*1024*1024, 0, 1), true},
-		3: {makeParams(10, 0, 1), true},
-		4: {makeParams(100*1024*1024, 0, 1), true},
-		5: {makeParams(101*1024*1024, 0, 1), false},
-		6: {makeParams(1024*1024*1024, 0, 1), false},
-		7: {makeParams(1024*1024*1024, 0, -1), false},
+		0: {makeParams(1, 0, 10*time.Second), true},
+		1: {makeParams(0, 0, 10*time.Second), false},
+		2: {makeParams(47*1024*1024, 0, 10*time.Second), true},
+		3: {makeParams(10, 0, 10*time.Second), true},
+		4: {makeParams(100*1024*1024, 0, 10*time.Second), true},
+		5: {makeParams(101*1024*1024, 0, 10*time.Second), false},
+		6: {makeParams(1024*1024*1024, 0, 10*time.Second), false},
+		7: {makeParams(1024*1024*1024, 0, -10*time.Second), false},
 		// test evidence age
 		8: {makeParams(1, 0, 0), false},
-		9: {makeParams(1, 0, -1), false},
+		9: {makeParams(1, 0, -1*time.Millisecond), false},
 	}
 	for i, tc := range testCases {
 		if tc.valid {
@@ -36,28 +38,23 @@ func TestConsensusParamsValidation(t *testing.T) {
 	}
 }
 
-func makeParams(blockBytes, blockGas, evidenceAge int64) ConsensusParams {
+func makeParams(blockBytes, blockGas int64, evidenceAge time.Duration) ConsensusParams {
 	return ConsensusParams{
 		BlockSize: BlockSize{
 			MaxBytes: blockBytes,
 			MaxGas:   blockGas,
 		},
 		EvidenceParams: EvidenceParams{
-			MaxAge: evidenceAge,
+			MaxAge: tmtime.DurationPretty{evidenceAge},
 		},
 	}
 }
 
 func TestConsensusParamsHash(t *testing.T) {
 	params := []ConsensusParams{
-		makeParams(4, 2, 3),
-		makeParams(1, 4, 3),
-		makeParams(1, 2, 4),
-		makeParams(2, 5, 7),
-		makeParams(1, 7, 6),
-		makeParams(9, 5, 4),
-		makeParams(7, 8, 9),
-		makeParams(4, 6, 5),
+		makeParams(4, 2, 3*time.Second),
+		makeParams(1, 4, 3*time.Second),
+		makeParams(1, 2, 4*time.Second),
 	}
 
 	hashes := make([][]byte, len(params))
@@ -83,23 +80,23 @@ func TestConsensusParamsUpdate(t *testing.T) {
 	}{
 		// empty updates
 		{
-			makeParams(1, 2, 3),
+			makeParams(1, 2, 3*time.Second),
 			&abci.ConsensusParams{},
-			makeParams(1, 2, 3),
+			makeParams(1, 2, 3*time.Second),
 		},
 		// fine updates
 		{
-			makeParams(1, 2, 3),
+			makeParams(1, 2, 3*time.Second),
 			&abci.ConsensusParams{
 				BlockSize: &abci.BlockSize{
 					MaxBytes: 100,
 					MaxGas:   200,
 				},
 				EvidenceParams: &abci.EvidenceParams{
-					MaxAge: 300,
+					MaxAge: 300 * time.Second,
 				},
 			},
-			makeParams(100, 200, 300),
+			makeParams(100, 200, 300*time.Second),
 		},
 	}
 	for _, tc := range testCases {

types/proposal.go

@@ -52,7 +52,7 @@ func (p *Proposal) String() string {
 
 // SignBytes returns the Proposal bytes for signing
 func (p *Proposal) SignBytes(chainID string) []byte {
-	bz, err := cdc.MarshalBinaryLengthPrefixed(CanonicalizeProposal(chainID, p))
+	bz, err := cdc.MarshalBinary(CanonicalizeProposal(chainID, p))
 	if err != nil {
 		panic(err)
 	}

types/proposal_test.go

@@ -27,7 +27,7 @@ func TestProposalSignable(t *testing.T) {
 	chainID := "test_chain_id"
 	signBytes := testProposal.SignBytes(chainID)
 
-	expected, err := cdc.MarshalBinaryLengthPrefixed(CanonicalizeProposal(chainID, testProposal))
+	expected, err := cdc.MarshalBinary(CanonicalizeProposal(chainID, testProposal))
 	require.NoError(t, err)
 	require.Equal(t, expected, signBytes, "Got unexpected sign bytes for Proposal")
 }
@@ -57,9 +57,9 @@ func TestProposalVerifySignature(t *testing.T) {
 
 	// serialize, deserialize and verify again....
 	newProp := new(Proposal)
-	bs, err := cdc.MarshalBinaryLengthPrefixed(prop)
+	bs, err := cdc.MarshalBinary(prop)
 	require.NoError(t, err)
-	err = cdc.UnmarshalBinaryLengthPrefixed(bs, &newProp)
+	err = cdc.UnmarshalBinary(bs, &newProp)
 	require.NoError(t, err)
 
 	// verify the transmitted proposal

types/proto3/block.pb.go

@@ -1,19 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// source: block.proto
+// source: types/proto3/block.proto
 
-/*
-Package proto3 is a generated protocol buffer package.
-
-It is generated from these files:
-	block.proto
-
-It has these top-level messages:
-	PartSetHeader
-	BlockID
-	Header
-	Version
-	Timestamp
-*/
+//nolint
 package proto3
 
 import proto "github.com/golang/protobuf/proto"
@@ -32,14 +20,36 @@ var _ = math.Inf
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 type PartSetHeader struct {
-	Total int32  `protobuf:"zigzag32,1,opt,name=Total" json:"Total,omitempty"`
-	Hash  []byte `protobuf:"bytes,2,opt,name=Hash,proto3" json:"Hash,omitempty"`
+	Total                int32    `protobuf:"zigzag32,1,opt,name=Total,proto3" json:"Total,omitempty"`
+	Hash                 []byte   `protobuf:"bytes,2,opt,name=Hash,proto3" json:"Hash,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *PartSetHeader) Reset()                    { *m = PartSetHeader{} }
-func (m *PartSetHeader) String() string            { return proto.CompactTextString(m) }
-func (*PartSetHeader) ProtoMessage()               {}
-func (*PartSetHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (m *PartSetHeader) Reset()         { *m = PartSetHeader{} }
+func (m *PartSetHeader) String() string { return proto.CompactTextString(m) }
+func (*PartSetHeader) ProtoMessage()    {}
+func (*PartSetHeader) Descriptor() ([]byte, []int) {
+	return fileDescriptor_block_c8c1dcbe91697ccd, []int{0}
+}
+func (m *PartSetHeader) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PartSetHeader.Unmarshal(m, b)
+}
+func (m *PartSetHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PartSetHeader.Marshal(b, m, deterministic)
+}
+func (dst *PartSetHeader) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PartSetHeader.Merge(dst, src)
+}
+func (m *PartSetHeader) XXX_Size() int {
+	return xxx_messageInfo_PartSetHeader.Size(m)
+}
+func (m *PartSetHeader) XXX_DiscardUnknown() {
+	xxx_messageInfo_PartSetHeader.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PartSetHeader proto.InternalMessageInfo
 
 func (m *PartSetHeader) GetTotal() int32 {
 	if m != nil {
@@ -56,14 +66,36 @@ func (m *PartSetHeader) GetHash() []byte {
 }
 
 type BlockID struct {
-	Hash        []byte         `protobuf:"bytes,1,opt,name=Hash,proto3" json:"Hash,omitempty"`
-	PartsHeader *PartSetHeader `protobuf:"bytes,2,opt,name=PartsHeader" json:"PartsHeader,omitempty"`
+	Hash                 []byte         `protobuf:"bytes,1,opt,name=Hash,proto3" json:"Hash,omitempty"`
+	PartsHeader          *PartSetHeader `protobuf:"bytes,2,opt,name=PartsHeader,proto3" json:"PartsHeader,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
+	XXX_unrecognized     []byte         `json:"-"`
+	XXX_sizecache        int32          `json:"-"`
 }
 
-func (m *BlockID) Reset()                    { *m = BlockID{} }
-func (m *BlockID) String() string            { return proto.CompactTextString(m) }
-func (*BlockID) ProtoMessage()               {}
-func (*BlockID) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+func (m *BlockID) Reset()         { *m = BlockID{} }
+func (m *BlockID) String() string { return proto.CompactTextString(m) }
+func (*BlockID) ProtoMessage()    {}
+func (*BlockID) Descriptor() ([]byte, []int) {
+	return fileDescriptor_block_c8c1dcbe91697ccd, []int{1}
+}
+func (m *BlockID) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BlockID.Unmarshal(m, b)
+}
+func (m *BlockID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BlockID.Marshal(b, m, deterministic)
+}
+func (dst *BlockID) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlockID.Merge(dst, src)
+}
+func (m *BlockID) XXX_Size() int {
+	return xxx_messageInfo_BlockID.Size(m)
+}
+func (m *BlockID) XXX_DiscardUnknown() {
+	xxx_messageInfo_BlockID.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BlockID proto.InternalMessageInfo
 
 func (m *BlockID) GetHash() []byte {
 	if m != nil {
@@ -81,39 +113,52 @@ func (m *BlockID) GetPartsHeader() *PartSetHeader {
 
 type Header struct {
 	// basic block info
-	Version  *Version   `protobuf:"bytes,1,opt,name=Version" json:"Version,omitempty"`
-	ChainID  string     `protobuf:"bytes,2,opt,name=ChainID" json:"ChainID,omitempty"`
-	Height   int64      `protobuf:"zigzag64,3,opt,name=Height" json:"Height,omitempty"`
-	Time     *Timestamp `protobuf:"bytes,4,opt,name=Time" json:"Time,omitempty"`
-	NumTxs   int64      `protobuf:"zigzag64,5,opt,name=NumTxs" json:"NumTxs,omitempty"`
-	TotalTxs int64      `protobuf:"zigzag64,6,opt,name=TotalTxs" json:"TotalTxs,omitempty"`
+	ChainID  string     `protobuf:"bytes,1,opt,name=ChainID,proto3" json:"ChainID,omitempty"`
+	Height   int64      `protobuf:"zigzag64,2,opt,name=Height,proto3" json:"Height,omitempty"`
+	Time     *Timestamp `protobuf:"bytes,3,opt,name=Time,proto3" json:"Time,omitempty"`
+	NumTxs   int64      `protobuf:"zigzag64,4,opt,name=NumTxs,proto3" json:"NumTxs,omitempty"`
+	TotalTxs int64      `protobuf:"zigzag64,5,opt,name=TotalTxs,proto3" json:"TotalTxs,omitempty"`
 	// prev block info
-	LastBlockID *BlockID `protobuf:"bytes,7,opt,name=LastBlockID" json:"LastBlockID,omitempty"`
+	LastBlockID *BlockID `protobuf:"bytes,6,opt,name=LastBlockID,proto3" json:"LastBlockID,omitempty"`
 	// hashes of block data
-	LastCommitHash []byte `protobuf:"bytes,8,opt,name=LastCommitHash,proto3" json:"LastCommitHash,omitempty"`
-	DataHash       []byte `protobuf:"bytes,9,opt,name=DataHash,proto3" json:"DataHash,omitempty"`
+	LastCommitHash []byte `protobuf:"bytes,7,opt,name=LastCommitHash,proto3" json:"LastCommitHash,omitempty"`
+	DataHash       []byte `protobuf:"bytes,8,opt,name=DataHash,proto3" json:"DataHash,omitempty"`
 	// hashes from the app output from the prev block
-	ValidatorsHash     []byte `protobuf:"bytes,10,opt,name=ValidatorsHash,proto3" json:"ValidatorsHash,omitempty"`
-	NextValidatorsHash []byte `protobuf:"bytes,11,opt,name=NextValidatorsHash,proto3" json:"NextValidatorsHash,omitempty"`
-	ConsensusHash      []byte `protobuf:"bytes,12,opt,name=ConsensusHash,proto3" json:"ConsensusHash,omitempty"`
-	AppHash            []byte `protobuf:"bytes,13,opt,name=AppHash,proto3" json:"AppHash,omitempty"`
-	LastResultsHash    []byte `protobuf:"bytes,14,opt,name=LastResultsHash,proto3" json:"LastResultsHash,omitempty"`
+	ValidatorsHash  []byte `protobuf:"bytes,9,opt,name=ValidatorsHash,proto3" json:"ValidatorsHash,omitempty"`
+	ConsensusHash   []byte `protobuf:"bytes,10,opt,name=ConsensusHash,proto3" json:"ConsensusHash,omitempty"`
+	AppHash         []byte `protobuf:"bytes,11,opt,name=AppHash,proto3" json:"AppHash,omitempty"`
+	LastResultsHash []byte `protobuf:"bytes,12,opt,name=LastResultsHash,proto3" json:"LastResultsHash,omitempty"`
 	// consensus info
-	EvidenceHash    []byte `protobuf:"bytes,15,opt,name=EvidenceHash,proto3" json:"EvidenceHash,omitempty"`
-	ProposerAddress []byte `protobuf:"bytes,16,opt,name=ProposerAddress,proto3" json:"ProposerAddress,omitempty"`
+	EvidenceHash         []byte   `protobuf:"bytes,13,opt,name=EvidenceHash,proto3" json:"EvidenceHash,omitempty"`
+	ProposerAddress      []byte   `protobuf:"bytes,14,opt,name=ProposerAddress,proto3" json:"ProposerAddress,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *Header) Reset()                    { *m = Header{} }
-func (m *Header) String() string            { return proto.CompactTextString(m) }
-func (*Header) ProtoMessage()               {}
-func (*Header) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
-
-func (m *Header) GetVersion() *Version {
-	if m != nil {
-		return m.Version
-	}
-	return nil
+func (m *Header) Reset()         { *m = Header{} }
+func (m *Header) String() string { return proto.CompactTextString(m) }
+func (*Header) ProtoMessage()    {}
+func (*Header) Descriptor() ([]byte, []int) {
+	return fileDescriptor_block_c8c1dcbe91697ccd, []int{2}
 }
+func (m *Header) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Header.Unmarshal(m, b)
+}
+func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Header.Marshal(b, m, deterministic)
+}
+func (dst *Header) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Header.Merge(dst, src)
+}
+func (m *Header) XXX_Size() int {
+	return xxx_messageInfo_Header.Size(m)
+}
+func (m *Header) XXX_DiscardUnknown() {
+	xxx_messageInfo_Header.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Header proto.InternalMessageInfo
 
 func (m *Header) GetChainID() string {
 	if m != nil {
@@ -178,13 +223,6 @@ func (m *Header) GetValidatorsHash() []byte {
 	return nil
 }
 
-func (m *Header) GetNextValidatorsHash() []byte {
-	if m != nil {
-		return m.NextValidatorsHash
-	}
-	return nil
-}
-
 func (m *Header) GetConsensusHash() []byte {
 	if m != nil {
 		return m.ConsensusHash
@@ -220,44 +258,41 @@ func (m *Header) GetProposerAddress() []byte {
 	return nil
 }
 
-type Version struct {
-	Block uint64 `protobuf:"varint,1,opt,name=Block" json:"Block,omitempty"`
-	App   uint64 `protobuf:"varint,2,opt,name=App" json:"App,omitempty"`
-}
-
-func (m *Version) Reset()                    { *m = Version{} }
-func (m *Version) String() string            { return proto.CompactTextString(m) }
-func (*Version) ProtoMessage()               {}
-func (*Version) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
-
-func (m *Version) GetBlock() uint64 {
-	if m != nil {
-		return m.Block
-	}
-	return 0
-}
-
-func (m *Version) GetApp() uint64 {
-	if m != nil {
-		return m.App
-	}
-	return 0
-}
-
-// Timestamp wraps how amino encodes time.
-// This is the protobuf well-known type protobuf/timestamp.proto
-// See:
+// Timestamp wraps how amino encodes time. Note that this is different from the protobuf well-known type
+// protobuf/timestamp.proto in the sense that there seconds and nanos are varint encoded. See:
 // https://github.com/google/protobuf/blob/d2980062c859649523d5fd51d6b55ab310e47482/src/google/protobuf/timestamp.proto#L123-L135
-// NOTE/XXX: nanos do not get skipped if they are zero in amino.
+// Also nanos do not get skipped if they are zero in amino.
 type Timestamp struct {
-	Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
-	Nanos   int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
+	Seconds              int64    `protobuf:"fixed64,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
+	Nanos                int32    `protobuf:"fixed32,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *Timestamp) Reset()                    { *m = Timestamp{} }
-func (m *Timestamp) String() string            { return proto.CompactTextString(m) }
-func (*Timestamp) ProtoMessage()               {}
-func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+func (m *Timestamp) Reset()         { *m = Timestamp{} }
+func (m *Timestamp) String() string { return proto.CompactTextString(m) }
+func (*Timestamp) ProtoMessage()    {}
+func (*Timestamp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_block_c8c1dcbe91697ccd, []int{3}
+}
+func (m *Timestamp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Timestamp.Unmarshal(m, b)
+}
+func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Timestamp.Marshal(b, m, deterministic)
+}
+func (dst *Timestamp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Timestamp.Merge(dst, src)
+}
+func (m *Timestamp) XXX_Size() int {
+	return xxx_messageInfo_Timestamp.Size(m)
+}
+func (m *Timestamp) XXX_DiscardUnknown() {
+	xxx_messageInfo_Timestamp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Timestamp proto.InternalMessageInfo
 
 func (m *Timestamp) GetSeconds() int64 {
 	if m != nil {
@@ -277,40 +312,36 @@ func init() {
 	proto.RegisterType((*PartSetHeader)(nil), "proto3.PartSetHeader")
 	proto.RegisterType((*BlockID)(nil), "proto3.BlockID")
 	proto.RegisterType((*Header)(nil), "proto3.Header")
-	proto.RegisterType((*Version)(nil), "proto3.Version")
 	proto.RegisterType((*Timestamp)(nil), "proto3.Timestamp")
 }
 
-func init() { proto.RegisterFile("block.proto", fileDescriptor0) }
+func init() { proto.RegisterFile("types/proto3/block.proto", fileDescriptor_block_c8c1dcbe91697ccd) }
 
-var fileDescriptor0 = []byte{
-	// 443 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x53, 0xcd, 0x6a, 0xdb, 0x40,
-	0x10, 0x46, 0xb5, 0x6c, 0xc7, 0x23, 0x3b, 0x4e, 0x86, 0xb6, 0x88, 0x9e, 0x8c, 0x68, 0x8b, 0x7b,
-	0x31, 0x24, 0x39, 0x94, 0xd2, 0x93, 0x6b, 0x17, 0x12, 0x28, 0x21, 0x6c, 0x8d, 0xef, 0x1b, 0x6b,
-	0xa9, 0x45, 0x2d, 0xad, 0xd0, 0xac, 0x4b, 0xde, 0xb0, 0xaf, 0x55, 0x66, 0x56, 0x52, 0x23, 0x93,
-	0x93, 0xf7, 0xfb, 0x99, 0x6f, 0x76, 0xc7, 0x23, 0x88, 0x1e, 0x0f, 0x76, 0xf7, 0x7b, 0x51, 0x56,
-	0xd6, 0x59, 0x1c, 0xc8, 0xcf, 0x4d, 0xf2, 0x05, 0x26, 0x0f, 0xba, 0x72, 0x3f, 0x8d, 0xbb, 0x35,
-	0x3a, 0x35, 0x15, 0xbe, 0x86, 0xfe, 0xc6, 0x3a, 0x7d, 0x88, 0x83, 0x59, 0x30, 0xbf, 0x54, 0x1e,
-	0x20, 0x42, 0x78, 0xab, 0x69, 0x1f, 0xbf, 0x9a, 0x05, 0xf3, 0xb1, 0x92, 0x73, 0xb2, 0x85, 0xe1,
-	0x37, 0x4e, 0xbc, 0x5b, 0xb7, 0x72, 0xf0, 0x5f, 0xc6, 0xcf, 0x10, 0x71, 0x32, 0xf9, 0x5c, 0xa9,
-	0x8c, 0xae, 0xdf, 0xf8, 0xf6, 0x37, 0x8b, 0x4e, 0x53, 0xf5, 0xdc, 0x99, 0xfc, 0x0d, 0x61, 0x50,
-	0x5f, 0xe6, 0x13, 0x0c, 0xb7, 0xa6, 0xa2, 0xcc, 0x16, 0x12, 0x1d, 0x5d, 0x4f, 0x9b, 0xfa, 0x9a,
-	0x56, 0x8d, 0x8e, 0x31, 0x0c, 0x57, 0x7b, 0x9d, 0x15, 0x77, 0x6b, 0x69, 0x35, 0x52, 0x0d, 0xc4,
-	0xb7, 0x1c, 0x97, 0xfd, 0xda, 0xbb, 0xb8, 0x37, 0x0b, 0xe6, 0xa8, 0x6a, 0x84, 0x1f, 0x20, 0xdc,
-	0x64, 0xb9, 0x89, 0x43, 0x49, 0xbe, 0x6c, 0x92, 0x99, 0x23, 0xa7, 0xf3, 0x52, 0x89, 0xcc, 0xe5,
-	0xf7, 0xc7, 0x7c, 0xf3, 0x44, 0x71, 0xdf, 0x97, 0x7b, 0x84, 0xef, 0xe0, 0x4c, 0x66, 0xc3, 0xca,
-	0x40, 0x94, 0x16, 0xe3, 0x15, 0x44, 0x3f, 0x34, 0xb9, 0x7a, 0x3c, 0xf1, 0xb0, 0x7b, 0xf7, 0x9a,
-	0x56, 0xcf, 0x3d, 0xf8, 0x11, 0xce, 0x19, 0xae, 0x6c, 0x9e, 0x67, 0x4e, 0x86, 0x79, 0x26, 0xc3,
-	0x3c, 0x61, 0xb9, 0xed, 0x5a, 0x3b, 0x2d, 0x8e, 0x91, 0x38, 0x5a, 0xcc, 0x19, 0x5b, 0x7d, 0xc8,
-	0x52, 0xed, 0x6c, 0x45, 0xe2, 0x00, 0x9f, 0xd1, 0x65, 0x71, 0x01, 0x78, 0x6f, 0x9e, 0xdc, 0x89,
-	0x37, 0x12, 0xef, 0x0b, 0x0a, 0xbe, 0x87, 0xc9, 0xca, 0x16, 0x64, 0x0a, 0x3a, 0x7a, 0xeb, 0x58,
-	0xac, 0x5d, 0x92, 0xff, 0x81, 0x65, 0x59, 0x8a, 0x3e, 0x11, 0xbd, 0x81, 0x38, 0x87, 0x29, 0xbf,
-	0x42, 0x19, 0x3a, 0x1e, 0x9c, 0x4f, 0x38, 0x17, 0xc7, 0x29, 0x8d, 0x09, 0x8c, 0xbf, 0xff, 0xc9,
-	0x52, 0x53, 0xec, 0x8c, 0xd8, 0xa6, 0x62, 0xeb, 0x70, 0x9c, 0xf6, 0x50, 0xd9, 0xd2, 0x92, 0xa9,
-	0x96, 0x69, 0x5a, 0x19, 0xa2, 0xf8, 0xc2, 0xa7, 0x9d, 0xd0, 0xc9, 0x55, 0xbb, 0x3e, 0xbc, 0xd6,
-	0x32, 0x69, 0xd9, 0xa3, 0x50, 0x79, 0x80, 0x17, 0xd0, 0x5b, 0x96, 0xa5, 0x2c, 0x4c, 0xa8, 0xf8,
-	0x98, 0x7c, 0x85, 0x51, 0xbb, 0x00, 0xfc, 0x22, 0x32, 0x3b, 0x5b, 0xa4, 0x24, 0x65, 0x3d, 0xd5,
-	0x40, 0x8e, 0x2b, 0x74, 0x61, 0x49, 0x4a, 0xfb, 0xca, 0x83, 0xc7, 0xfa, 0xa3, 0xfa, 0x17, 0x00,
-	0x00, 0xff, 0xff, 0x8f, 0x82, 0xc0, 0x0c, 0x6a, 0x03, 0x00, 0x00,
+var fileDescriptor_block_c8c1dcbe91697ccd = []byte{
+	// 395 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x52, 0x4b, 0x8b, 0xdb, 0x30,
+	0x10, 0xc6, 0xcd, 0x7b, 0x9c, 0x47, 0x23, 0xda, 0x22, 0x7a, 0x0a, 0xa6, 0x2d, 0x39, 0x25, 0xb4,
+	0x39, 0x94, 0xd2, 0x53, 0x9a, 0x14, 0x12, 0x28, 0x25, 0x68, 0x43, 0xee, 0x4a, 0x2c, 0x36, 0x66,
+	0x6d, 0xcb, 0x78, 0x94, 0x65, 0xf7, 0x3f, 0xef, 0x8f, 0x58, 0x34, 0xb2, 0xbd, 0x71, 0x6e, 0xfe,
+	0x1e, 0xfa, 0x3e, 0x79, 0x46, 0xc0, 0xcd, 0x73, 0xa6, 0x70, 0x9e, 0xe5, 0xda, 0xe8, 0xc5, 0xfc,
+	0x18, 0xeb, 0xd3, 0xc3, 0x8c, 0x00, 0x6b, 0x3b, 0x2e, 0xf8, 0x05, 0x83, 0x9d, 0xcc, 0xcd, 0x9d,
+	0x32, 0x1b, 0x25, 0x43, 0x95, 0xb3, 0x0f, 0xd0, 0xda, 0x6b, 0x23, 0x63, 0xee, 0x4d, 0xbc, 0xe9,
+	0x58, 0x38, 0xc0, 0x18, 0x34, 0x37, 0x12, 0xcf, 0xfc, 0xdd, 0xc4, 0x9b, 0xf6, 0x05, 0x7d, 0x07,
+	0x07, 0xe8, 0xfc, 0xb1, 0x89, 0xdb, 0x75, 0x25, 0x7b, 0x6f, 0x32, 0xfb, 0x09, 0xbe, 0x4d, 0x46,
+	0x97, 0x4b, 0x27, 0xfd, 0x1f, 0x1f, 0x5d, 0xfd, 0x62, 0x56, 0x2b, 0x15, 0xd7, 0xce, 0xe0, 0xa5,
+	0x01, 0xed, 0xe2, 0x32, 0x1c, 0x3a, 0xab, 0xb3, 0x8c, 0xd2, 0xed, 0x9a, 0xa2, 0x7b, 0xa2, 0x84,
+	0xec, 0x93, 0xf5, 0x44, 0xf7, 0x67, 0x43, 0xc1, 0x4c, 0x14, 0x88, 0x7d, 0x85, 0xe6, 0x3e, 0x4a,
+	0x14, 0x6f, 0x50, 0xdd, 0xb8, 0xac, 0xb3, 0x1c, 0x1a, 0x99, 0x64, 0x82, 0x64, 0x7b, 0xfc, 0xff,
+	0x25, 0xd9, 0x3f, 0x21, 0x6f, 0xba, 0xe3, 0x0e, 0xb1, 0xcf, 0xd0, 0xa5, 0x1f, 0xb6, 0x4a, 0x8b,
+	0x94, 0x0a, 0xb3, 0xef, 0xe0, 0xff, 0x93, 0x68, 0x8a, 0x7f, 0xe6, 0x6d, 0x6a, 0x18, 0x95, 0x0d,
+	0x05, 0x2d, 0xae, 0x3d, 0xec, 0x1b, 0x0c, 0x2d, 0x5c, 0xe9, 0x24, 0x89, 0x0c, 0x4d, 0xa8, 0x43,
+	0x13, 0xba, 0x61, 0x6d, 0xed, 0x5a, 0x1a, 0x49, 0x8e, 0x2e, 0x39, 0x2a, 0x6c, 0x33, 0x0e, 0x32,
+	0x8e, 0x42, 0x69, 0x74, 0x8e, 0xe4, 0xe8, 0xb9, 0x8c, 0x3a, 0xcb, 0xbe, 0xc0, 0x60, 0xa5, 0x53,
+	0x54, 0x29, 0x5e, 0x9c, 0x0d, 0xc8, 0x56, 0x27, 0xed, 0x44, 0x97, 0x59, 0x46, 0xba, 0x4f, 0x7a,
+	0x09, 0xd9, 0x14, 0x46, 0xf6, 0x56, 0x42, 0xe1, 0x25, 0x36, 0x2e, 0xa1, 0x4f, 0x8e, 0x5b, 0x9a,
+	0x05, 0xd0, 0xff, 0xfb, 0x18, 0x85, 0x2a, 0x3d, 0x29, 0xb2, 0x0d, 0xc8, 0x56, 0xe3, 0x6c, 0xda,
+	0x2e, 0xd7, 0x99, 0x46, 0x95, 0x2f, 0xc3, 0x30, 0x57, 0x88, 0x7c, 0xe8, 0xd2, 0x6e, 0xe8, 0xe0,
+	0x37, 0xf4, 0xaa, 0xed, 0xd8, 0xeb, 0xa1, 0x3a, 0xe9, 0x34, 0x44, 0x5a, 0xf8, 0x7b, 0x51, 0x42,
+	0xfb, 0x2e, 0x53, 0x99, 0x6a, 0xa4, 0x7d, 0x8f, 0x84, 0x03, 0xc7, 0xe2, 0x19, 0xbf, 0x06, 0x00,
+	0x00, 0xff, 0xff, 0xde, 0x29, 0x34, 0x75, 0xe9, 0x02, 0x00, 0x00,
 }

types/proto3/block.proto

@@ -15,43 +15,36 @@ message BlockID {
 
 message Header {
   // basic block info
-  Version Version = 1;
-  string ChainID = 2;
-  sint64 Height = 3;
-  Timestamp Time = 4;
-  sint64 NumTxs = 5;
-  sint64 TotalTxs = 6;
+  string ChainID = 1;
+  sint64 Height = 2;
+  Timestamp Time = 3;
+  sint64 NumTxs = 4;
+  sint64 TotalTxs = 5;
 
   // prev block info
-  BlockID LastBlockID = 7;
+  BlockID LastBlockID = 6;
 
   // hashes of block data
-  bytes LastCommitHash = 8; // commit from validators from the last block
-  bytes DataHash = 9; // transactions
+  bytes LastCommitHash = 7; // commit from validators from the last block
+  bytes DataHash = 8; // transactions
 
   // hashes from the app output from the prev block
-  bytes ValidatorsHash = 10; // validators for the current block
-  bytes NextValidatorsHash = 11; // validators for the next block
-  bytes ConsensusHash = 12; // consensus params for current block
-  bytes AppHash = 13; // state after txs from the previous block
-  bytes LastResultsHash = 14; // root hash of all results from the txs from the previous block
+  bytes ValidatorsHash = 9; // validators for the current block
+  bytes NextValidatorsHash = 10; // validators for the next block
+  bytes ConsensusHash = 11; // consensus params for current block
+  bytes AppHash = 12; // state after txs from the previous block
+  bytes LastResultsHash = 13; // root hash of all results from the txs from the previous block
 
   // consensus info
-  bytes EvidenceHash = 15; // evidence included in the block
-  bytes ProposerAddress = 16; // original proposer of the block
+  bytes EvidenceHash = 14; // evidence included in the block
+  bytes ProposerAddress = 15; // original proposer of the block
 }
 
-message Version {
-  uint64 Block = 1;
-  uint64 App = 2;
-}
-
-// Timestamp wraps how amino encodes time.
-// This is the protobuf well-known type protobuf/timestamp.proto
-// See:
+// Timestamp wraps how amino encodes time. Note that this is different from the protobuf well-known type
+// protobuf/timestamp.proto in the sense that there seconds and nanos are varint encoded. See:
 // https://github.com/google/protobuf/blob/d2980062c859649523d5fd51d6b55ab310e47482/src/google/protobuf/timestamp.proto#L123-L135
-// NOTE/XXX: nanos do not get skipped if they are zero in amino.
+// Also nanos do not get skipped if they are zero in amino.
 message Timestamp {
-  int64 seconds = 1;
-  int32 nanos = 2;
+  sfixed64 seconds = 1;
+  sfixed32 nanos = 2;
 }

types/protobuf.go

@@ -9,6 +9,7 @@ import (
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	"github.com/tendermint/tendermint/crypto/secp256k1"
+	tmtime "github.com/tendermint/tendermint/types/time"
 )
 
 //-------------------------------------------------------
@@ -34,10 +35,6 @@ type tm2pb struct{}
 
 func (tm2pb) Header(header *Header) abci.Header {
 	return abci.Header{
-		Version: abci.Version{
-			Block: header.Version.Block.Uint64(),
-			App:   header.Version.App.Uint64(),
-		},
 		ChainID:  header.ChainID,
 		Height:   header.Height,
 		Time:     header.Time,
@@ -49,11 +46,10 @@ func (tm2pb) Header(header *Header) abci.Header {
 		LastCommitHash: header.LastCommitHash,
 		DataHash:       header.DataHash,
 
-		ValidatorsHash:     header.ValidatorsHash,
-		NextValidatorsHash: header.NextValidatorsHash,
-		ConsensusHash:      header.ConsensusHash,
-		AppHash:            header.AppHash,
-		LastResultsHash:    header.LastResultsHash,
+		ValidatorsHash:  header.ValidatorsHash,
+		ConsensusHash:   header.ConsensusHash,
+		AppHash:         header.AppHash,
+		LastResultsHash: header.LastResultsHash,
 
 		EvidenceHash:    header.EvidenceHash,
 		ProposerAddress: header.ProposerAddress,
@@ -124,7 +120,7 @@ func (tm2pb) ConsensusParams(params *ConsensusParams) *abci.ConsensusParams {
 			MaxGas:   params.BlockSize.MaxGas,
 		},
 		EvidenceParams: &abci.EvidenceParams{
-			MaxAge: params.EvidenceParams.MaxAge,
+			MaxAge: params.EvidenceParams.MaxAge.Duration,
 		},
 	}
 }
@@ -214,13 +210,18 @@ func (pb2tm) ValidatorUpdates(vals []abci.ValidatorUpdate) ([]*Validator, error)
 }
 
 func (pb2tm) ConsensusParams(csp *abci.ConsensusParams) ConsensusParams {
-	return ConsensusParams{
-		BlockSize: BlockSize{
+	params := ConsensusParams{}
+
+	// we must defensively consider any structs may be nil
+	if csp.BlockSize != nil {
+		params.BlockSize = BlockSize{
 			MaxBytes: csp.BlockSize.MaxBytes,
 			MaxGas:   csp.BlockSize.MaxGas,
-		},
-		EvidenceParams: EvidenceParams{
-			MaxAge: csp.EvidenceParams.MaxAge,
-		},
+		}
 	}
+	if csp.EvidenceParams != nil {
+		params.EvidenceParams.MaxAge = tmtime.DurationPretty{csp.EvidenceParams.MaxAge}
+	}
+
+	return params
 }

types/protobuf_test.go

@@ -4,16 +4,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/golang/protobuf/proto"
 	"github.com/stretchr/testify/assert"
-
-	"github.com/tendermint/go-amino"
-
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	"github.com/tendermint/tendermint/crypto/secp256k1"
-	"github.com/tendermint/tendermint/version"
+	tmtime "github.com/tendermint/tendermint/types/time"
 )
 
 func TestABCIPubKey(t *testing.T) {
@@ -34,9 +30,17 @@ func TestABCIValidators(t *testing.T) {
 	pkEd := ed25519.GenPrivKey().PubKey()
 
 	// correct validator
-	tmValExpected := NewValidator(pkEd, 10)
+	tmValExpected := &Validator{
+		Address:     pkEd.Address(),
+		PubKey:      pkEd,
+		VotingPower: 10,
+	}
 
-	tmVal := NewValidator(pkEd, 10)
+	tmVal := &Validator{
+		Address:     pkEd.Address(),
+		PubKey:      pkEd,
+		VotingPower: 10,
+	}
 
 	abciVal := TM2PB.ValidatorUpdate(tmVal)
 	tmVals, err := PB2TM.ValidatorUpdates([]abci.ValidatorUpdate{abciVal})
@@ -64,78 +68,24 @@ func TestABCIValidators(t *testing.T) {
 
 func TestABCIConsensusParams(t *testing.T) {
 	cp := DefaultConsensusParams()
-	cp.EvidenceParams.MaxAge = 0 // TODO add this to ABCI
+	cp.EvidenceParams.MaxAge.Duration = 0 // TODO add this to ABCI
 	abciCP := TM2PB.ConsensusParams(cp)
 	cp2 := PB2TM.ConsensusParams(abciCP)
 
 	assert.Equal(t, *cp, cp2)
 }
 
-func newHeader(
-	height, numTxs int64,
-	commitHash, dataHash, evidenceHash []byte,
-) *Header {
-	return &Header{
-		Height:         height,
-		NumTxs:         numTxs,
-		LastCommitHash: commitHash,
-		DataHash:       dataHash,
-		EvidenceHash:   evidenceHash,
-	}
-}
-
 func TestABCIHeader(t *testing.T) {
-	// build a full header
-	var height int64 = 5
-	var numTxs int64 = 3
-	header := newHeader(
-		height, numTxs,
-		[]byte("lastCommitHash"), []byte("dataHash"), []byte("evidenceHash"),
-	)
-	protocolVersion := version.Consensus{7, 8}
-	timestamp := time.Now()
-	lastBlockID := BlockID{
-		Hash: []byte("hash"),
-		PartsHeader: PartSetHeader{
-			Total: 10,
-			Hash:  []byte("hash"),
-		},
+	header := &Header{
+		Height:          int64(3),
+		Time:            tmtime.Now(),
+		NumTxs:          int64(10),
+		ProposerAddress: []byte("cloak"),
 	}
-	var totalTxs int64 = 100
-	header.Populate(
-		protocolVersion, "chainID",
-		timestamp, lastBlockID, totalTxs,
-		[]byte("valHash"), []byte("nextValHash"),
-		[]byte("consHash"), []byte("appHash"), []byte("lastResultsHash"),
-		[]byte("proposerAddress"),
-	)
-
-	cdc := amino.NewCodec()
-	headerBz := cdc.MustMarshalBinaryBare(header)
-
-	pbHeader := TM2PB.Header(header)
-	pbHeaderBz, err := proto.Marshal(&pbHeader)
-	assert.NoError(t, err)
-
-	// assert some fields match
-	assert.EqualValues(t, protocolVersion.Block, pbHeader.Version.Block)
-	assert.EqualValues(t, protocolVersion.App, pbHeader.Version.App)
-	assert.EqualValues(t, "chainID", pbHeader.ChainID)
-	assert.EqualValues(t, height, pbHeader.Height)
-	assert.EqualValues(t, timestamp, pbHeader.Time)
-	assert.EqualValues(t, numTxs, pbHeader.NumTxs)
-	assert.EqualValues(t, totalTxs, pbHeader.TotalTxs)
-	assert.EqualValues(t, lastBlockID.Hash, pbHeader.LastBlockId.Hash)
-	assert.EqualValues(t, []byte("lastCommitHash"), pbHeader.LastCommitHash)
-	assert.Equal(t, []byte("proposerAddress"), pbHeader.ProposerAddress)
-
-	// assert the encodings match
-	// NOTE: they don't yet because Amino encodes
-	// int64 as zig-zag and we're using non-zigzag in the protobuf.
-	// See https://github.com/tendermint/tendermint/issues/2682
-	_, _ = headerBz, pbHeaderBz
-	// assert.EqualValues(t, headerBz, pbHeaderBz)
+	abciHeader := TM2PB.Header(header)
 
+	assert.Equal(t, int64(3), abciHeader.Height)
+	assert.Equal(t, []byte("cloak"), abciHeader.ProposerAddress)
 }
 
 func TestABCIEvidence(t *testing.T) {
@@ -177,7 +127,11 @@ func TestABCIValidatorFromPubKeyAndPower(t *testing.T) {
 func TestABCIValidatorWithoutPubKey(t *testing.T) {
 	pkEd := ed25519.GenPrivKey().PubKey()
 
-	abciVal := TM2PB.Validator(NewValidator(pkEd, 10))
+	abciVal := TM2PB.Validator(&Validator{
+		Address:     pkEd.Address(),
+		PubKey:      pkEd,
+		VotingPower: 10,
+	})
 
 	// pubkey must be nil
 	tmValExpected := abci.Validator{

types/results.go

@@ -48,7 +48,7 @@ func NewResultFromResponse(response *abci.ResponseDeliverTx) ABCIResult {
 
 // Bytes serializes the ABCIResponse using wire
 func (a ABCIResults) Bytes() []byte {
-	bz, err := cdc.MarshalBinaryLengthPrefixed(a)
+	bz, err := cdc.MarshalBinary(a)
 	if err != nil {
 		panic(err)
 	}