write tests for the upgrade

.circleci/config.yml

@@ -3,17 +3,10 @@ version: 2
 defaults: &defaults
   working_directory: /go/src/github.com/tendermint/tendermint
   docker:
-    - image: circleci/golang:1.11.4
+    - image: circleci/golang:1.10.3
   environment:
     GOBIN: /tmp/workspace/bin
 
-docs_update_config: &docs_update_config
-  working_directory: ~/repo
-  docker:
-    - image: tendermint/docs_deployment
-  environment:
-    AWS_REGION: us-east-1
-
 jobs:
   setup_dependencies:
     <<: *defaults
@@ -346,25 +339,10 @@ jobs:
           name: upload
           command: bash .circleci/codecov.sh -f coverage.txt
 
-  deploy_docs:
-    <<: *docs_update_config
-    steps:
-      - checkout
-      - run:
-          name: Trigger website build
-          command: |
-            chamber exec tendermint -- start_website_build
-
 workflows:
   version: 2
   test-suite:
     jobs:
-      - deploy_docs:
-          filters:
-            branches:
-              only:
-                - master
-                - develop
       - setup_dependencies
       - lint:
           requires:

CHANGELOG.md

@@ -1,138 +1,13 @@
 # Changelog
 
-## v0.27.4
-
-*December 21st, 2018*
-
-### BUG FIXES:
-
-- [mempool] [\#3036](https://github.com/tendermint/tendermint/issues/3036) Fix
-  LRU cache by popping the least recently used item when the cache is full,
-  not the most recently used one!
-
-## v0.27.3
-
-*December 16th, 2018*
-
-### BREAKING CHANGES:
-
-* Go API
-
-- [dep] [\#3027](https://github.com/tendermint/tendermint/issues/3027) Revert to mainline Go crypto library, eliminating the modified
-  `bcrypt.GenerateFromPassword`
-
-## v0.27.2
-
-*December 16th, 2018*
-
-### IMPROVEMENTS:
-
-- [node] [\#3025](https://github.com/tendermint/tendermint/issues/3025) Validate NodeInfo addresses on startup.
-
-### BUG FIXES:
-
-- [p2p] [\#3025](https://github.com/tendermint/tendermint/pull/3025) Revert to using defers in addrbook.  Fixes deadlocks in pex and consensus upon invalid ExternalAddr/ListenAddr configuration.
-
-## v0.27.1
-
-*December 15th, 2018*
-
-Special thanks to external contributors on this release:
-@danil-lashin, @hleb-albau, @james-ray, @leo-xinwang
-
-### FEATURES:
-- [rpc] [\#2964](https://github.com/tendermint/tendermint/issues/2964) Add `UnconfirmedTxs(limit)` and `NumUnconfirmedTxs()` methods to HTTP/Local clients (@danil-lashin)
-- [docs] [\#3004](https://github.com/tendermint/tendermint/issues/3004) Enable full-text search on docs pages
-
-### IMPROVEMENTS:
-- [consensus] [\#2971](https://github.com/tendermint/tendermint/issues/2971) Return error if ValidatorSet is empty after InitChain
-  (@leo-xinwang)
-- [ci/cd] [\#3005](https://github.com/tendermint/tendermint/issues/3005) Updated CircleCI job to trigger website build when docs are updated
-- [docs] Various updates
-
-### BUG FIXES:
-- [cmd] [\#2983](https://github.com/tendermint/tendermint/issues/2983) `testnet` command always sets `addr_book_strict = false`
-- [config] [\#2980](https://github.com/tendermint/tendermint/issues/2980) Fix CORS options formatting
-- [kv indexer] [\#2912](https://github.com/tendermint/tendermint/issues/2912) Don't ignore key when executing CONTAINS
-- [mempool] [\#2961](https://github.com/tendermint/tendermint/issues/2961) Call `notifyTxsAvailable` if there're txs left after committing a block, but recheck=false
-- [mempool] [\#2994](https://github.com/tendermint/tendermint/issues/2994) Reject txs with negative GasWanted
-- [p2p] [\#2990](https://github.com/tendermint/tendermint/issues/2990) Fix a bug where seeds don't disconnect from a peer after 3h
-- [consensus] [\#3006](https://github.com/tendermint/tendermint/issues/3006) Save state after InitChain only when stateHeight is also 0 (@james-ray)
-
-## v0.27.0
-
-*December 5th, 2018*
-
-Special thanks to external contributors on this release:
-@danil-lashin, @srmo
-
-Special thanks to @dlguddus for discovering a [major
-issue](https://github.com/tendermint/tendermint/issues/2718#issuecomment-440888677)
-in the proposer selection algorithm.
-
-Friendly reminder, we have a [bug bounty
-program](https://hackerone.com/tendermint).
-
-This release is primarily about fixes to the proposer selection algorithm
-in preparation for the [Cosmos Game of
-Stakes](https://blog.cosmos.network/the-game-of-stakes-is-open-for-registration-83a404746ee6).
-It also makes use of the `ConsensusParams.Validator.PubKeyTypes` to restrict the
-key types that can be used by validators, and removes the `Heartbeat` consensus
-message.
-
-### BREAKING CHANGES:
-
-* CLI/RPC/Config
-  - [rpc] [\#2932](https://github.com/tendermint/tendermint/issues/2932) Rename `accum` to `proposer_priority`
-
-* Go API
-  - [db] [\#2913](https://github.com/tendermint/tendermint/pull/2913)
-    ReverseIterator API change: start < end, and end is exclusive.
-  - [types] [\#2932](https://github.com/tendermint/tendermint/issues/2932) Rename `Validator.Accum` to `Validator.ProposerPriority`
-
-* Blockchain Protocol
-  - [state] [\#2714](https://github.com/tendermint/tendermint/issues/2714) Validators can now only use pubkeys allowed within
-    ConsensusParams.Validator.PubKeyTypes
-
-* P2P Protocol
-  - [consensus] [\#2871](https://github.com/tendermint/tendermint/issues/2871)
-    Remove *ProposalHeartbeat* message as it serves no real purpose (@srmo)
-  - [state] Fixes for proposer selection:
-    - [\#2785](https://github.com/tendermint/tendermint/issues/2785) Accum for new validators is `-1.125*totalVotingPower` instead of 0
-    - [\#2941](https://github.com/tendermint/tendermint/issues/2941) val.Accum is preserved during ValidatorSet.Update to avoid being
-      reset to 0
-
-### IMPROVEMENTS:
-
-- [state] [\#2929](https://github.com/tendermint/tendermint/issues/2929) Minor refactor of updateState logic (@danil-lashin)
-- [node] [\#2959](https://github.com/tendermint/tendermint/issues/2959) Allow node to start even if software's BlockProtocol is
-  different from state's BlockProtocol
-- [pex] [\#2959](https://github.com/tendermint/tendermint/issues/2959) Pex reactor logger uses `module=pex`
-
-### BUG FIXES:
-
-- [p2p] [\#2968](https://github.com/tendermint/tendermint/issues/2968) Panic on transport error rather than continuing to run but not
-  accept new connections
-- [p2p] [\#2969](https://github.com/tendermint/tendermint/issues/2969) Fix mismatch in peer count between `/net_info` and the prometheus
-  metrics
-- [rpc] [\#2408](https://github.com/tendermint/tendermint/issues/2408) `/broadcast_tx_commit`: Fix "interface conversion: interface {} in nil, not EventDataTx" panic (could happen if somebody sent a tx using `/broadcast_tx_commit` while Tendermint was being stopped)
-- [state] [\#2785](https://github.com/tendermint/tendermint/issues/2785) Fix accum for new validators to be `-1.125*totalVotingPower`
-  instead of 0, forcing them to wait before becoming the proposer. Also:
-    - do not batch clip
-    - keep accums averaged near 0
-- [txindex/kv] [\#2925](https://github.com/tendermint/tendermint/issues/2925) Don't return false positives when range searching for a prefix of a tag value
-- [types] [\#2938](https://github.com/tendermint/tendermint/issues/2938) Fix regression in v0.26.4 where we panic on empty
-  genDoc.Validators
-- [types] [\#2941](https://github.com/tendermint/tendermint/issues/2941) Preserve val.Accum during ValidatorSet.Update to avoid it being
-  reset to 0 every time a validator is updated
-
 ## v0.26.4
 
 *November 27th, 2018*
 
 Special thanks to external contributors on this release:
-@ackratos, @goolAdapter, @james-ray, @joe-bowman, @kostko,
-@nagarajmanjunath, @tomtau
+ackratos, goolAdapter, james-ray, joe-bowman, kostko,
+nagarajmanjunath, tomtau
+
 
 Friendly reminder, we have a [bug bounty
 program](https://hackerone.com/tendermint).

CHANGELOG_PENDING.md

@@ -1,40 +1,49 @@
-## v0.28.0
+# Pending
+
+## v0.27.0
 
 *TBD*
 
 Special thanks to external contributors on this release:
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 * CLI/RPC/Config
-- [cli] Removed `node` `--proxy_app=dummy` option. Use `kvstore` (`persistent_kvstore`) instead.
-- [cli] Renamed `node` `--proxy_app=nilapp` to `--proxy_app=noop`.
-- [config] \#2992 `allow_duplicate_ip` is now set to false
-- [privval] \#2926 split up `PubKeyMsg` into `PubKeyRequest` and `PubKeyResponse` to be consistent with other message types
-- [privval] \#2923 listen for unix socket connections instead of dialing them
+  - [rpc] \#2932 Rename `accum` to `proposer_priority`
 
 * Apps
 
 * Go API
-- [types] \#2926 memoize consensus public key on initialization of remote signer and return the memoized key on
-`PrivValidator.GetPubKey()` instead of requesting it again
-- [types] \#2981 Remove `PrivValidator.GetAddress()`
+  - [db] [\#2913](https://github.com/tendermint/tendermint/pull/2913)
+    ReverseIterator API change -- start < end, and end is exclusive.
+  - [types] \#2932 Rename `Validator.Accum` to `Validator.ProposerPriority`
 
 * Blockchain Protocol
+  - [state] \#2714 Validators can now only use pubkeys allowed within
+    ConsensusParams.ValidatorParams
 
 * P2P Protocol
+  - [consensus] [\#2871](https://github.com/tendermint/tendermint/issues/2871)
+    Remove *ProposalHeartbeat* message as it serves no real purpose
+  - [state] Fixes for proposer selection:
+    - \#2785 Accum for new validators is `-1.125*totalVotingPower` instead of 0
+    - \#2941 val.Accum is preserved during ValidatorSet.Update to avoid being
+      reset to 0
 
 ### FEATURES:
-- [privval] \#1181 Split immutable and mutable parts of `priv_validator.json`
+- [privval] \#1181 Split immutable and mutable parts of priv_validator.json
 
 ### IMPROVEMENTS:
-- [p2p/conn] \#3111 make SecretConnection thread safe
-- [privval] \#2923 retry RemoteSigner connections on error
-- [rpc] \#3047 Include peer's remote IP in `/net_info`
 
 ### BUG FIXES:
-
-- [types] \#2926 do not panic if retrieving the private validator's public key fails
-- [rpc] \#3080 check if the variable "skipCount" is bigger than zero. If it is not, we set it to 0. If it, we do not do anything.
-- [crypto/multisig] \#3102 fix multisig keys address length
-- [crypto/encoding] \#3101 Fix `PubKeyMultisigThreshold` unmarshalling into `crypto.PubKey` interface
+- [types] \#2938 Fix regression in v0.26.4 where we panic on empty
+  genDoc.Validators
+- [state] \#2785 Fix accum for new validators to be `-1.125*totalVotingPower`
+  instead of 0, forcing them to wait before becoming the proposer. Also:
+    - do not batch clip
+    - keep accums averaged near 0
+- [types] \#2941 Preserve val.Accum during ValidatorSet.Update to avoid it being
+  reset to 0 every time a validator is updated

DOCKER/build.sh

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

DOCKER/push.sh

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

Gopkg.lock

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

Gopkg.toml

@@ -81,7 +81,8 @@
 
 [[constraint]]
   name = "golang.org/x/crypto"
-  revision = "505ab145d0a99da450461ae2c1a9f6cd10d1f447"
+  source = "github.com/tendermint/crypto"
+  revision = "3764759f34a542a3aef74d6b02e35be7ab893bba"
 
 [[override]]
   name = "github.com/jmhodges/levigo"

Makefile

@@ -294,7 +294,6 @@ build-linux:
 build-docker-localnode:
 	cd networks/local
 	make
-	cd -
 
 # Run a 4-node testnet locally
 localnet-start: localnet-stop

README.md

@@ -1,8 +1,8 @@
 # Tendermint
 
 [Byzantine-Fault Tolerant](https://en.wikipedia.org/wiki/Byzantine_fault_tolerance)
-[State Machines](https://en.wikipedia.org/wiki/State_machine_replication).
-Or [Blockchain](https://en.wikipedia.org/wiki/Blockchain_(database)), for short.
+[State Machine Replication](https://en.wikipedia.org/wiki/State_machine_replication).
+Or [Blockchain](https://en.wikipedia.org/wiki/Blockchain_(database)) for short.
 
 [![version](https://img.shields.io/github/tag/tendermint/tendermint.svg)](https://github.com/tendermint/tendermint/releases/latest)
 [![API Reference](
@@ -49,7 +49,7 @@ For examples of the kinds of bugs we're looking for, see [SECURITY.md](SECURITY.
 
 Requirement|Notes
 ---|---
-Go version | Go1.11.4 or higher
+Go version | Go1.10 or higher
 
 ## Documentation
 
@@ -66,26 +66,49 @@ See the [install instructions](/docs/introduction/install.md)
 - [Remote cluster using terraform and ansible](/docs/networks/terraform-and-ansible.md)
 - [Join the Cosmos testnet](https://cosmos.network/testnet)
 
+## Resources
+
+### Tendermint Core
+
+For details about the blockchain data structures and the p2p protocols, see the
+the [Tendermint specification](/docs/spec).
+
+For details on using the software, see the [documentation](/docs/) which is also
+hosted at: https://tendermint.com/docs/
+
+### Tools
+
+Benchmarking and monitoring is provided by `tm-bench` and `tm-monitor`, respectively.
+Their code is found [here](/tools) and these binaries need to be built seperately.
+Additional documentation is found [here](/docs/tools).
+
+### Sub-projects
+
+* [Amino](http://github.com/tendermint/go-amino), a reflection-based improvement on proto3
+* [IAVL](http://github.com/tendermint/iavl), Merkleized IAVL+ Tree implementation
+
+### Applications
+
+* [Cosmos SDK](http://github.com/cosmos/cosmos-sdk); a cryptocurrency application framework
+* [Ethermint](http://github.com/cosmos/ethermint); Ethereum on Tendermint
+* [Many more](https://tendermint.com/ecosystem)
+
+### Research
+
+* [The latest gossip on BFT consensus](https://arxiv.org/abs/1807.04938)
+* [Master's Thesis on Tendermint](https://atrium.lib.uoguelph.ca/xmlui/handle/10214/9769)
+* [Original Whitepaper](https://tendermint.com/static/docs/tendermint.pdf)
+* [Blog](https://blog.cosmos.network/tendermint/home)
+
 ## Contributing
 
-Please abide by the [Code of Conduct](CODE_OF_CONDUCT.md) in all interactions,
-and the [contributing guidelines](CONTRIBUTING.md) when submitting code.
-
-Join the larger community on the [forum](https://forum.cosmos.network/) and the [chat](https://riot.im/app/#/room/#tendermint:matrix.org).
-
-To learn more about the structure of the software, watch the [Developer
-Sessions](https://www.youtube.com/playlist?list=PLdQIb0qr3pnBbG5ZG-0gr3zM86_s8Rpqv)
-and read some [Architectural
-Decision Records](https://github.com/tendermint/tendermint/tree/master/docs/architecture).
-
-Learn more by reading the code and comparing it to the
-[specification](https://github.com/tendermint/tendermint/tree/develop/docs/spec).
+Yay open source! Please see our [contributing guidelines](CONTRIBUTING.md).
 
 ## Versioning
 
-### Semantic Versioning
+### SemVer
 
-Tendermint uses [Semantic Versioning](http://semver.org/) to determine when and how the version changes.
+Tendermint uses [SemVer](http://semver.org/) to determine when and how the version changes.
 According to SemVer, anything in the public API can change at any time before version 1.0.0
 
 To provide some stability to Tendermint users in these 0.X.X days, the MINOR version is used
@@ -122,40 +145,8 @@ data into the new chain.
 However, any bump in the PATCH version should be compatible with existing histories
 (if not please open an [issue](https://github.com/tendermint/tendermint/issues)).
 
-For more information on upgrading, see [UPGRADING.md](./UPGRADING.md)
+For more information on upgrading, see [here](./UPGRADING.md)
 
-## Resources
-
-### Tendermint Core
-
-For details about the blockchain data structures and the p2p protocols, see the
-[Tendermint specification](/docs/spec).
-
-For details on using the software, see the [documentation](/docs/) which is also
-hosted at: https://tendermint.com/docs/
-
-### Tools
-
-Benchmarking and monitoring is provided by `tm-bench` and `tm-monitor`, respectively.
-Their code is found [here](/tools) and these binaries need to be built seperately.
-Additional documentation is found [here](/docs/tools).
-
-### Sub-projects
-
-* [Amino](http://github.com/tendermint/go-amino), reflection-based proto3, with
-  interfaces
-* [IAVL](http://github.com/tendermint/iavl), Merkleized IAVL+ Tree implementation
-
-### Applications
-
-* [Cosmos SDK](http://github.com/cosmos/cosmos-sdk); a cryptocurrency application framework
-* [Ethermint](http://github.com/cosmos/ethermint); Ethereum on Tendermint
-* [Many more](https://tendermint.com/ecosystem)
-
-### Research
-
-* [The latest gossip on BFT consensus](https://arxiv.org/abs/1807.04938)
-* [Master's Thesis on Tendermint](https://atrium.lib.uoguelph.ca/xmlui/handle/10214/9769)
-* [Original Whitepaper](https://tendermint.com/static/docs/tendermint.pdf)
-* [Blog](https://blog.cosmos.network/tendermint/home)
+## Code of Conduct
 
+Please read, understand and adhere to our [code of conduct](CODE_OF_CONDUCT.md).

UPGRADING.md

@@ -3,50 +3,9 @@
 This guide provides steps to be followed when you upgrade your applications to
 a newer version of Tendermint Core.
 
-## v0.27.0
-
-This release contains some breaking changes to the block and p2p protocols,
-but does not change any core data structures, so it should be compatible with
-existing blockchains from the v0.26 series that only used Ed25519 validator keys.
-Blockchains using Secp256k1 for validators will not be compatible. This is due
-to the fact that we now enforce which key types validators can use as a
-consensus param. The default is Ed25519, and Secp256k1 must be activated
-explicitly.
-
-It is recommended to upgrade all nodes at once to avoid incompatibilities at the
-peer layer - namely, the heartbeat consensus message has been removed (only
-relevant if `create_empty_blocks=false` or `create_empty_blocks_interval > 0`),
-and the proposer selection algorithm has changed. Since proposer information is
-never included in the blockchain, this change only affects the peer layer.
-
-### Go API Changes
-
-#### libs/db
-
-The ReverseIterator API has changed the meaning of `start` and `end`.
-Before, iteration was from `start` to `end`, where
-`start > end`. Now, iteration is from `end` to `start`, where `start < end`.
-The iterator also excludes `end`. This change allows a simplified and more
-intuitive logic, aligning the semantic meaning of `start` and `end` in the
-`Iterator` and `ReverseIterator`.
-
-### Applications
-
-This release enforces a new consensus parameter, the
-ValidatorParams.PubKeyTypes. Applications must ensure that they only return
-validator updates with the allowed PubKeyTypes. If a validator update includes a
-pubkey type that is not included in the ConsensusParams.Validator.PubKeyTypes,
-block execution will fail and the consensus will halt.
-
-By default, only Ed25519 pubkeys may be used for validators. Enabling
-Secp256k1 requires explicit modification of the ConsensusParams.
-Please update your application accordingly (ie. restrict validators to only be
-able to use Ed25519 keys, or explicitly add additional key types to the genesis
-file).
-
 ## v0.26.0
 
-This release contains a lot of changes to core data types and protocols. It is not
+New 0.26.0 release contains a lot of changes to core data types and protocols. 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.
 
@@ -108,7 +67,7 @@ For more information, see:
 
 ### Go API Changes
 
-#### crypto/merkle
+#### 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

abci/cmd/abci-cli/abci-cli.go

@@ -58,7 +58,7 @@ var RootCmd = &cobra.Command{
 	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
 
 		switch cmd.Use {
-		case "counter", "kvstore": // for the examples apps, don't pre-run
+		case "counter", "kvstore", "dummy": // for the examples apps, don't pre-run
 			return nil
 		case "version": // skip running for version command
 			return nil
@@ -127,6 +127,10 @@ func addCounterFlags() {
 	counterCmd.PersistentFlags().BoolVarP(&flagSerial, "serial", "", false, "enforce incrementing (serial) transactions")
 }
 
+func addDummyFlags() {
+	dummyCmd.PersistentFlags().StringVarP(&flagPersist, "persist", "", "", "directory to use for a database")
+}
+
 func addKVStoreFlags() {
 	kvstoreCmd.PersistentFlags().StringVarP(&flagPersist, "persist", "", "", "directory to use for a database")
 }
@@ -148,6 +152,10 @@ func addCommands() {
 	// examples
 	addCounterFlags()
 	RootCmd.AddCommand(counterCmd)
+	// deprecated, left for backwards compatibility
+	addDummyFlags()
+	RootCmd.AddCommand(dummyCmd)
+	// replaces dummy, see issue #196
 	addKVStoreFlags()
 	RootCmd.AddCommand(kvstoreCmd)
 }
@@ -283,6 +291,18 @@ var counterCmd = &cobra.Command{
 	},
 }
 
+// deprecated, left for backwards compatibility
+var dummyCmd = &cobra.Command{
+	Use:        "dummy",
+	Deprecated: "use: [abci-cli kvstore] instead",
+	Short:      "ABCI demo example",
+	Long:       "ABCI demo example",
+	Args:       cobra.ExactArgs(0),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return cmdKVStore(cmd, args)
+	},
+}
+
 var kvstoreCmd = &cobra.Command{
 	Use:   "kvstore",
 	Short: "ABCI demo example",

blockchain/reactor.go

@@ -432,7 +432,11 @@ type bcBlockResponseMessage struct {
 
 // ValidateBasic performs basic validation.
 func (m *bcBlockResponseMessage) ValidateBasic() error {
-	return m.Block.ValidateBasic()
+	if err := m.Block.ValidateBasic(); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func (m *bcBlockResponseMessage) String() string {

blockchain/reactor_test.go

@@ -42,7 +42,7 @@ func randGenesisDoc(numValidators int, randPower bool, minPower int64) (*types.G
 }
 
 func makeVote(header *types.Header, blockID types.BlockID, valset *types.ValidatorSet, privVal types.PrivValidator) *types.Vote {
-	addr := privVal.GetPubKey().Address()
+	addr := privVal.GetAddress()
 	idx, _ := valset.GetByAddress(addr)
 	vote := &types.Vote{
 		ValidatorAddress: addr,

cmd/priv_val_server/main.go

@@ -3,7 +3,6 @@ package main
 import (
 	"flag"
 	"os"
-	"time"
 
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	cmn "github.com/tendermint/tendermint/libs/common"
@@ -35,20 +34,13 @@ func main() {
 
 	pv := privval.LoadFilePV(*privValKeyPath, *privValStatePath)
 
-	var dialer privval.Dialer
-	protocol, address := cmn.ProtocolAndAddress(*addr)
-	switch protocol {
-	case "unix":
-		dialer = privval.DialUnixFn(address)
-	case "tcp":
-		connTimeout := 3 * time.Second // TODO
-		dialer = privval.DialTCPFn(address, connTimeout, ed25519.GenPrivKey())
-	default:
-		logger.Error("Unknown protocol", "protocol", protocol)
-		return
-	}
-
-	rs := privval.NewRemoteSigner(logger, *chainID, pv, dialer)
+	rs := privval.NewRemoteSigner(
+		logger,
+		*chainID,
+		*addr,
+		pv,
+		ed25519.GenPrivKey(),
+	)
 	err := rs.Start()
 	if err != nil {
 		panic(err)

cmd/tendermint/commands/init.go

@@ -59,10 +59,9 @@ func initFilesWithConfig(config *cfg.Config) error {
 			GenesisTime:     tmtime.Now(),
 			ConsensusParams: types.DefaultConsensusParams(),
 		}
-		key := pv.GetPubKey()
 		genDoc.Validators = []types.GenesisValidator{{
-			Address: key.Address(),
-			PubKey:  key,
+			Address: pv.GetPubKey().Address(),
+			PubKey:  pv.GetPubKey(),
 			Power:   10,
 		}}
 

cmd/tendermint/commands/reset_priv_validator.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/spf13/cobra"
 
-	cmn "github.com/tendermint/tendermint/libs/common"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/privval"
 )
@@ -38,23 +37,21 @@ func resetPrivValidator(cmd *cobra.Command, args []string) {
 	resetFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile(), logger)
 }
 
-// ResetAll removes address book files plus all data, and resets the privValdiator data.
+// ResetAll removes the privValidator and address book files plus all data.
 // Exported so other CLI tools can use it.
 func ResetAll(dbDir, addrBookFile, privValKeyFile, privValStateFile string, logger log.Logger) {
+	resetFilePV(privValKeyFile, privValStateFile, logger)
 	removeAddrBook(addrBookFile, logger)
 	if err := os.RemoveAll(dbDir); err == nil {
 		logger.Info("Removed all blockchain history", "dir", dbDir)
 	} else {
 		logger.Error("Error removing all blockchain history", "dir", dbDir, "err", err)
 	}
-	// recreate the dbDir since the privVal state needs to live there
-	cmn.EnsureDir(dbDir, 0700)
-	resetFilePV(privValKeyFile, privValStateFile, logger)
 }
 
 func resetFilePV(privValKeyFile, privValStateFile string, logger log.Logger) {
 	if _, err := os.Stat(privValKeyFile); err == nil {
-		pv := privval.LoadFilePVEmptyState(privValKeyFile, privValStateFile)
+		pv := privval.LoadFilePV(privValKeyFile, privValStateFile)
 		pv.Reset()
 		logger.Info("Reset private validator file to genesis state", "keyFile", privValKeyFile,
 			"stateFile", privValStateFile)

cmd/tendermint/commands/run_node.go

@@ -24,7 +24,7 @@ func AddNodeFlags(cmd *cobra.Command) {
 	cmd.Flags().Bool("fast_sync", config.FastSync, "Fast blockchain syncing")
 
 	// abci flags
-	cmd.Flags().String("proxy_app", config.ProxyApp, "Proxy app address, or one of: 'kvstore', 'persistent_kvstore', 'counter', 'counter_serial' or 'noop' for local testing.")
+	cmd.Flags().String("proxy_app", config.ProxyApp, "Proxy app address, or 'nilapp' or 'kvstore' for local testing.")
 	cmd.Flags().String("abci", config.ABCI, "Specify abci transport (socket | grpc)")
 
 	// rpc flags

cmd/tendermint/commands/testnet.go

@@ -134,32 +134,14 @@ func testnetFiles(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	// Gather persistent peer addresses.
-	var (
-		persistentPeers string
-		err             error
-	)
 	if populatePersistentPeers {
-		persistentPeers, err = persistentPeersString(config)
+		err := populatePersistentPeersInConfigAndWriteIt(config)
 		if err != nil {
 			_ = os.RemoveAll(outputDir)
 			return err
 		}
 	}
 
-	// Overwrite default config.
-	for i := 0; i < nValidators+nNonValidators; i++ {
-		nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i))
-		config.SetRoot(nodeDir)
-		config.P2P.AddrBookStrict = false
-		config.P2P.AllowDuplicateIP = true
-		if populatePersistentPeers {
-			config.P2P.PersistentPeers = persistentPeers
-		}
-
-		cfg.WriteConfigFile(filepath.Join(nodeDir, "config", "config.toml"), config)
-	}
-
 	fmt.Printf("Successfully initialized %v node directories\n", nValidators+nNonValidators)
 	return nil
 }
@@ -182,16 +164,28 @@ func hostnameOrIP(i int) string {
 	return fmt.Sprintf("%s%d", hostnamePrefix, i)
 }
 
-func persistentPeersString(config *cfg.Config) (string, error) {
+func populatePersistentPeersInConfigAndWriteIt(config *cfg.Config) error {
 	persistentPeers := make([]string, nValidators+nNonValidators)
 	for i := 0; i < nValidators+nNonValidators; i++ {
 		nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i))
 		config.SetRoot(nodeDir)
 		nodeKey, err := p2p.LoadNodeKey(config.NodeKeyFile())
 		if err != nil {
-			return "", err
+			return err
 		}
 		persistentPeers[i] = p2p.IDAddressString(nodeKey.ID(), fmt.Sprintf("%s:%d", hostnameOrIP(i), p2pPort))
 	}
-	return strings.Join(persistentPeers, ","), nil
+	persistentPeersList := strings.Join(persistentPeers, ",")
+
+	for i := 0; i < nValidators+nNonValidators; i++ {
+		nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i))
+		config.SetRoot(nodeDir)
+		config.P2P.PersistentPeers = persistentPeersList
+		config.P2P.AddrBookStrict = false
+
+		// overwrite default config
+		cfg.WriteConfigFile(filepath.Join(nodeDir, "config", "config.toml"), config)
+	}
+
+	return nil
 }

config/config.go

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

config/toml.go

@@ -128,13 +128,13 @@ laddr = "{{ .RPC.ListenAddress }}"
 # A list of origins a cross-domain request can be executed from
 # Default value '[]' disables cors support
 # Use '["*"]' to allow any origin
-cors_allowed_origins = [{{ range .RPC.CORSAllowedOrigins }}{{ printf "%q, " . }}{{end}}]
+cors_allowed_origins = "{{ .RPC.CORSAllowedOrigins }}"
 
 # A list of methods the client is allowed to use with cross-domain requests
-cors_allowed_methods = [{{ range .RPC.CORSAllowedMethods }}{{ printf "%q, " . }}{{end}}]
+cors_allowed_methods = "{{ .RPC.CORSAllowedMethods }}"
 
 # A list of non simple headers the client is allowed to use with cross-domain requests
-cors_allowed_headers = [{{ range .RPC.CORSAllowedHeaders }}{{ printf "%q, " . }}{{end}}]
+cors_allowed_headers = "{{ .RPC.CORSAllowedHeaders }}"
 
 # TCP or UNIX socket address for the gRPC server to listen on
 # NOTE: This server only supports /broadcast_tx_commit
@@ -142,7 +142,7 @@ grpc_laddr = "{{ .RPC.GRPCListenAddress }}"
 
 # Maximum number of simultaneous connections.
 # Does not include RPC (HTTP&WebSocket) connections. See max_open_connections
-# If you want to accept a larger number than the default, make sure
+# If you want to accept more significant number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
 # Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
@@ -154,7 +154,7 @@ unsafe = {{ .RPC.Unsafe }}
 
 # Maximum number of simultaneous connections (including WebSocket).
 # Does not include gRPC connections. See grpc_max_open_connections
-# If you want to accept a larger number than the default, make sure
+# If you want to accept more significant number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
 # Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
@@ -272,8 +272,8 @@ blocktime_iota = "{{ .Consensus.BlockTimeIota }}"
 # What indexer to use for transactions
 #
 # Options:
-#   1) "null"
-#   2) "kv" (default) - the simplest possible indexer, backed by key-value storage (defaults to levelDB; see DBBackend).
+#   1) "null" (default)
+#   2) "kv" - the simplest possible indexer, backed by key-value storage (defaults to levelDB; see DBBackend).
 indexer = "{{ .TxIndex.Indexer }}"
 
 # Comma-separated list of tags to index (by default the only tag is "tx.hash")
@@ -305,7 +305,7 @@ prometheus = {{ .Instrumentation.Prometheus }}
 prometheus_listen_addr = "{{ .Instrumentation.PrometheusListenAddr }}"
 
 # Maximum number of simultaneous connections.
-# If you want to accept a larger number than the default, make sure
+# If you want to accept more significant number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
 max_open_connections = {{ .Instrumentation.MaxOpenConnections }}

consensus/common_test.go

@@ -71,10 +71,9 @@ func NewValidatorStub(privValidator types.PrivValidator, valIndex int) *validato
 }
 
 func (vs *validatorStub) signVote(voteType types.SignedMsgType, hash []byte, header types.PartSetHeader) (*types.Vote, error) {
-	addr := vs.PrivValidator.GetPubKey().Address()
 	vote := &types.Vote{
 		ValidatorIndex:   vs.Index,
-		ValidatorAddress: addr,
+		ValidatorAddress: vs.PrivValidator.GetAddress(),
 		Height:           vs.Height,
 		Round:            vs.Round,
 		Timestamp:        tmtime.Now(),
@@ -151,9 +150,8 @@ func signAddVotes(to *ConsensusState, voteType types.SignedMsgType, hash []byte,
 
 func validatePrevote(t *testing.T, cs *ConsensusState, round int, privVal *validatorStub, blockHash []byte) {
 	prevotes := cs.Votes.Prevotes(round)
-	address := privVal.GetPubKey().Address()
 	var vote *types.Vote
-	if vote = prevotes.GetByAddress(address); vote == nil {
+	if vote = prevotes.GetByAddress(privVal.GetAddress()); vote == nil {
 		panic("Failed to find prevote from validator")
 	}
 	if blockHash == nil {
@@ -169,9 +167,8 @@ func validatePrevote(t *testing.T, cs *ConsensusState, round int, privVal *valid
 
 func validateLastPrecommit(t *testing.T, cs *ConsensusState, privVal *validatorStub, blockHash []byte) {
 	votes := cs.LastCommit
-	address := privVal.GetPubKey().Address()
 	var vote *types.Vote
-	if vote = votes.GetByAddress(address); vote == nil {
+	if vote = votes.GetByAddress(privVal.GetAddress()); vote == nil {
 		panic("Failed to find precommit from validator")
 	}
 	if !bytes.Equal(vote.BlockID.Hash, blockHash) {
@@ -181,9 +178,8 @@ func validateLastPrecommit(t *testing.T, cs *ConsensusState, privVal *validatorS
 
 func validatePrecommit(t *testing.T, cs *ConsensusState, thisRound, lockRound int, privVal *validatorStub, votedBlockHash, lockedBlockHash []byte) {
 	precommits := cs.Votes.Precommits(thisRound)
-	address := privVal.GetPubKey().Address()
 	var vote *types.Vote
-	if vote = precommits.GetByAddress(address); vote == nil {
+	if vote = precommits.GetByAddress(privVal.GetAddress()); vote == nil {
 		panic("Failed to find precommit from validator")
 	}
 

consensus/reactor_test.go

@@ -143,8 +143,7 @@ func TestReactorWithEvidence(t *testing.T) {
 		// mock the evidence pool
 		// everyone includes evidence of another double signing
 		vIdx := (i + 1) % nValidators
-		addr := privVals[vIdx].GetPubKey().Address()
-		evpool := newMockEvidencePool(addr)
+		evpool := newMockEvidencePool(privVals[vIdx].GetAddress())
 
 		// Make ConsensusState
 		blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(), proxyAppConnCon, mempool, evpool)
@@ -269,8 +268,7 @@ func TestReactorVotingPowerChange(t *testing.T) {
 	// map of active validators
 	activeVals := make(map[string]struct{})
 	for i := 0; i < nVals; i++ {
-		addr := css[i].privValidator.GetPubKey().Address()
-		activeVals[string(addr)] = struct{}{}
+		activeVals[string(css[i].privValidator.GetAddress())] = struct{}{}
 	}
 
 	// wait till everyone makes block 1
@@ -333,8 +331,7 @@ func TestReactorValidatorSetChanges(t *testing.T) {
 	// map of active validators
 	activeVals := make(map[string]struct{})
 	for i := 0; i < nVals; i++ {
-		addr := css[i].privValidator.GetPubKey().Address()
-		activeVals[string(addr)] = struct{}{}
+		activeVals[string(css[i].privValidator.GetAddress())] = struct{}{}
 	}
 
 	// wait till everyone makes block 1

consensus/replay.go

@@ -11,6 +11,7 @@ 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"
@@ -19,7 +20,6 @@ import (
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
-	"github.com/tendermint/tendermint/version"
 )
 
 var crc32c = crc32.MakeTable(crc32.Castagnoli)
@@ -247,7 +247,6 @@ func (h *Handshaker) Handshake(proxyApp proxy.AppConns) error {
 
 	// Set AppVersion on the state.
 	h.initialState.Version.Consensus.App = version.Protocol(res.AppVersion)
-	sm.SaveState(h.stateDB, h.initialState)
 
 	// Replay blocks up to the latest in the blockstore.
 	_, err = h.ReplayBlocks(h.initialState, appHash, blockHeight, proxyApp)
@@ -296,27 +295,19 @@ func (h *Handshaker) ReplayBlocks(
 			return nil, err
 		}
 
-		if stateBlockHeight == 0 { //we only update state when we are in initial state
-			// If the app returned validators or consensus params, update the state.
-			if len(res.Validators) > 0 {
-				vals, err := types.PB2TM.ValidatorUpdates(res.Validators)
-				if err != nil {
-					return nil, err
-				}
-				state.Validators = types.NewValidatorSet(vals)
-				state.NextValidators = types.NewValidatorSet(vals)
-			} else {
-				// If validator set is not set in genesis and still empty after InitChain, exit.
-				if len(h.genDoc.Validators) == 0 {
-					return nil, fmt.Errorf("Validator set is nil in genesis and still empty after InitChain")
-				}
+		// If the app returned validators or consensus params, update the state.
+		if len(res.Validators) > 0 {
+			vals, err := types.PB2TM.ValidatorUpdates(res.Validators)
+			if err != nil {
+				return nil, err
 			}
-
-			if res.ConsensusParams != nil {
-				state.ConsensusParams = types.PB2TM.ConsensusParams(res.ConsensusParams)
-			}
-			sm.SaveState(h.stateDB, state)
+			state.Validators = types.NewValidatorSet(vals)
+			state.NextValidators = types.NewValidatorSet(vals)
 		}
+		if res.ConsensusParams != nil {
+			state.ConsensusParams = types.PB2TM.ConsensusParams(res.ConsensusParams)
+		}
+		sm.SaveState(h.stateDB, state)
 	}
 
 	// First handle edge cases and constraints on the storeBlockHeight.

consensus/replay_test.go

@@ -659,6 +659,12 @@ func TestInitChainUpdateValidators(t *testing.T) {
 	assert.Equal(t, newValAddr, expectValAddr)
 }
 
+func newInitChainApp(vals []abci.ValidatorUpdate) *initChainApp {
+	return &initChainApp{
+		vals: vals,
+	}
+}
+
 // returns the vals on InitChain
 type initChainApp struct {
 	abci.BaseApplication

consensus/state.go

@@ -2,14 +2,13 @@ package consensus
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"reflect"
 	"runtime/debug"
 	"sync"
 	"time"
 
-	"github.com/pkg/errors"
-
 	cmn "github.com/tendermint/tendermint/libs/common"
 	"github.com/tendermint/tendermint/libs/fail"
 	"github.com/tendermint/tendermint/libs/log"
@@ -830,14 +829,13 @@ func (cs *ConsensusState) enterPropose(height int64, round int) {
 	}
 
 	// if not a validator, we're done
-	address := cs.privValidator.GetPubKey().Address()
-	if !cs.Validators.HasAddress(address) {
-		logger.Debug("This node is not a validator", "addr", address, "vals", cs.Validators)
+	if !cs.Validators.HasAddress(cs.privValidator.GetAddress()) {
+		logger.Debug("This node is not a validator", "addr", cs.privValidator.GetAddress(), "vals", cs.Validators)
 		return
 	}
 	logger.Debug("This node is a validator")
 
-	if cs.isProposer(address) {
+	if cs.isProposer() {
 		logger.Info("enterPropose: Our turn to propose", "proposer", cs.Validators.GetProposer().Address, "privValidator", cs.privValidator)
 		cs.decideProposal(height, round)
 	} else {
@@ -845,8 +843,8 @@ func (cs *ConsensusState) enterPropose(height int64, round int) {
 	}
 }
 
-func (cs *ConsensusState) isProposer(address []byte) bool {
-	return bytes.Equal(cs.Validators.GetProposer().Address, address)
+func (cs *ConsensusState) isProposer() bool {
+	return bytes.Equal(cs.Validators.GetProposer().Address, cs.privValidator.GetAddress())
 }
 
 func (cs *ConsensusState) defaultDecideProposal(height int64, round int) {
@@ -931,7 +929,7 @@ func (cs *ConsensusState) createProposalBlock() (block *types.Block, blockParts
 		cs.state.Validators.Size(),
 		len(evidence),
 	), maxGas)
-	proposerAddr := cs.privValidator.GetPubKey().Address()
+	proposerAddr := cs.privValidator.GetAddress()
 	block, parts := cs.state.MakeBlock(cs.Height, txs, commit, evidence, proposerAddr)
 
 	return block, parts
@@ -1476,8 +1474,7 @@ func (cs *ConsensusState) tryAddVote(vote *types.Vote, peerID p2p.ID) (bool, err
 		if err == ErrVoteHeightMismatch {
 			return added, err
 		} else if voteErr, ok := err.(*types.ErrVoteConflictingVotes); ok {
-			addr := cs.privValidator.GetPubKey().Address()
-			if bytes.Equal(vote.ValidatorAddress, addr) {
+			if bytes.Equal(vote.ValidatorAddress, cs.privValidator.GetAddress()) {
 				cs.Logger.Error("Found conflicting vote from ourselves. Did you unsafe_reset a validator?", "height", vote.Height, "round", vote.Round, "type", vote.Type)
 				return added, err
 			}
@@ -1529,7 +1526,7 @@ func (cs *ConsensusState) addVote(vote *types.Vote, peerID p2p.ID) (added bool,
 	// Not necessarily a bad peer, but not favourable behaviour.
 	if vote.Height != cs.Height {
 		err = ErrVoteHeightMismatch
-		cs.Logger.Info("Vote ignored and not added", "voteHeight", vote.Height, "csHeight", cs.Height, "peerID", peerID)
+		cs.Logger.Info("Vote ignored and not added", "voteHeight", vote.Height, "csHeight", cs.Height, "err", err)
 		return
 	}
 
@@ -1642,7 +1639,7 @@ func (cs *ConsensusState) addVote(vote *types.Vote, peerID p2p.ID) (added bool,
 }
 
 func (cs *ConsensusState) signVote(type_ types.SignedMsgType, hash []byte, header types.PartSetHeader) (*types.Vote, error) {
-	addr := cs.privValidator.GetPubKey().Address()
+	addr := cs.privValidator.GetAddress()
 	valIndex, _ := cs.Validators.GetByAddress(addr)
 
 	vote := &types.Vote{
@@ -1678,7 +1675,7 @@ func (cs *ConsensusState) voteTime() time.Time {
 // sign the vote and publish on internalMsgQueue
 func (cs *ConsensusState) signAddVote(type_ types.SignedMsgType, hash []byte, header types.PartSetHeader) *types.Vote {
 	// if we don't have a key or we're not in the validator set, do nothing
-	if cs.privValidator == nil || !cs.Validators.HasAddress(cs.privValidator.GetPubKey().Address()) {
+	if cs.privValidator == nil || !cs.Validators.HasAddress(cs.privValidator.GetAddress()) {
 		return nil
 	}
 	vote, err := cs.signVote(type_, hash, header)

consensus/state_test.go

@@ -73,8 +73,7 @@ func TestStateProposerSelection0(t *testing.T) {
 
 	// Commit a block and ensure proposer for the next height is correct.
 	prop := cs1.GetRoundState().Validators.GetProposer()
-	address := cs1.privValidator.GetPubKey().Address()
-	if !bytes.Equal(prop.Address, address) {
+	if !bytes.Equal(prop.Address, cs1.privValidator.GetAddress()) {
 		t.Fatalf("expected proposer to be validator %d. Got %X", 0, prop.Address)
 	}
 
@@ -88,8 +87,7 @@ func TestStateProposerSelection0(t *testing.T) {
 	ensureNewRound(newRoundCh, height+1, 0)
 
 	prop = cs1.GetRoundState().Validators.GetProposer()
-	addr := vss[1].GetPubKey().Address()
-	if !bytes.Equal(prop.Address, addr) {
+	if !bytes.Equal(prop.Address, vss[1].GetAddress()) {
 		panic(fmt.Sprintf("expected proposer to be validator %d. Got %X", 1, prop.Address))
 	}
 }
@@ -112,8 +110,7 @@ func TestStateProposerSelection2(t *testing.T) {
 	// everyone just votes nil. we get a new proposer each round
 	for i := 0; i < len(vss); i++ {
 		prop := cs1.GetRoundState().Validators.GetProposer()
-		addr := vss[(i+round)%len(vss)].GetPubKey().Address()
-		correctProposer := addr
+		correctProposer := vss[(i+round)%len(vss)].GetAddress()
 		if !bytes.Equal(prop.Address, correctProposer) {
 			panic(fmt.Sprintf("expected RoundState.Validators.GetProposer() to be validator %d. Got %X", (i+2)%len(vss), prop.Address))
 		}
@@ -508,8 +505,7 @@ func TestStateLockPOLRelock(t *testing.T) {
 
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
+	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
 	newBlockCh := subscribe(cs1.eventBus, types.EventQueryNewBlockHeader)
 
@@ -600,8 +596,7 @@ func TestStateLockPOLUnlock(t *testing.T) {
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
 	unlockCh := subscribe(cs1.eventBus, types.EventQueryUnlock)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
+	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
 
 	// everything done from perspective of cs1
 
@@ -694,8 +689,7 @@ func TestStateLockPOLSafety1(t *testing.T) {
 	timeoutProposeCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose)
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
+	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
 
 	// start round and wait for propose and prevote
 	startTestRound(cs1, cs1.Height, round)
@@ -811,8 +805,7 @@ func TestStateLockPOLSafety2(t *testing.T) {
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
 	unlockCh := subscribe(cs1.eventBus, types.EventQueryUnlock)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
+	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
 
 	// the block for R0: gets polkad but we miss it
 	// (even though we signed it, shhh)
@@ -903,8 +896,7 @@ func TestProposeValidBlock(t *testing.T) {
 	timeoutProposeCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
 	unlockCh := subscribe(cs1.eventBus, types.EventQueryUnlock)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
+	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
 
 	// start round and wait for propose and prevote
 	startTestRound(cs1, cs1.Height, round)
@@ -990,8 +982,7 @@ func TestSetValidBlockOnDelayedPrevote(t *testing.T) {
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
 	validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
+	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
 
 	// start round and wait for propose and prevote
 	startTestRound(cs1, cs1.Height, round)
@@ -1050,8 +1041,7 @@ func TestSetValidBlockOnDelayedProposal(t *testing.T) {
 	timeoutProposeCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
 	validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
+	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
 
 	round = round + 1 // move to round in which P0 is not proposer
@@ -1121,8 +1111,7 @@ func TestWaitingTimeoutProposeOnNewRound(t *testing.T) {
 
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
+	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
 
 	// start round
 	startTestRound(cs1, height, round)
@@ -1155,8 +1144,7 @@ func TestRoundSkipOnNilPolkaFromHigherRound(t *testing.T) {
 
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
+	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
 
 	// start round
 	startTestRound(cs1, height, round)
@@ -1189,8 +1177,7 @@ func TestWaitTimeoutProposeOnNilPolkaForTheCurrentRound(t *testing.T) {
 
 	timeoutProposeCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
+	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
 
 	// start round in which PO is not proposer
 	startTestRound(cs1, height, round)
@@ -1374,8 +1361,7 @@ func TestStateHalt1(t *testing.T) {
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
 	newBlockCh := subscribe(cs1.eventBus, types.EventQueryNewBlock)
-	addr := cs1.privValidator.GetPubKey().Address()
-	voteCh := subscribeToVoter(cs1, addr)
+	voteCh := subscribeToVoter(cs1, cs1.privValidator.GetAddress())
 
 	// start round and wait for propose and prevote
 	startTestRound(cs1, height, round)

consensus/types/height_vote_set_test.go

@@ -50,9 +50,8 @@ func TestPeerCatchupRounds(t *testing.T) {
 
 func makeVoteHR(t *testing.T, height int64, round int, privVals []types.PrivValidator, valIndex int) *types.Vote {
 	privVal := privVals[valIndex]
-	addr := privVal.GetPubKey().Address()
 	vote := &types.Vote{
-		ValidatorAddress: addr,
+		ValidatorAddress: privVal.GetAddress(),
 		ValidatorIndex:   valIndex,
 		Height:           height,
 		Round:            round,

crypto/armor/armor.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"io/ioutil"
 
-	"golang.org/x/crypto/openpgp/armor"
+	"golang.org/x/crypto/openpgp/armor" // forked to github.com/tendermint/crypto
 )
 
 func EncodeArmor(blockType string, headers map[string]string, data []byte) string {

crypto/ed25519/ed25519.go

@@ -7,7 +7,7 @@ import (
 	"io"
 
 	amino "github.com/tendermint/go-amino"
-	"golang.org/x/crypto/ed25519"
+	"golang.org/x/crypto/ed25519" // forked to github.com/tendermint/crypto
 
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/tmhash"
@@ -18,8 +18,8 @@ import (
 var _ crypto.PrivKey = PrivKeyEd25519{}
 
 const (
-	PrivKeyAminoName = "tendermint/PrivKeyEd25519"
-	PubKeyAminoName  = "tendermint/PubKeyEd25519"
+	PrivKeyAminoRoute = "tendermint/PrivKeyEd25519"
+	PubKeyAminoRoute  = "tendermint/PubKeyEd25519"
 	// Size of an Edwards25519 signature. Namely the size of a compressed
 	// Edwards25519 point, and a field element. Both of which are 32 bytes.
 	SignatureSize = 64
@@ -30,11 +30,11 @@ var cdc = amino.NewCodec()
 func init() {
 	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
 	cdc.RegisterConcrete(PubKeyEd25519{},
-		PubKeyAminoName, nil)
+		PubKeyAminoRoute, nil)
 
 	cdc.RegisterInterface((*crypto.PrivKey)(nil), nil)
 	cdc.RegisterConcrete(PrivKeyEd25519{},
-		PrivKeyAminoName, nil)
+		PrivKeyAminoRoute, nil)
 }
 
 // PrivKeyEd25519 implements crypto.PrivKey.

crypto/encoding/amino/amino.go

@@ -12,11 +12,11 @@ import (
 
 var cdc = amino.NewCodec()
 
-// nameTable is used to map public key concrete types back
-// to their registered amino names. This should eventually be handled
+// routeTable is used to map public key concrete types back
+// to their amino routes. This should eventually be handled
 // by amino. Example usage:
-// nameTable[reflect.TypeOf(ed25519.PubKeyEd25519{})] = ed25519.PubKeyAminoName
-var nameTable = make(map[reflect.Type]string, 3)
+// routeTable[reflect.TypeOf(ed25519.PubKeyEd25519{})] = ed25519.PubKeyAminoRoute
+var routeTable = make(map[reflect.Type]string, 3)
 
 func init() {
 	// NOTE: It's important that there be no conflicts here,
@@ -29,16 +29,16 @@ func init() {
 
 	// TODO: Have amino provide a way to go from concrete struct to route directly.
 	// Its currently a private API
-	nameTable[reflect.TypeOf(ed25519.PubKeyEd25519{})] = ed25519.PubKeyAminoName
-	nameTable[reflect.TypeOf(secp256k1.PubKeySecp256k1{})] = secp256k1.PubKeyAminoName
-	nameTable[reflect.TypeOf(multisig.PubKeyMultisigThreshold{})] = multisig.PubKeyMultisigThresholdAminoRoute
+	routeTable[reflect.TypeOf(ed25519.PubKeyEd25519{})] = ed25519.PubKeyAminoRoute
+	routeTable[reflect.TypeOf(secp256k1.PubKeySecp256k1{})] = secp256k1.PubKeyAminoRoute
+	routeTable[reflect.TypeOf(&multisig.PubKeyMultisigThreshold{})] = multisig.PubKeyMultisigThresholdAminoRoute
 }
 
-// PubkeyAminoName returns the amino route of a pubkey
+// PubkeyAminoRoute returns the amino route of a pubkey
 // cdc is currently passed in, as eventually this will not be using
 // a package level codec.
-func PubkeyAminoName(cdc *amino.Codec, key crypto.PubKey) (string, bool) {
-	route, found := nameTable[reflect.TypeOf(key)]
+func PubkeyAminoRoute(cdc *amino.Codec, key crypto.PubKey) (string, bool) {
+	route, found := routeTable[reflect.TypeOf(key)]
 	return route, found
 }
 
@@ -47,17 +47,17 @@ func RegisterAmino(cdc *amino.Codec) {
 	// These are all written here instead of
 	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
 	cdc.RegisterConcrete(ed25519.PubKeyEd25519{},
-		ed25519.PubKeyAminoName, nil)
+		ed25519.PubKeyAminoRoute, nil)
 	cdc.RegisterConcrete(secp256k1.PubKeySecp256k1{},
-		secp256k1.PubKeyAminoName, nil)
+		secp256k1.PubKeyAminoRoute, nil)
 	cdc.RegisterConcrete(multisig.PubKeyMultisigThreshold{},
 		multisig.PubKeyMultisigThresholdAminoRoute, nil)
 
 	cdc.RegisterInterface((*crypto.PrivKey)(nil), nil)
 	cdc.RegisterConcrete(ed25519.PrivKeyEd25519{},
-		ed25519.PrivKeyAminoName, nil)
+		ed25519.PrivKeyAminoRoute, nil)
 	cdc.RegisterConcrete(secp256k1.PrivKeySecp256k1{},
-		secp256k1.PrivKeyAminoName, nil)
+		secp256k1.PrivKeyAminoRoute, nil)
 }
 
 func PrivKeyFromBytes(privKeyBytes []byte) (privKey crypto.PrivKey, err error) {

crypto/encoding/amino/encode_test.go

@@ -128,18 +128,18 @@ func TestPubKeyInvalidDataProperReturnsEmpty(t *testing.T) {
 	require.Nil(t, pk)
 }
 
-func TestPubkeyAminoName(t *testing.T) {
+func TestPubkeyAminoRoute(t *testing.T) {
 	tests := []struct {
 		key   crypto.PubKey
 		want  string
 		found bool
 	}{
-		{ed25519.PubKeyEd25519{}, ed25519.PubKeyAminoName, true},
-		{secp256k1.PubKeySecp256k1{}, secp256k1.PubKeyAminoName, true},
-		{multisig.PubKeyMultisigThreshold{}, multisig.PubKeyMultisigThresholdAminoRoute, true},
+		{ed25519.PubKeyEd25519{}, ed25519.PubKeyAminoRoute, true},
+		{secp256k1.PubKeySecp256k1{}, secp256k1.PubKeyAminoRoute, true},
+		{&multisig.PubKeyMultisigThreshold{}, multisig.PubKeyMultisigThresholdAminoRoute, true},
 	}
 	for i, tc := range tests {
-		got, found := PubkeyAminoName(cdc, tc.key)
+		got, found := PubkeyAminoRoute(cdc, tc.key)
 		require.Equal(t, tc.found, found, "not equal on tc %d", i)
 		if tc.found {
 			require.Equal(t, tc.want, got, "not equal on tc %d", i)

crypto/hash.go

@@ -3,7 +3,7 @@ package crypto
 import (
 	"crypto/sha256"
 
-	"golang.org/x/crypto/ripemd160"
+	"golang.org/x/crypto/ripemd160" // forked to github.com/tendermint/crypto
 )
 
 func Sha256(bytes []byte) []byte {

crypto/multisig/threshold_pubkey.go

@@ -2,6 +2,7 @@ package multisig
 
 import (
 	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/crypto/tmhash"
 )
 
 // PubKeyMultisigThreshold implements a K of N threshold multisig.
@@ -10,7 +11,7 @@ type PubKeyMultisigThreshold struct {
 	PubKeys []crypto.PubKey `json:"pubkeys"`
 }
 
-var _ crypto.PubKey = PubKeyMultisigThreshold{}
+var _ crypto.PubKey = &PubKeyMultisigThreshold{}
 
 // NewPubKeyMultisigThreshold returns a new PubKeyMultisigThreshold.
 // Panics if len(pubkeys) < k or 0 >= k.
@@ -21,7 +22,7 @@ func NewPubKeyMultisigThreshold(k int, pubkeys []crypto.PubKey) crypto.PubKey {
 	if len(pubkeys) < k {
 		panic("threshold k of n multisignature: len(pubkeys) < k")
 	}
-	return PubKeyMultisigThreshold{uint(k), pubkeys}
+	return &PubKeyMultisigThreshold{uint(k), pubkeys}
 }
 
 // VerifyBytes expects sig to be an amino encoded version of a MultiSignature.
@@ -30,8 +31,8 @@ func NewPubKeyMultisigThreshold(k int, pubkeys []crypto.PubKey) crypto.PubKey {
 // and all signatures are valid. (Not just k of the signatures)
 // The multisig uses a bitarray, so multiple signatures for the same key is not
 // a concern.
-func (pk PubKeyMultisigThreshold) VerifyBytes(msg []byte, marshalledSig []byte) bool {
-	var sig Multisignature
+func (pk *PubKeyMultisigThreshold) VerifyBytes(msg []byte, marshalledSig []byte) bool {
+	var sig *Multisignature
 	err := cdc.UnmarshalBinaryBare(marshalledSig, &sig)
 	if err != nil {
 		return false
@@ -63,19 +64,19 @@ func (pk PubKeyMultisigThreshold) VerifyBytes(msg []byte, marshalledSig []byte)
 }
 
 // Bytes returns the amino encoded version of the PubKeyMultisigThreshold
-func (pk PubKeyMultisigThreshold) Bytes() []byte {
+func (pk *PubKeyMultisigThreshold) Bytes() []byte {
 	return cdc.MustMarshalBinaryBare(pk)
 }
 
 // Address returns tmhash(PubKeyMultisigThreshold.Bytes())
-func (pk PubKeyMultisigThreshold) Address() crypto.Address {
-	return crypto.AddressHash(pk.Bytes())
+func (pk *PubKeyMultisigThreshold) Address() crypto.Address {
+	return crypto.Address(tmhash.Sum(pk.Bytes()))
 }
 
 // Equals returns true iff pk and other both have the same number of keys, and
 // all constituent keys are the same, and in the same order.
-func (pk PubKeyMultisigThreshold) Equals(other crypto.PubKey) bool {
-	otherKey, sameType := other.(PubKeyMultisigThreshold)
+func (pk *PubKeyMultisigThreshold) Equals(other crypto.PubKey) bool {
+	otherKey, sameType := other.(*PubKeyMultisigThreshold)
 	if !sameType {
 		return false
 	}

crypto/multisig/threshold_pubkey_test.go

@@ -82,7 +82,7 @@ func TestMultiSigPubKeyEquality(t *testing.T) {
 	msg := []byte{1, 2, 3, 4}
 	pubkeys, _ := generatePubKeysAndSignatures(5, msg)
 	multisigKey := NewPubKeyMultisigThreshold(2, pubkeys)
-	var unmarshalledMultisig PubKeyMultisigThreshold
+	var unmarshalledMultisig *PubKeyMultisigThreshold
 	cdc.MustUnmarshalBinaryBare(multisigKey.Bytes(), &unmarshalledMultisig)
 	require.True(t, multisigKey.Equals(unmarshalledMultisig))
 
@@ -95,29 +95,6 @@ func TestMultiSigPubKeyEquality(t *testing.T) {
 	require.False(t, multisigKey.Equals(multisigKey2))
 }
 
-func TestAddress(t *testing.T) {
-	msg := []byte{1, 2, 3, 4}
-	pubkeys, _ := generatePubKeysAndSignatures(5, msg)
-	multisigKey := NewPubKeyMultisigThreshold(2, pubkeys)
-	require.Len(t, multisigKey.Address().Bytes(), 20)
-}
-
-func TestPubKeyMultisigThresholdAminoToIface(t *testing.T) {
-	msg := []byte{1, 2, 3, 4}
-	pubkeys, _ := generatePubKeysAndSignatures(5, msg)
-	multisigKey := NewPubKeyMultisigThreshold(2, pubkeys)
-
-	ab, err := cdc.MarshalBinaryLengthPrefixed(multisigKey)
-	require.NoError(t, err)
-	// like other crypto.Pubkey implementations (e.g. ed25519.PubKeyEd25519),
-	// PubKeyMultisigThreshold should be deserializable into a crypto.PubKey:
-	var pubKey crypto.PubKey
-	err = cdc.UnmarshalBinaryLengthPrefixed(ab, &pubKey)
-	require.NoError(t, err)
-
-	require.Equal(t, multisigKey, pubKey)
-}
-
 func generatePubKeysAndSignatures(n int, msg []byte) (pubkeys []crypto.PubKey, signatures [][]byte) {
 	pubkeys = make([]crypto.PubKey, n)
 	signatures = make([][]byte, n)

crypto/multisig/wire.go

@@ -20,7 +20,7 @@ func init() {
 	cdc.RegisterConcrete(PubKeyMultisigThreshold{},
 		PubKeyMultisigThresholdAminoRoute, nil)
 	cdc.RegisterConcrete(ed25519.PubKeyEd25519{},
-		ed25519.PubKeyAminoName, nil)
+		ed25519.PubKeyAminoRoute, nil)
 	cdc.RegisterConcrete(secp256k1.PubKeySecp256k1{},
-		secp256k1.PubKeyAminoName, nil)
+		secp256k1.PubKeyAminoRoute, nil)
 }

crypto/secp256k1/secp256k1.go

@@ -9,15 +9,15 @@ import (
 
 	secp256k1 "github.com/tendermint/btcd/btcec"
 	amino "github.com/tendermint/go-amino"
-	"golang.org/x/crypto/ripemd160"
+	"golang.org/x/crypto/ripemd160" // forked to github.com/tendermint/crypto
 
 	"github.com/tendermint/tendermint/crypto"
 )
 
 //-------------------------------------
 const (
-	PrivKeyAminoName = "tendermint/PrivKeySecp256k1"
-	PubKeyAminoName  = "tendermint/PubKeySecp256k1"
+	PrivKeyAminoRoute = "tendermint/PrivKeySecp256k1"
+	PubKeyAminoRoute  = "tendermint/PubKeySecp256k1"
 )
 
 var cdc = amino.NewCodec()
@@ -25,11 +25,11 @@ var cdc = amino.NewCodec()
 func init() {
 	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
 	cdc.RegisterConcrete(PubKeySecp256k1{},
-		PubKeyAminoName, nil)
+		PubKeyAminoRoute, nil)
 
 	cdc.RegisterInterface((*crypto.PrivKey)(nil), nil)
 	cdc.RegisterConcrete(PrivKeySecp256k1{},
-		PrivKeyAminoName, nil)
+		PrivKeyAminoRoute, nil)
 }
 
 //-------------------------------------

crypto/xchacha20poly1305/xchachapoly.go

@@ -8,7 +8,7 @@ import (
 	"errors"
 	"fmt"
 
-	"golang.org/x/crypto/chacha20poly1305"
+	"golang.org/x/crypto/chacha20poly1305" // forked to github.com/tendermint/crypto
 )
 
 // Implements crypto.AEAD

crypto/xsalsa20symmetric/symmetric.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"fmt"
 
-	"golang.org/x/crypto/nacl/secretbox"
+	"golang.org/x/crypto/nacl/secretbox" // forked to github.com/tendermint/crypto
 
 	"github.com/tendermint/tendermint/crypto"
 	cmn "github.com/tendermint/tendermint/libs/common"

crypto/xsalsa20symmetric/symmetric_test.go

@@ -6,7 +6,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"golang.org/x/crypto/bcrypt"
+	"golang.org/x/crypto/bcrypt" // forked to github.com/tendermint/crypto
 
 	"github.com/tendermint/tendermint/crypto"
 )
@@ -30,7 +30,9 @@ func TestSimpleWithKDF(t *testing.T) {
 
 	plaintext := []byte("sometext")
 	secretPass := []byte("somesecret")
-	secret, err := bcrypt.GenerateFromPassword(secretPass, 12)
+	salt := []byte("somesaltsomesalt") // len 16
+	// NOTE: we use a fork of x/crypto so we can inject our own randomness for salt
+	secret, err := bcrypt.GenerateFromPassword(salt, secretPass, 12)
 	if err != nil {
 		t.Error(err)
 	}

docs/.vuepress/config.js

@@ -8,21 +8,8 @@ module.exports = {
     lineNumbers: true
   },
   themeConfig: {
-    repo: "tendermint/tendermint",
-    editLinks: true,
-    docsDir: "docs",
-    docsBranch: "develop",
-    editLinkText: 'Edit this page on Github',
-    lastUpdated: true,
-    algolia: {
-      apiKey: '59f0e2deb984aa9cdf2b3a5fd24ac501',
-      indexName: 'tendermint',
-      debug: false
-    },
-    nav: [
-      { text: "Back to Tendermint", link: "https://tendermint.com" },
-      { text: "RPC", link: "../rpc/" }
-    ],
+    lastUpdated: "Last Updated",
+    nav: [{ text: "Back to Tendermint", link: "https://tendermint.com" }],
     sidebar: [
       {
         title: "Introduction",
@@ -34,20 +21,6 @@ module.exports = {
           "/introduction/what-is-tendermint"
         ]
       },
-      {
-        title: "Apps",
-        collapsable: false,
-        children: [
-          "/app-dev/getting-started",
-          "/app-dev/abci-cli",
-          "/app-dev/app-architecture",
-          "/app-dev/app-development",
-          "/app-dev/subscribing-to-events-via-websocket",
-          "/app-dev/indexing-transactions",
-          "/app-dev/abci-spec",
-          "/app-dev/ecosystem"
-        ]
-      },
       {
         title: "Tendermint Core",
         collapsable: false,
@@ -66,6 +39,15 @@ module.exports = {
           "/tendermint-core/validators"
         ]
       },
+      {
+        title: "Tools",
+        collapsable: false,
+        children:  [
+	  "/tools/",
+	  "/tools/benchmarking",
+	  "/tools/monitoring"
+	]
+      },
       {
         title: "Networks",
         collapsable: false,
@@ -76,13 +58,18 @@ module.exports = {
         ]
       },
       {
-        title: "Tools",
+        title: "Apps",
         collapsable: false,
-        children:  [
-	  "/tools/",
-	  "/tools/benchmarking",
-	  "/tools/monitoring"
-	]
+        children: [
+          "/app-dev/getting-started",
+          "/app-dev/abci-cli",
+          "/app-dev/app-architecture",
+          "/app-dev/app-development",
+          "/app-dev/subscribing-to-events-via-websocket",
+          "/app-dev/indexing-transactions",
+          "/app-dev/abci-spec",
+          "/app-dev/ecosystem"
+        ]
       },
       {
         title: "Tendermint Spec",

docs/DOCS_README.md

@@ -12,10 +12,10 @@ respectively.
 
 ## How It Works
 
-There is a CircleCI job listening for changes in the `/docs` directory, on both
+There is a Jenkins job listening for changes in the `/docs` directory, on both
 the  `master` and `develop` branches. Any updates to files in this directory
 on those branches will automatically trigger a website deployment. Under the hood,
-the private website repository has a `make build-docs` target consumed by a CircleCI job in that repo.
+a private website repository has make targets consumed by a standard Jenkins task.
 
 ## README
 
@@ -93,10 +93,6 @@ python -m SimpleHTTPServer 8080
 
 then navigate to localhost:8080 in your browser.
 
-## Search
-
-We are using [Algolia](https://www.algolia.com) to power full-text search. This uses a public API search-only key in the `config.js` as well as a [tendermint.json](https://github.com/algolia/docsearch-configs/blob/master/configs/tendermint.json) configuration file that we can update with PRs.
-
 ## Consistency
 
 Because the build processes are identical (as is the information contained herein), this file should be kept in sync as

docs/app-dev/app-architecture.md

@@ -5,7 +5,7 @@ Tendermint blockchain application.
 
 The following diagram provides a superb example:
 
-![](../imgs/cosmos-tendermint-stack-4k.jpg)
+<https://drive.google.com/open?id=1yR2XpRi9YCY9H9uMfcw8-RMJpvDyvjz9>
 
 The end-user application here is the Cosmos Voyager, at the bottom left.
 Voyager communicates with a REST API exposed by a local Light-Client

docs/app-dev/ecosystem.json

@@ -181,13 +181,5 @@
       "language": "Javascript",
       "author": "Dennis McKinnon"
     }
-  ],
-  "aminoLibraries": [
-    {
-      "name": "JS-Amino",
-      "url": "https://github.com/TanNgocDo/Js-Amino",
-      "language": "Javascript",
-      "author": "TanNgocDo"
-    }
   ]
 }

docs/app-dev/ecosystem.md

@@ -1,9 +1,11 @@
 # Ecosystem
 
 The growing list of applications built using various pieces of the
-Tendermint stack can be found at the [ecosystem page](https://tendermint.com/ecosystem).
+Tendermint stack can be found at:
 
-We thank the community for their contributions and welcome the
+- https://tendermint.com/ecosystem
+
+We thank the community for their contributions thus far and welcome the
 addition of new projects. A pull request can be submitted to [this
 file](https://github.com/tendermint/tendermint/blob/master/docs/app-dev/ecosystem.json)
 to include your project.

docs/architecture/adr-030-consensus-refactor.md

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

docs/introduction/what-is-tendermint.md

@@ -70,6 +70,10 @@ Tendermint is in essence similar software, but with two key differences:
   the application logic that's right for them, from key-value store to
   cryptocurrency to e-voting platform and beyond.
 
+The layout of this Tendermint website content is also ripped directly
+and without shame from [consul.io](https://www.consul.io/) and the other
+[Hashicorp sites](https://www.hashicorp.com/#tools).
+
 ### Bitcoin, Ethereum, etc.
 
 Tendermint emerged in the tradition of cryptocurrencies like Bitcoin,

docs/networks/docker-compose.md

@@ -1,17 +1,20 @@
 # Docker Compose
 
-With Docker Compose, you can spin up local testnets with a single command.
+With Docker Compose, we can spin up local testnets in a single command:
+
+```
+make localnet-start
+```
 
 ## Requirements
 
-1. [Install tendermint](/docs/install.md)
-2. [Install docker](https://docs.docker.com/engine/installation/)
-3. [Install docker-compose](https://docs.docker.com/compose/install/)
+- [Install tendermint](/docs/install.md)
+- [Install docker](https://docs.docker.com/engine/installation/)
+- [Install docker-compose](https://docs.docker.com/compose/install/)
 
 ## Build
 
-Build the `tendermint` binary and, optionally, the `tendermint/localnode`
-docker image.
+Build the `tendermint` binary and the `tendermint/localnode` docker image.
 
 Note the binary will be mounted into the container so it can be updated without
 rebuilding the image.
@@ -22,10 +25,11 @@ cd $GOPATH/src/github.com/tendermint/tendermint
 # Build the linux binary in ./build
 make build-linux
 
-# (optionally) Build tendermint/localnode image
+# Build tendermint/localnode image
 make build-docker-localnode
 ```
 
+
 ## Run a testnet
 
 To start a 4 node testnet run:
@@ -34,13 +38,9 @@ To start a 4 node testnet run:
 make localnet-start
 ```
 
-The nodes bind their RPC servers to ports 26657, 26660, 26662, and 26664 on the
-host.
-
+The nodes bind their RPC servers to ports 26657, 26660, 26662, and 26664 on the host.
 This file creates a 4-node network using the localnode image.
-
-The nodes of the network expose their P2P and RPC endpoints to the host machine
-on ports 26656-26657, 26659-26660, 26661-26662, and 26663-26664 respectively.
+The nodes of the network expose their P2P and RPC endpoints to the host machine on ports 26656-26657, 26659-26660, 26661-26662, and 26663-26664 respectively.
 
 To update the binary, just rebuild it and restart the nodes:
 
@@ -52,40 +52,34 @@ make localnet-start
 
 ## Configuration
 
-The `make localnet-start` creates files for a 4-node testnet in `./build` by
-calling the `tendermint testnet` command.
+The `make localnet-start` creates files for a 4-node testnet in `./build` by calling the `tendermint testnet` command.
 
-The `./build` directory is mounted to the `/tendermint` mount point to attach
-the binary and config files to the container.
+The `./build` directory is mounted to the `/tendermint` mount point to attach the binary and config files to the container.
 
-To change the number of validators / non-validators change the `localnet-start` Makefile target:
-
-```
-localnet-start: localnet-stop
-	@if ! [ -f build/node0/config/genesis.json ]; then docker run --rm -v $(CURDIR)/build:/tendermint:Z tendermint/localnode testnet --v 5 --n 3 --o . --populate-persistent-peers --starting-ip-address 192.167.10.2 ; fi
-	docker-compose up
-```
-
-The command now will generate config files for 5 validators and 3
-non-validators network.
-
-Before running it, don't forget to cleanup the old files:
+For instance, to create a single node testnet:
 
 ```
 cd $GOPATH/src/github.com/tendermint/tendermint
 
 # Clear the build folder
-rm -rf ./build/node*
+rm -rf ./build
+
+# Build binary
+make build-linux
+
+# Create configuration
+docker run -e LOG="stdout" -v `pwd`/build:/tendermint tendermint/localnode testnet --o . --v 1
+
+#Run the node
+docker run -v `pwd`/build:/tendermint tendermint/localnode
+
 ```
 
 ## Logging
 
-Log is saved under the attached volume, in the `tendermint.log` file. If the
-`LOG` environment variable is set to `stdout` at start, the log is not saved,
-but printed on the screen.
+Log is saved under the attached volume, in the `tendermint.log` file. If the `LOG` environment variable is set to `stdout` at start, the log is not saved, but printed on the screen.
 
 ## Special binaries
 
-If you have multiple binaries with different names, you can specify which one
-to run with the `BINARY` environment variable. The path of the binary is relative
-to the attached volume.
+If you have multiple binaries with different names, you can specify which one to run with the BINARY environment variable. The path of the binary is relative to the attached volume.
+

docs/package.json

@@ -0,0 +1,40 @@
+{
+  "dependencies": {
+    "prettier": "^1.13.7",
+    "remark-cli": "^5.0.0",
+    "remark-lint-no-dead-urls": "^0.3.0",
+    "remark-lint-write-good": "^1.0.3",
+    "textlint": "^10.2.1",
+    "textlint-rule-stop-words": "^1.0.3"
+  },
+  "name": "tendermint",
+  "description": "Tendermint Core Documentation",
+  "version": "0.0.1",
+  "main": "README.md",
+  "devDependencies": {},
+  "scripts": {
+    "lint:json": "prettier \"**/*.json\" --write",
+    "lint:md": "prettier \"**/*.md\" --write && remark . && textlint \"md/**\"",
+    "lint": "yarn lint:json && yarn lint:md"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tendermint/tendermint.git"
+  },
+  "keywords": [
+    "tendermint",
+    "blockchain"
+  ],
+  "author": "Tendermint",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/tendermint/tendermint/issues"
+  },
+  "homepage": "https://tendermint.com/docs/",
+  "remarkConfig": {
+    "plugins": [
+      "remark-lint-no-dead-urls",
+      "remark-lint-write-good"
+    ]
+  }
+}

docs/spec/README.md

@@ -14,31 +14,31 @@ please submit them to our [bug bounty](https://tendermint.com/security)!
 
 ### Data Structures
 
-- [Encoding and Digests](./blockchain/encoding.md)
-- [Blockchain](./blockchain/blockchain.md)
-- [State](./blockchain/state.md)
+- [Encoding and Digests](https://github.com/tendermint/tendermint/blob/master/docs/spec/blockchain/encoding.md)
+- [Blockchain](https://github.com/tendermint/tendermint/blob/master/docs/spec/blockchain/blockchain.md)
+- [State](https://github.com/tendermint/tendermint/blob/master/docs/spec/blockchain/state.md)
 
 ### Consensus Protocol
 
-- [Consensus Algorithm](./consensus/consensus.md)
-- [Creating a proposal](./consensus/creating-proposal.md)
-- [Time](./consensus/bft-time.md)
-- [Light-Client](./consensus/light-client.md)
+- [Consensus Algorithm](/docs/spec/consensus/consensus.md)
+- [Creating a proposal](/docs/spec/consensus/creating-proposal.md)
+- [Time](/docs/spec/consensus/bft-time.md)
+- [Light-Client](/docs/spec/consensus/light-client.md)
 
 ### P2P and Network Protocols
 
-- [The Base P2P Layer](./p2p/): multiplex the protocols ("reactors") on authenticated and encrypted TCP connections
-- [Peer Exchange (PEX)](./reactors/pex/): gossip known peer addresses so peers can find each other
-- [Block Sync](./reactors/block_sync/): gossip blocks so peers can catch up quickly
-- [Consensus](./reactors/consensus/): gossip votes and block parts so new blocks can be committed
-- [Mempool](./reactors/mempool/): gossip transactions so they get included in blocks
-- [Evidence](./reactors/evidence/): sending invalid evidence will stop the peer
+- [The Base P2P Layer](https://github.com/tendermint/tendermint/tree/master/docs/spec/p2p): multiplex the protocols ("reactors") on authenticated and encrypted TCP connections
+- [Peer Exchange (PEX)](https://github.com/tendermint/tendermint/tree/master/docs/spec/reactors/pex): gossip known peer addresses so peers can find each other
+- [Block Sync](https://github.com/tendermint/tendermint/tree/master/docs/spec/reactors/block_sync): gossip blocks so peers can catch up quickly
+- [Consensus](https://github.com/tendermint/tendermint/tree/master/docs/spec/reactors/consensus): gossip votes and block parts so new blocks can be committed
+- [Mempool](https://github.com/tendermint/tendermint/tree/master/docs/spec/reactors/mempool): gossip transactions so they get included in blocks
+- Evidence: Forthcoming, see [this issue](https://github.com/tendermint/tendermint/issues/2329).
 
 ### Software
 
-- [ABCI](./software/abci.md): Details about interactions between the
+- [ABCI](/docs/spec/software/abci.md): Details about interactions between the
   application and consensus engine over ABCI
-- [Write-Ahead Log](./software/wal.md): Details about how the consensus
+- [Write-Ahead Log](/docs/spec/software/wal.md): Details about how the consensus
   engine preserves data and recovers from crash failures
 
 ## Overview

docs/spec/abci/apps.md

@@ -407,22 +407,21 @@ If `storeBlockHeight == stateBlockHeight && appBlockHeight < storeBlockHeight`,
 replay all blocks in full from `appBlockHeight` to `storeBlockHeight`.
 This happens if we completed processing the block, but the app forgot its height.
 
-If `storeBlockHeight == stateBlockHeight && appBlockHeight == storeBlockHeight`, we're done.
+If `storeBlockHeight == stateBlockHeight && appBlockHeight == storeBlockHeight`, we're done
 This happens if we crashed at an opportune spot.
 
 If `storeBlockHeight == stateBlockHeight+1`
 This happens if we started processing the block but didn't finish.
 
-If `appBlockHeight < stateBlockHeight`
-    replay all blocks in full from `appBlockHeight` to `storeBlockHeight-1`,
-    and replay the block at `storeBlockHeight` using the WAL.
-This happens if the app forgot the last block it committed.
+    If `appBlockHeight < stateBlockHeight`
+    	replay all blocks in full from `appBlockHeight` to `storeBlockHeight-1`,
+    	and replay the block at `storeBlockHeight` using the WAL.
+    This happens if the app forgot the last block it committed.
 
-If `appBlockHeight == stateBlockHeight`,
-    replay the last block (storeBlockHeight) in full.
-This happens if we crashed before the app finished Commit
-
-If `appBlockHeight == storeBlockHeight`
-    update the state using the saved ABCI responses but dont run the block against the real app.
-This happens if we crashed after the app finished Commit but before Tendermint saved the state.
+    If `appBlockHeight == stateBlockHeight`,
+    	replay the last block (storeBlockHeight) in full.
+    This happens if we crashed before the app finished Commit
 
+    If appBlockHeight == storeBlockHeight {
+    	update the state using the saved ABCI responses but dont run the block against the real app.
+    This happens if we crashed after the app finished Commit but before Tendermint saved the state.

docs/spec/blockchain/blockchain.md

@@ -230,7 +230,7 @@ The block version must match the state version.
 len(block.ChainID) < 50
 ```
 
-ChainID must be less than 50 bytes.
+ChainID must be maximum 50 UTF-8 symbols.
 
 ### Height
 

docs/spec/consensus/signing.md

@@ -1,205 +0,0 @@
-# Validator Signing
-
-Here we specify the rules for validating a proposal and vote before signing.
-First we include some general notes on validating data structures common to both types.
-We then provide specific validation rules for each. Finally, we include validation rules to prevent double-sigining.
-
-## SignedMsgType
-
-The `SignedMsgType` is a single byte that refers to the type of the message
-being signed. It is defined in Go as follows:
-
-```
-// SignedMsgType is a type of signed message in the consensus.
-type SignedMsgType byte
-
-const (
-	// Votes
-	PrevoteType   SignedMsgType = 0x01
-	PrecommitType SignedMsgType = 0x02
-
-	// Proposals
-	ProposalType SignedMsgType = 0x20
-)
-```
-
-All signed messages must correspond to one of these types.
-
-## Timestamp
-
-Timestamp validation is subtle and there are currently no bounds placed on the
-timestamp included in a proposal or vote. It is expected that validators will honestly
-report their local clock time. The median of all timestamps
-included in a commit is used as the timestamp for the next block height.
-
-Timestamps are expected to be strictly monotonic for a given validator, though
-this is not currently enforced.
-
-## ChainID
-
-ChainID is an unstructured string with a max length of 50-bytes.
-In the future, the ChainID may become structured, and may take on longer lengths.
-For now, it is recommended that signers be configured for a particular ChainID,
-and to only sign votes and proposals corresponding to that ChainID.
-
-## BlockID
-
-BlockID is the structure used to represent the block:
-
-```
-type BlockID struct {
-	Hash        []byte
-	PartsHeader PartSetHeader
-}
-
-type PartSetHeader struct {
-	Hash  []byte
-	Total int
-}
-```
-
-To be included in a valid vote or proposal, BlockID must either represent a `nil` block, or a complete one.
-We introduce two methods, `BlockID.IsNil()` and `BlockID.IsComplete()` for these cases, respectively.
-
-`BlockID.IsNil()` returns true for BlockID `b` if each of the following
-are true:
-
-```
-b.Hash == nil
-b.PartsHeader.Total == 0
-b.PartsHeader.Hash == nil
-```
-
-`BlockID.IsComplete()` returns true for BlockID `b` if each of the following
-are true:
-
-```
-len(b.Hash) == 32
-b.PartsHeader.Total > 0
-len(b.PartsHeader.Hash) == 32
-```
-
-## Proposals
-
-The structure of a propsal for signing looks like:
-
-```
-type CanonicalProposal struct {
-	Type      SignedMsgType // type alias for byte
-	Height    int64         `binary:"fixed64"`
-	Round     int64         `binary:"fixed64"`
-	POLRound  int64         `binary:"fixed64"`
-	BlockID   BlockID
-	Timestamp time.Time
-	ChainID   string
-}
-```
-
-A proposal is valid if each of the following lines evaluates to true for proposal `p`:
-
-```
-p.Type == 0x20
-p.Height > 0
-p.Round >= 0
-p.POLRound >= -1
-p.BlockID.IsComplete()
-```
-
-In other words, a proposal is valid for signing if it contains the type of a Proposal
-(0x20), has a positive, non-zero height, a
-non-negative round, a POLRound not less than -1, and a complete BlockID.
-
-## Votes
-
-The structure of a vote for signing looks like:
-
-```
-type CanonicalVote struct {
-	Type      SignedMsgType // type alias for byte
-	Height    int64         `binary:"fixed64"`
-	Round     int64         `binary:"fixed64"`
-	Timestamp time.Time
-	BlockID   BlockID
-	ChainID   string
-}
-```
-
-A vote is valid if each of the following lines evaluates to true for vote `v`:
-
-```
-v.Type == 0x1 || v.Type == 0x2
-v.Height > 0
-v.Round >= 0
-v.BlockID.IsNil() || v.BlockID.IsValid()
-```
-
-In other words, a vote is valid for signing if it contains the type of a Prevote
-or Precommit (0x1 or 0x2, respectively), has a positive, non-zero height, a
-non-negative round, and an empty or valid BlockID.
-
-## Invalid Votes and Proposals
-
-Votes and proposals which do not satisfy the above rules are considered invalid.
-Peers gossipping invalid votes and proposals may be disconnected from other peers on the network.
-Note, however, that there is not currently any explicit mechanism to punish validators signing votes or proposals that fail
-these basic validation rules.
-
-## Double Signing
-
-Signers must be careful not to sign conflicting messages, also known as "double signing" or "equivocating".
-Tendermint has mechanisms to publish evidence of validators that signed conflicting votes, so they can be punished
-by the application. Note Tendermint does not currently handle evidence of conflciting proposals, though it may in the future.
-
-### State
-
-To prevent such double signing, signers must track the height, round, and type of the last message signed.
-Assume the signer keeps the following state, `s`:
-
-```
-type LastSigned struct {
-	Height	int64
-	Round	int64
-	Type	SignedMsgType // byte
-}
-```
-
-After signing a vote or proposal `m`, the signer sets:
-
-```
-s.Height = m.Height
-s.Round = m.Round
-s.Type = m.Type
-```
-
-### Proposals
-
-A signer should only sign a proposal `p` if any of the following lines are true:
-
-```
-p.Height > s.Height
-p.Height == s.Height && p.Round > s.Round
-```
-
-In other words, a proposal should only be signed if it's at a higher height, or a higher round for the same height.
-Once a proposal or vote has been signed for a given height and round, a proposal should never be signed for the same height and round.
-
-### Votes
-
-A signer should only sign a vote `v` if any of the following lines are true:
-
-```
-v.Height > s.Height
-v.Height == s.Height && v.Round > s.Round
-v.Height == s.Height && v.Round == s.Round && v.Step == 0x1 && s.Step == 0x20
-v.Height == s.Height && v.Round == s.Round && v.Step == 0x2 && s.Step != 0x2
-```
-
-In other words, a vote should only be signed if it's:
-
-- at a higher height
-- at a higher round for the same height
-- a prevote for the same height and round where we haven't signed a prevote or precommit (but have signed a proposal)
-- a precommit for the same height and round where we haven't signed a precommit (but have signed a proposal and/or a prevote)
-
-This means that once a validator signs a prevote for a given height and round, the only other message it can sign for that height and round is a precommit.
-And once a validator signs a precommit for a given height and round, it must not sign any other message for that same height and round.

docs/tendermint-core/configuration.md

@@ -36,26 +36,22 @@ db_backend = "leveldb"
 # Database directory
 db_dir = "data"
 
-# Output level for logging, including package level options
-log_level = "main:info,state:info,*:error"
+# Output level for logging
+log_level = "state:info,*:error"
 
 # Output format: 'plain' (colored text) or 'json'
 log_format = "plain"
 
 ##### additional base config options #####
 
+# The ID of the chain to join (should be signed with every transaction and vote)
+chain_id = ""
+
 # Path to the JSON file containing the initial validator set and other meta data
-genesis_file = "config/genesis.json"
+genesis_file = "genesis.json"
 
 # Path to the JSON file containing the private key to use as a validator in the consensus protocol
-priv_validator_file = "config/priv_validator.json"
-
-# TCP or UNIX socket address for Tendermint to listen on for
-# connections from an external PrivValidator process
-priv_validator_laddr = ""
-
-# Path to the JSON file containing the private key to use for node authentication in the p2p protocol
-node_key_file = "config/node_key.json"
+priv_validator_file = "priv_validator.json"
 
 # Mechanism to connect to the ABCI application: socket | grpc
 abci = "socket"
@@ -78,13 +74,13 @@ laddr = "tcp://0.0.0.0:26657"
 # A list of origins a cross-domain request can be executed from
 # Default value '[]' disables cors support
 # Use '["*"]' to allow any origin
-cors_allowed_origins = []
+cors_allowed_origins = "[]"
 
 # A list of methods the client is allowed to use with cross-domain requests
-cors_allowed_methods = ["HEAD", "GET", "POST"]
+cors_allowed_methods = "[HEAD GET POST]"
 
 # A list of non simple headers the client is allowed to use with cross-domain requests
-cors_allowed_headers = ["Origin", "Accept", "Content-Type", "X-Requested-With", "X-Server-Time"]
+cors_allowed_headers = "[Origin Accept Content-Type X-Requested-With X-Server-Time]"
 
 # TCP or UNIX socket address for the gRPC server to listen on
 # NOTE: This server only supports /broadcast_tx_commit
@@ -92,7 +88,7 @@ grpc_laddr = ""
 
 # Maximum number of simultaneous connections.
 # Does not include RPC (HTTP&WebSocket) connections. See max_open_connections
-# If you want to accept a larger number than the default, make sure
+# If you want to accept more significant number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
 # Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
@@ -104,7 +100,7 @@ unsafe = false
 
 # Maximum number of simultaneous connections (including WebSocket).
 # Does not include gRPC connections. See grpc_max_open_connections
-# If you want to accept a larger number than the default, make sure
+# If you want to accept more significant number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
 # Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
@@ -117,12 +113,6 @@ max_open_connections = 900
 # Address to listen for incoming connections
 laddr = "tcp://0.0.0.0:26656"
 
-# Address to advertise to peers for them to dial
-# If empty, will use the same port as the laddr,
-# and will introspect on the listener or use UPnP
-# to figure out the address.
-external_address = ""
-
 # Comma separated list of seed nodes to connect to
 seeds = ""
 
@@ -133,7 +123,7 @@ persistent_peers = ""
 upnp = false
 
 # Path to address book
-addr_book_file = "config/addrbook.json"
+addr_book_file = "addrbook.json"
 
 # Set true for strict address routability rules
 # Set false for private or local networks
@@ -170,7 +160,7 @@ seed_mode = false
 private_peer_ids = ""
 
 # Toggle to disable guard against peers connecting from the same ip.
-allow_duplicate_ip = false
+allow_duplicate_ip = true
 
 # Peer connection configuration.
 handshake_timeout = "20s"
@@ -181,26 +171,26 @@ dial_timeout = "3s"
 
 recheck = true
 broadcast = true
-wal_dir = ""
+wal_dir = "data/mempool.wal"
 
 # size of the mempool
-size = 5000
+size = 100000
 
 # size of the cache (used to filter transactions we saw earlier)
-cache_size = 10000
+cache_size = 100000
 
 ##### consensus configuration options #####
 [consensus]
 
 wal_file = "data/cs.wal/wal"
 
-timeout_propose = "3s"
+timeout_propose = "3000ms"
 timeout_propose_delta = "500ms"
-timeout_prevote = "1s"
+timeout_prevote = "1000ms"
 timeout_prevote_delta = "500ms"
-timeout_precommit = "1s"
+timeout_precommit = "1000ms"
 timeout_precommit_delta = "500ms"
-timeout_commit = "1s"
+timeout_commit = "1000ms"
 
 # Make progress as soon as we have all the precommits (as if TimeoutCommit = 0)
 skip_timeout_commit = false
@@ -211,10 +201,10 @@ create_empty_blocks_interval = "0s"
 
 # Reactor sleep duration parameters
 peer_gossip_sleep_duration = "100ms"
-peer_query_maj23_sleep_duration = "2s"
+peer_query_maj23_sleep_duration = "2000ms"
 
 # Block time parameters. Corresponds to the minimum time increment between consecutive blocks.
-blocktime_iota = "1s"
+blocktime_iota = "1000ms"
 
 ##### transactions indexer configuration options #####
 [tx_index]
@@ -255,7 +245,7 @@ prometheus = false
 prometheus_listen_addr = ":26660"
 
 # Maximum number of simultaneous connections.
-# If you want to accept a larger number than the default, make sure
+# If you want to accept a more significant number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
 max_open_connections = 3

docs/tendermint-core/using-tendermint.md

@@ -113,7 +113,7 @@ blocks are produced regularly, even if there are no transactions. See
 _No Empty Blocks_, below, to modify this setting.
 
 Tendermint supports in-process versions of the `counter`, `kvstore` and
-`noop` apps that ship as examples with `abci-cli`. It's easy to compile
+`nil` apps that ship as examples with `abci-cli`. It's easy to compile
 your own app in-process with Tendermint if it's written in Go. If your
 app is not written in Go, simply run it in another process, and use the
 `--proxy_app` flag to specify the address of the socket it is listening

libs/log/testing_logger.go

@@ -1,7 +1,6 @@
 package log
 
 import (
-	"io"
 	"os"
 	"testing"
 
@@ -20,22 +19,12 @@ var (
 // inside a test (not in the init func) because
 // verbose flag only set at the time of testing.
 func TestingLogger() Logger {
-	return TestingLoggerWithOutput(os.Stdout)
-}
-
-// TestingLoggerWOutput returns a TMLogger which writes to (w io.Writer) if testing being run
-// with the verbose (-v) flag, NopLogger otherwise.
-//
-// Note that the call to TestingLoggerWithOutput(w io.Writer) must be made
-// inside a test (not in the init func) because
-// verbose flag only set at the time of testing.
-func TestingLoggerWithOutput(w io.Writer) Logger {
 	if _testingLogger != nil {
 		return _testingLogger
 	}
 
 	if testing.Verbose() {
-		_testingLogger = NewTMLogger(NewSyncWriter(w))
+		_testingLogger = NewTMLogger(NewSyncWriter(os.Stdout))
 	} else {
 		_testingLogger = NewNopLogger()
 	}

mempool/mempool.go

@@ -108,10 +108,6 @@ func PostCheckMaxGas(maxGas int64) PostCheckFunc {
 		if maxGas == -1 {
 			return nil
 		}
-		if res.GasWanted < 0 {
-			return fmt.Errorf("gas wanted %d is negative",
-				res.GasWanted)
-		}
 		if res.GasWanted > maxGas {
 			return fmt.Errorf("gas wanted %d is greater than max gas %d",
 				res.GasWanted, maxGas)
@@ -490,15 +486,11 @@ func (mem *Mempool) ReapMaxBytesMaxGas(maxBytes, maxGas int64) types.Txs {
 			return txs
 		}
 		totalBytes += int64(len(memTx.tx)) + aminoOverhead
-		// Check total gas requirement.
-		// If maxGas is negative, skip this check.
-		// Since newTotalGas < masGas, which
-		// must be non-negative, it follows that this won't overflow.
-		newTotalGas := totalGas + memTx.gasWanted
-		if maxGas > -1 && newTotalGas > maxGas {
+		// Check total gas requirement
+		if maxGas > -1 && totalGas+memTx.gasWanted > maxGas {
 			return txs
 		}
-		totalGas = newTotalGas
+		totalGas += memTx.gasWanted
 		txs = append(txs, memTx.tx)
 	}
 	return txs
@@ -556,18 +548,13 @@ func (mem *Mempool) Update(
 	// Remove committed transactions.
 	txsLeft := mem.removeTxs(txs)
 
-	// Either recheck non-committed txs to see if they became invalid
-	// or just notify there're some txs left.
-	if len(txsLeft) > 0 {
-		if mem.config.Recheck {
-			mem.logger.Info("Recheck txs", "numtxs", len(txsLeft), "height", height)
-			mem.recheckTxs(txsLeft)
-			// At this point, mem.txs are being rechecked.
-			// mem.recheckCursor re-scans mem.txs and possibly removes some txs.
-			// Before mem.Reap(), we should wait for mem.recheckCursor to be nil.
-		} else {
-			mem.notifyTxsAvailable()
-		}
+	// Recheck mempool txs if any txs were committed in the block
+	if mem.config.Recheck && len(txsLeft) > 0 {
+		mem.logger.Info("Recheck txs", "numtxs", len(txsLeft), "height", height)
+		mem.recheckTxs(txsLeft)
+		// At this point, mem.txs are being rechecked.
+		// mem.recheckCursor re-scans mem.txs and possibly removes some txs.
+		// Before mem.Reap(), we should wait for mem.recheckCursor to be nil.
 	}
 
 	// Update metrics
@@ -676,7 +663,7 @@ func (cache *mapTxCache) Push(tx types.Tx) bool {
 	// Use the tx hash in the cache
 	txHash := sha256.Sum256(tx)
 	if moved, exists := cache.map_[txHash]; exists {
-		cache.list.MoveToBack(moved)
+		cache.list.MoveToFront(moved)
 		return false
 	}
 

node/node.go

@@ -229,18 +229,13 @@ func NewNode(config *cfg.Config,
 	// what happened during block replay).
 	state = sm.LoadState(stateDB)
 
-	// Log the version info.
-	logger.Info("Version info",
-		"software", version.TMCoreSemVer,
-		"block", version.BlockProtocol,
-		"p2p", version.P2PProtocol,
-	)
-
-	// If the state and software differ in block version, at least log it.
+	// Ensure the state's block version matches that of the software.
 	if state.Version.Consensus.Block != version.BlockProtocol {
-		logger.Info("Software and state have different block protocols",
-			"software", version.BlockProtocol,
-			"state", state.Version.Consensus.Block,
+		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,
 		)
 	}
 
@@ -259,19 +254,16 @@ func NewNode(config *cfg.Config,
 	fastSync := config.FastSync
 	if state.Validators.Size() == 1 {
 		addr, _ := state.Validators.GetByIndex(0)
-		privValAddr := privValidator.GetPubKey().Address()
-		if bytes.Equal(privValAddr, addr) {
+		if bytes.Equal(privValidator.GetAddress(), addr) {
 			fastSync = false
 		}
 	}
 
-	pubKey := privValidator.GetPubKey()
-	addr := pubKey.Address()
 	// Log whether this node is a validator or an observer
-	if state.Validators.HasAddress(addr) {
-		consensusLogger.Info("This node is a validator", "addr", addr, "pubKey", pubKey)
+	if state.Validators.HasAddress(privValidator.GetAddress()) {
+		consensusLogger.Info("This node is a validator", "addr", privValidator.GetAddress(), "pubKey", privValidator.GetPubKey())
 	} else {
-		consensusLogger.Info("This node is not a validator", "addr", addr, "pubKey", pubKey)
+		consensusLogger.Info("This node is not a validator", "addr", privValidator.GetAddress(), "pubKey", privValidator.GetPubKey())
 	}
 
 	csMetrics, p2pMetrics, memplMetrics, smMetrics := metricsProvider()
@@ -370,21 +362,20 @@ func NewNode(config *cfg.Config,
 	indexerService := txindex.NewIndexerService(txIndexer, eventBus)
 	indexerService.SetLogger(logger.With("module", "txindex"))
 
-	p2pLogger := logger.With("module", "p2p")
-	nodeInfo, err := makeNodeInfo(
-		config,
-		nodeKey.ID(),
-		txIndexer,
-		genDoc.ChainID,
-		p2p.NewProtocolVersion(
-			version.P2PProtocol, // global
-			state.Version.Consensus.Block,
-			state.Version.Consensus.App,
-		),
+	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,
+			),
+		)
 	)
-	if err != nil {
-		return nil, err
-	}
 
 	// Setup Transport.
 	var (
@@ -482,7 +473,7 @@ func NewNode(config *cfg.Config,
 				Seeds:    splitAndTrimEmpty(config.P2P.Seeds, ",", " "),
 				SeedMode: config.P2P.SeedMode,
 			})
-		pexReactor.SetLogger(logger.With("module", "pex"))
+		pexReactor.SetLogger(p2pLogger)
 		sw.AddReactor("PEX", pexReactor)
 	}
 
@@ -639,8 +630,7 @@ func (n *Node) ConfigureRPC() {
 	rpccore.SetEvidencePool(n.evidencePool)
 	rpccore.SetP2PPeers(n.sw)
 	rpccore.SetP2PTransport(n)
-	pubKey := n.privValidator.GetPubKey()
-	rpccore.SetPubKey(pubKey)
+	rpccore.SetPubKey(n.privValidator.GetPubKey())
 	rpccore.SetGenesisDoc(n.genesisDoc)
 	rpccore.SetAddrBook(n.addrBook)
 	rpccore.SetProxyAppQuery(n.proxyApp.Query())
@@ -806,7 +796,7 @@ func makeNodeInfo(
 	txIndexer txindex.TxIndexer,
 	chainID string,
 	protocolVersion p2p.ProtocolVersion,
-) (p2p.NodeInfo, error) {
+) p2p.NodeInfo {
 	txIndexerStatus := "on"
 	if _, ok := txIndexer.(*null.TxIndex); ok {
 		txIndexerStatus = "off"
@@ -841,8 +831,7 @@ func makeNodeInfo(
 
 	nodeInfo.ListenAddr = lAddr
 
-	err := nodeInfo.Validate()
-	return nodeInfo, err
+	return nodeInfo
 }
 
 //------------------------------------------------------------------------------
@@ -878,20 +867,16 @@ func createAndStartPrivValidatorSocketClient(
 	listenAddr string,
 	logger log.Logger,
 ) (types.PrivValidator, error) {
-	var listener net.Listener
+	var pvsc types.PrivValidator
 
 	protocol, address := cmn.ProtocolAndAddress(listenAddr)
-	ln, err := net.Listen(protocol, address)
-	if err != nil {
-		return nil, err
-	}
 	switch protocol {
 	case "unix":
-		listener = privval.NewUnixListener(ln)
+		pvsc = privval.NewIPCVal(logger.With("module", "privval"), address)
 	case "tcp":
 		// TODO: persist this key so external signer
 		// can actually authenticate us
-		listener = privval.NewTCPListener(ln, ed25519.GenPrivKey())
+		pvsc = privval.NewTCPVal(logger.With("module", "privval"), listenAddr, ed25519.GenPrivKey())
 	default:
 		return nil, fmt.Errorf(
 			"Wrong listen address: expected either 'tcp' or 'unix' protocols, got %s",
@@ -899,9 +884,10 @@ func createAndStartPrivValidatorSocketClient(
 		)
 	}
 
-	pvsc := privval.NewSocketVal(logger.With("module", "privval"), listener)
-	if err := pvsc.Start(); err != nil {
-		return nil, errors.Wrap(err, "failed to start")
+	if pvsc, ok := pvsc.(cmn.Service); ok {
+		if err := pvsc.Start(); err != nil {
+			return nil, errors.Wrap(err, "failed to start")
+		}
 	}
 
 	return pvsc, nil

node/node_test.go

@@ -122,25 +122,25 @@ func TestNodeSetPrivValTCP(t *testing.T) {
 	config := cfg.ResetTestRoot("node_priv_val_tcp_test")
 	config.BaseConfig.PrivValidatorListenAddr = addr
 
-	dialer := privval.DialTCPFn(addr, 100*time.Millisecond, ed25519.GenPrivKey())
-	pvsc := privval.NewRemoteSigner(
+	rs := privval.NewRemoteSigner(
 		log.TestingLogger(),
 		config.ChainID(),
+		addr,
 		types.NewMockPV(),
-		dialer,
+		ed25519.GenPrivKey(),
 	)
-
+	privval.RemoteSignerConnDeadline(5 * time.Millisecond)(rs)
 	go func() {
-		err := pvsc.Start()
+		err := rs.Start()
 		if err != nil {
 			panic(err)
 		}
 	}()
-	defer pvsc.Stop()
+	defer rs.Stop()
 
 	n, err := DefaultNewNode(config, log.TestingLogger())
 	require.NoError(t, err)
-	assert.IsType(t, &privval.SocketVal{}, n.PrivValidator())
+	assert.IsType(t, &privval.TCPVal{}, n.PrivValidator())
 }
 
 // address without a protocol must result in error
@@ -161,25 +161,25 @@ func TestNodeSetPrivValIPC(t *testing.T) {
 	config := cfg.ResetTestRoot("node_priv_val_tcp_test")
 	config.BaseConfig.PrivValidatorListenAddr = "unix://" + tmpfile
 
-	dialer := privval.DialUnixFn(tmpfile)
-	pvsc := privval.NewRemoteSigner(
+	rs := privval.NewIPCRemoteSigner(
 		log.TestingLogger(),
 		config.ChainID(),
+		tmpfile,
 		types.NewMockPV(),
-		dialer,
 	)
+	privval.IPCRemoteSignerConnDeadline(3 * time.Second)(rs)
 
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
 		n, err := DefaultNewNode(config, log.TestingLogger())
 		require.NoError(t, err)
-		assert.IsType(t, &privval.SocketVal{}, n.PrivValidator())
+		assert.IsType(t, &privval.IPCVal{}, n.PrivValidator())
 	}()
 
-	err := pvsc.Start()
+	err := rs.Start()
 	require.NoError(t, err)
-	defer pvsc.Stop()
+	defer rs.Stop()
 
 	<-done
 }

p2p/README.md

@@ -4,8 +4,8 @@ The p2p package provides an abstraction around peer-to-peer communication.
 
 Docs:
 
-- [Connection](https://github.com/tendermint/tendermint/blob/master/docs/spec/p2p/connection.md) for details on how connections and multiplexing work
-- [Peer](https://github.com/tendermint/tendermint/blob/master/docs/spec/p2p/peer.md) for details on peer ID, handshakes, and peer exchange
-- [Node](https://github.com/tendermint/tendermint/blob/master/docs/spec/p2p/node.md) for details about different types of nodes and how they should work
-- [Pex](https://github.com/tendermint/tendermint/blob/master/docs/spec/reactors/pex/pex.md) for details on peer discovery and exchange
-- [Config](https://github.com/tendermint/tendermint/blob/master/docs/spec/p2p/config.md) for details on some config option
+- [Connection](https://github.com/tendermint/tendermint/blob/master/docs/spec/docs/spec/p2p/connection.md) for details on how connections and multiplexing work
+- [Peer](https://github.com/tendermint/tendermint/blob/master/docs/spec/docs/spec/p2p/peer.md) for details on peer ID, handshakes, and peer exchange
+- [Node](https://github.com/tendermint/tendermint/blob/master/docs/spec/docs/spec/p2p/node.md) for details about different types of nodes and how they should work
+- [Pex](https://github.com/tendermint/tendermint/blob/master/docs/spec/docs/spec/reactors/pex/pex.md) for details on peer discovery and exchange
+- [Config](https://github.com/tendermint/tendermint/blob/master/docs/spec/docs/spec/p2p/config.md) for details on some config option

p2p/conn/connection.go

@@ -160,7 +160,6 @@ func NewMConnectionWithConfig(conn net.Conn, chDescs []*ChannelDescriptor, onRec
 		onReceive:     onReceive,
 		onError:       onError,
 		config:        config,
-		created:       time.Now(),
 	}
 
 	// Create channels

p2p/conn/secret_connection.go

@@ -8,9 +8,9 @@ import (
 	"errors"
 	"io"
 	"net"
-	"sync"
 	"time"
 
+	// forked to github.com/tendermint/crypto
 	"golang.org/x/crypto/chacha20poly1305"
 	"golang.org/x/crypto/curve25519"
 	"golang.org/x/crypto/nacl/box"
@@ -28,36 +28,20 @@ const aeadSizeOverhead = 16 // overhead of poly 1305 authentication tag
 const aeadKeySize = chacha20poly1305.KeySize
 const aeadNonceSize = chacha20poly1305.NonceSize
 
-// SecretConnection implements net.Conn.
+// SecretConnection implements net.conn.
 // It is an implementation of the STS protocol.
-// See https://github.com/tendermint/tendermint/blob/0.1/docs/sts-final.pdf for
-// details on the protocol.
-//
-// Consumers of the SecretConnection are responsible for authenticating
-// the remote peer's pubkey against known information, like a nodeID.
-// Otherwise they are vulnerable to MITM.
-// (TODO(ismail): see also https://github.com/tendermint/tendermint/issues/3010)
+// Note we do not (yet) assume that a remote peer's pubkey
+// is known ahead of time, and thus we are technically
+// still vulnerable to MITM. (TODO!)
+// See docs/sts-final.pdf for more info
 type SecretConnection struct {
-
-	// immutable
+	conn       io.ReadWriteCloser
+	recvBuffer []byte
+	recvNonce  *[aeadNonceSize]byte
+	sendNonce  *[aeadNonceSize]byte
 	recvSecret *[aeadKeySize]byte
 	sendSecret *[aeadKeySize]byte
 	remPubKey  crypto.PubKey
-	conn       io.ReadWriteCloser
-
-	// net.Conn must be thread safe:
-	// https://golang.org/pkg/net/#Conn.
-	// Since we have internal mutable state,
-	// we need mtxs. But recv and send states
-	// are independent, so we can use two mtxs.
-	// All .Read are covered by recvMtx,
-	// all .Write are covered by sendMtx.
-	recvMtx    sync.Mutex
-	recvBuffer []byte
-	recvNonce  *[aeadNonceSize]byte
-
-	sendMtx   sync.Mutex
-	sendNonce *[aeadNonceSize]byte
 }
 
 // MakeSecretConnection performs handshake and returns a new authenticated
@@ -126,12 +110,9 @@ func (sc *SecretConnection) RemotePubKey() crypto.PubKey {
 	return sc.remPubKey
 }
 
-// Writes encrypted frames of `totalFrameSize + aeadSizeOverhead`.
-// CONTRACT: data smaller than dataMaxSize is written atomically.
+// Writes encrypted frames of `sealedFrameSize`
+// CONTRACT: data smaller than dataMaxSize is read atomically.
 func (sc *SecretConnection) Write(data []byte) (n int, err error) {
-	sc.sendMtx.Lock()
-	defer sc.sendMtx.Unlock()
-
 	for 0 < len(data) {
 		var frame = make([]byte, totalFrameSize)
 		var chunk []byte
@@ -150,7 +131,6 @@ func (sc *SecretConnection) Write(data []byte) (n int, err error) {
 		if err != nil {
 			return n, errors.New("Invalid SecretConnection Key")
 		}
-
 		// encrypt the frame
 		var sealedFrame = make([]byte, aeadSizeOverhead+totalFrameSize)
 		aead.Seal(sealedFrame[:0], sc.sendNonce[:], frame, nil)
@@ -168,30 +148,23 @@ func (sc *SecretConnection) Write(data []byte) (n int, err error) {
 
 // CONTRACT: data smaller than dataMaxSize is read atomically.
 func (sc *SecretConnection) Read(data []byte) (n int, err error) {
-	sc.recvMtx.Lock()
-	defer sc.recvMtx.Unlock()
-
-	// read off and update the recvBuffer, if non-empty
 	if 0 < len(sc.recvBuffer) {
 		n = copy(data, sc.recvBuffer)
 		sc.recvBuffer = sc.recvBuffer[n:]
 		return
 	}
 
-	// read off the conn
-	sealedFrame := make([]byte, totalFrameSize+aeadSizeOverhead)
-	_, err = io.ReadFull(sc.conn, sealedFrame)
-	if err != nil {
-		return
-	}
-
 	aead, err := chacha20poly1305.New(sc.recvSecret[:])
 	if err != nil {
 		return n, errors.New("Invalid SecretConnection Key")
 	}
+	sealedFrame := make([]byte, totalFrameSize+aeadSizeOverhead)
+	_, err = io.ReadFull(sc.conn, sealedFrame)
+	if err != nil {
+		return
+	}
 
-	// decrypt the frame.
-	// reads and updates the sc.recvNonce
+	// decrypt the frame
 	var frame = make([]byte, totalFrameSize)
 	_, err = aead.Open(frame[:0], sc.recvNonce[:], sealedFrame, nil)
 	if err != nil {
@@ -200,13 +173,12 @@ func (sc *SecretConnection) Read(data []byte) (n int, err error) {
 	incrNonce(sc.recvNonce)
 	// end decryption
 
-	// copy checkLength worth into data,
-	// set recvBuffer to the rest.
 	var chunkLength = binary.LittleEndian.Uint32(frame) // read the first four bytes
 	if chunkLength > dataMaxSize {
 		return 0, errors.New("chunkLength is greater than dataMaxSize")
 	}
 	var chunk = frame[dataLenSize : dataLenSize+chunkLength]
+
 	n = copy(data, chunk)
 	sc.recvBuffer = chunk[n:]
 	return

p2p/conn/secret_connection_test.go

@@ -7,12 +7,10 @@ import (
 	"fmt"
 	"io"
 	"log"
-	"net"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
-	"sync"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -100,69 +98,6 @@ func TestSecretConnectionHandshake(t *testing.T) {
 	}
 }
 
-func TestConcurrentWrite(t *testing.T) {
-	fooSecConn, barSecConn := makeSecretConnPair(t)
-	fooWriteText := cmn.RandStr(dataMaxSize)
-
-	// write from two routines.
-	// should be safe from race according to net.Conn:
-	// https://golang.org/pkg/net/#Conn
-	n := 100
-	wg := new(sync.WaitGroup)
-	wg.Add(3)
-	go writeLots(t, wg, fooSecConn, fooWriteText, n)
-	go writeLots(t, wg, fooSecConn, fooWriteText, n)
-
-	// Consume reads from bar's reader
-	readLots(t, wg, barSecConn, n*2)
-	wg.Wait()
-
-	if err := fooSecConn.Close(); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestConcurrentRead(t *testing.T) {
-	fooSecConn, barSecConn := makeSecretConnPair(t)
-	fooWriteText := cmn.RandStr(dataMaxSize)
-	n := 100
-
-	// read from two routines.
-	// should be safe from race according to net.Conn:
-	// https://golang.org/pkg/net/#Conn
-	wg := new(sync.WaitGroup)
-	wg.Add(3)
-	go readLots(t, wg, fooSecConn, n/2)
-	go readLots(t, wg, fooSecConn, n/2)
-
-	// write to bar
-	writeLots(t, wg, barSecConn, fooWriteText, n)
-	wg.Wait()
-
-	if err := fooSecConn.Close(); err != nil {
-		t.Error(err)
-	}
-}
-
-func writeLots(t *testing.T, wg *sync.WaitGroup, conn net.Conn, txt string, n int) {
-	defer wg.Done()
-	for i := 0; i < n; i++ {
-		_, err := conn.Write([]byte(txt))
-		if err != nil {
-			t.Fatalf("Failed to write to fooSecConn: %v", err)
-		}
-	}
-}
-
-func readLots(t *testing.T, wg *sync.WaitGroup, conn net.Conn, n int) {
-	readBuffer := make([]byte, dataMaxSize)
-	for i := 0; i < n; i++ {
-		_, err := conn.Read(readBuffer)
-		assert.NoError(t, err)
-	}
-	wg.Done()
-}
-
 func TestSecretConnectionReadWrite(t *testing.T) {
 	fooConn, barConn := makeKVStoreConnPair()
 	fooWrites, barWrites := []string{}, []string{}

p2p/netaddress.go

@@ -175,9 +175,6 @@ func (na *NetAddress) Same(other interface{}) bool {
 
 // String representation: <ID>@<IP>:<PORT>
 func (na *NetAddress) String() string {
-	if na == nil {
-		return "<nil-NetAddress>"
-	}
 	if na.str == "" {
 		addrStr := na.DialString()
 		if na.ID != "" {
@@ -189,9 +186,6 @@ func (na *NetAddress) String() string {
 }
 
 func (na *NetAddress) DialString() string {
-	if na == nil {
-		return "<nil-NetAddress>"
-	}
 	return net.JoinHostPort(
 		na.IP.String(),
 		strconv.FormatUint(uint64(na.Port), 10),

p2p/node_info.go

@@ -9,7 +9,7 @@ import (
 )
 
 const (
-	maxNodeInfoSize = 10240 // 10KB
+	maxNodeInfoSize = 10240 // 10Kb
 	maxNumChannels  = 16    // plenty of room for upgrades, for now
 )
 
@@ -36,7 +36,7 @@ type nodeInfoAddress interface {
 // nodeInfoTransport validates a nodeInfo and checks
 // our compatibility with it. It's for use in the handshake.
 type nodeInfoTransport interface {
-	Validate() error
+	ValidateBasic() error
 	CompatibleWith(other NodeInfo) error
 }
 
@@ -103,7 +103,7 @@ func (info DefaultNodeInfo) ID() ID {
 	return info.ID_
 }
 
-// Validate checks the self-reported DefaultNodeInfo is safe.
+// ValidateBasic checks the self-reported DefaultNodeInfo is safe.
 // It returns an error if there
 // are too many Channels, if there are any duplicate Channels,
 // if the ListenAddr is malformed, or if the ListenAddr is a host name
@@ -116,7 +116,7 @@ func (info DefaultNodeInfo) ID() ID {
 // International clients could then use punycode (or we could use
 // 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) Validate() error {
+func (info DefaultNodeInfo) ValidateBasic() error {
 
 	// ID is already validated.
 

p2p/node_info_test.go

@@ -12,7 +12,7 @@ func TestNodeInfoValidate(t *testing.T) {
 
 	// empty fails
 	ni := DefaultNodeInfo{}
-	assert.Error(t, ni.Validate())
+	assert.Error(t, ni.ValidateBasic())
 
 	channels := make([]byte, maxNumChannels)
 	for i := 0; i < maxNumChannels; i++ {
@@ -68,13 +68,13 @@ func TestNodeInfoValidate(t *testing.T) {
 	// test case passes
 	ni = testNodeInfo(nodeKey.ID(), name).(DefaultNodeInfo)
 	ni.Channels = channels
-	assert.NoError(t, ni.Validate())
+	assert.NoError(t, ni.ValidateBasic())
 
 	for _, tc := range testCases {
 		ni := testNodeInfo(nodeKey.ID(), name).(DefaultNodeInfo)
 		ni.Channels = channels
 		tc.malleateNodeInfo(&ni)
-		err := ni.Validate()
+		err := ni.ValidateBasic()
 		if tc.expectErr {
 			assert.Error(t, err, tc.testName)
 		} else {

p2p/peer_set.go

@@ -98,15 +98,13 @@ func (ps *PeerSet) Get(peerKey ID) Peer {
 }
 
 // Remove discards peer by its Key, if the peer was previously memoized.
-// Returns true if the peer was removed, and false if it was not found.
-// in the set.
-func (ps *PeerSet) Remove(peer Peer) bool {
+func (ps *PeerSet) Remove(peer Peer) {
 	ps.mtx.Lock()
 	defer ps.mtx.Unlock()
 
 	item := ps.lookup[peer.ID()]
 	if item == nil {
-		return false
+		return
 	}
 
 	index := item.index
@@ -118,7 +116,7 @@ func (ps *PeerSet) Remove(peer Peer) bool {
 	if index == len(ps.list)-1 {
 		ps.list = newList
 		delete(ps.lookup, peer.ID())
-		return true
+		return
 	}
 
 	// Replace the popped item with the last item in the old list.
@@ -129,7 +127,6 @@ func (ps *PeerSet) Remove(peer Peer) bool {
 	lastPeerItem.index = index
 	ps.list = newList
 	delete(ps.lookup, peer.ID())
-	return true
 }
 
 // Size returns the number of unique items in the peerSet.

p2p/peer_set_test.go

@@ -60,15 +60,13 @@ func TestPeerSetAddRemoveOne(t *testing.T) {
 	n := len(peerList)
 	// 1. Test removing from the front
 	for i, peerAtFront := range peerList {
-		removed := peerSet.Remove(peerAtFront)
-		assert.True(t, removed)
+		peerSet.Remove(peerAtFront)
 		wantSize := n - i - 1
 		for j := 0; j < 2; j++ {
 			assert.Equal(t, false, peerSet.Has(peerAtFront.ID()), "#%d Run #%d: failed to remove peer", i, j)
 			assert.Equal(t, wantSize, peerSet.Size(), "#%d Run #%d: failed to remove peer and decrement size", i, j)
 			// Test the route of removing the now non-existent element
-			removed := peerSet.Remove(peerAtFront)
-			assert.False(t, removed)
+			peerSet.Remove(peerAtFront)
 		}
 	}
 
@@ -83,8 +81,7 @@ func TestPeerSetAddRemoveOne(t *testing.T) {
 	// b) In reverse, remove each element
 	for i := n - 1; i >= 0; i-- {
 		peerAtEnd := peerList[i]
-		removed := peerSet.Remove(peerAtEnd)
-		assert.True(t, removed)
+		peerSet.Remove(peerAtEnd)
 		assert.Equal(t, false, peerSet.Has(peerAtEnd.ID()), "#%d: failed to remove item at end", i)
 		assert.Equal(t, i, peerSet.Size(), "#%d: differing sizes after peerSet.Remove(atEndPeer)", i)
 	}
@@ -108,8 +105,7 @@ func TestPeerSetAddRemoveMany(t *testing.T) {
 	}
 
 	for i, peer := range peers {
-		removed := peerSet.Remove(peer)
-		assert.True(t, removed)
+		peerSet.Remove(peer)
 		if peerSet.Has(peer.ID()) {
 			t.Errorf("Failed to remove peer")
 		}

p2p/pex/addrbook.go

@@ -162,29 +162,26 @@ func (a *addrBook) FilePath() string {
 
 // AddOurAddress one of our addresses.
 func (a *addrBook) AddOurAddress(addr *p2p.NetAddress) {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
 	a.Logger.Info("Add our address to book", "addr", addr)
+	a.mtx.Lock()
 	a.ourAddrs[addr.String()] = struct{}{}
+	a.mtx.Unlock()
 }
 
 // OurAddress returns true if it is our address.
 func (a *addrBook) OurAddress(addr *p2p.NetAddress) bool {
 	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
 	_, ok := a.ourAddrs[addr.String()]
+	a.mtx.Unlock()
 	return ok
 }
 
 func (a *addrBook) AddPrivateIDs(IDs []string) {
 	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
 	for _, id := range IDs {
 		a.privateIDs[p2p.ID(id)] = struct{}{}
 	}
+	a.mtx.Unlock()
 }
 
 // AddAddress implements AddrBook
@@ -194,7 +191,6 @@ func (a *addrBook) AddPrivateIDs(IDs []string) {
 func (a *addrBook) AddAddress(addr *p2p.NetAddress, src *p2p.NetAddress) error {
 	a.mtx.Lock()
 	defer a.mtx.Unlock()
-
 	return a.addAddress(addr, src)
 }
 
@@ -202,7 +198,6 @@ func (a *addrBook) AddAddress(addr *p2p.NetAddress, src *p2p.NetAddress) error {
 func (a *addrBook) RemoveAddress(addr *p2p.NetAddress) {
 	a.mtx.Lock()
 	defer a.mtx.Unlock()
-
 	ka := a.addrLookup[addr.ID]
 	if ka == nil {
 		return
@@ -216,16 +211,14 @@ func (a *addrBook) RemoveAddress(addr *p2p.NetAddress) {
 func (a *addrBook) IsGood(addr *p2p.NetAddress) bool {
 	a.mtx.Lock()
 	defer a.mtx.Unlock()
-
 	return a.addrLookup[addr.ID].isOld()
 }
 
 // HasAddress returns true if the address is in the book.
 func (a *addrBook) HasAddress(addr *p2p.NetAddress) bool {
 	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
 	ka := a.addrLookup[addr.ID]
+	a.mtx.Unlock()
 	return ka != nil
 }
 
@@ -299,7 +292,6 @@ func (a *addrBook) PickAddress(biasTowardsNewAddrs int) *p2p.NetAddress {
 func (a *addrBook) MarkGood(addr *p2p.NetAddress) {
 	a.mtx.Lock()
 	defer a.mtx.Unlock()
-
 	ka := a.addrLookup[addr.ID]
 	if ka == nil {
 		return
@@ -314,7 +306,6 @@ func (a *addrBook) MarkGood(addr *p2p.NetAddress) {
 func (a *addrBook) MarkAttempt(addr *p2p.NetAddress) {
 	a.mtx.Lock()
 	defer a.mtx.Unlock()
-
 	ka := a.addrLookup[addr.ID]
 	if ka == nil {
 		return
@@ -470,13 +461,12 @@ ADDRS_LOOP:
 
 // ListOfKnownAddresses returns the new and old addresses.
 func (a *addrBook) ListOfKnownAddresses() []*knownAddress {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
 	addrs := []*knownAddress{}
+	a.mtx.Lock()
 	for _, addr := range a.addrLookup {
 		addrs = append(addrs, addr.copy())
 	}
+	a.mtx.Unlock()
 	return addrs
 }
 
@@ -486,7 +476,6 @@ func (a *addrBook) ListOfKnownAddresses() []*knownAddress {
 func (a *addrBook) Size() int {
 	a.mtx.Lock()
 	defer a.mtx.Unlock()
-
 	return a.size()
 }
 

p2p/switch.go

@@ -211,9 +211,7 @@ func (sw *Switch) OnStop() {
 	// Stop peers
 	for _, p := range sw.peers.List() {
 		p.Stop()
-		if sw.peers.Remove(p) {
-			sw.metrics.Peers.Add(float64(-1))
-		}
+		sw.peers.Remove(p)
 	}
 
 	// Stop reactors
@@ -301,9 +299,8 @@ func (sw *Switch) StopPeerGracefully(peer Peer) {
 }
 
 func (sw *Switch) stopAndRemovePeer(peer Peer, reason interface{}) {
-	if sw.peers.Remove(peer) {
-		sw.metrics.Peers.Add(float64(-1))
-	}
+	sw.peers.Remove(peer)
+	sw.metrics.Peers.Add(float64(-1))
 	peer.Stop()
 	for _, reactor := range sw.reactors {
 		reactor.RemovePeer(peer, reason)
@@ -508,12 +505,6 @@ func (sw *Switch) acceptRoutine() {
 					"err", err,
 					"numPeers", sw.peers.Size(),
 				)
-				// We could instead have a retry loop around the acceptRoutine,
-				// but that would need to stop and let the node shutdown eventually.
-				// So might as well panic and let process managers restart the node.
-				// There's no point in letting the node run without the acceptRoutine,
-				// since it won't be able to accept new connections.
-				panic(fmt.Errorf("accept routine exited: %v", err))
 			}
 
 			break

p2p/switch_test.go

@@ -3,17 +3,10 @@ package p2p
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"regexp"
-	"strconv"
 	"sync"
 	"testing"
 	"time"
 
-	stdprometheus "github.com/prometheus/client_golang/prometheus"
-
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -342,54 +335,6 @@ func TestSwitchStopsNonPersistentPeerOnError(t *testing.T) {
 	assert.False(p.IsRunning())
 }
 
-func TestSwitchStopPeerForError(t *testing.T) {
-	s := httptest.NewServer(stdprometheus.UninstrumentedHandler())
-	defer s.Close()
-
-	scrapeMetrics := func() string {
-		resp, _ := http.Get(s.URL)
-		buf, _ := ioutil.ReadAll(resp.Body)
-		return string(buf)
-	}
-
-	namespace, subsystem, name := config.TestInstrumentationConfig().Namespace, MetricsSubsystem, "peers"
-	re := regexp.MustCompile(namespace + `_` + subsystem + `_` + name + ` ([0-9\.]+)`)
-	peersMetricValue := func() float64 {
-		matches := re.FindStringSubmatch(scrapeMetrics())
-		f, _ := strconv.ParseFloat(matches[1], 64)
-		return f
-	}
-
-	p2pMetrics := PrometheusMetrics(namespace)
-
-	// make two connected switches
-	sw1, sw2 := MakeSwitchPair(t, func(i int, sw *Switch) *Switch {
-		// set metrics on sw1
-		if i == 0 {
-			opt := WithMetrics(p2pMetrics)
-			opt(sw)
-		}
-		return initSwitchFunc(i, sw)
-	})
-
-	assert.Equal(t, len(sw1.Peers().List()), 1)
-	assert.EqualValues(t, 1, peersMetricValue())
-
-	// send messages to the peer from sw1
-	p := sw1.Peers().List()[0]
-	p.Send(0x1, []byte("here's a message to send"))
-
-	// stop sw2. this should cause the p to fail,
-	// which results in calling StopPeerForError internally
-	sw2.Stop()
-
-	// now call StopPeerForError explicitly, eg. from a reactor
-	sw1.StopPeerForError(p, fmt.Errorf("some err"))
-
-	assert.Equal(t, len(sw1.Peers().List()), 0)
-	assert.EqualValues(t, 0, peersMetricValue())
-}
-
 func TestSwitchReconnectsToPersistentPeer(t *testing.T) {
 	assert, require := assert.New(t), require.New(t)
 

p2p/test_util.go

@@ -24,7 +24,7 @@ type mockNodeInfo struct {
 
 func (ni mockNodeInfo) ID() ID                              { return ni.addr.ID }
 func (ni mockNodeInfo) NetAddress() *NetAddress             { return ni.addr }
-func (ni mockNodeInfo) Validate() error                     { return nil }
+func (ni mockNodeInfo) ValidateBasic() error                { return nil }
 func (ni mockNodeInfo) CompatibleWith(other NodeInfo) error { return nil }
 
 func AddPeerToSwitch(sw *Switch, peer Peer) {
@@ -184,7 +184,7 @@ func MakeSwitch(
 
 	// TODO: let the config be passed in?
 	sw := initSwitch(i, NewSwitch(cfg, t, opts...))
-	sw.SetLogger(log.TestingLogger().With("switch", i))
+	sw.SetLogger(log.TestingLogger())
 	sw.SetNodeKey(&nodeKey)
 
 	ni := nodeInfo.(DefaultNodeInfo)

p2p/transport.go

@@ -350,7 +350,7 @@ func (mt *MultiplexTransport) upgrade(
 		}
 	}
 
-	if err := nodeInfo.Validate(); err != nil {
+	if err := nodeInfo.ValidateBasic(); err != nil {
 		return nil, nil, ErrRejected{
 			conn:              c,
 			err:               err,

privval/client.go

@@ -1,263 +0,0 @@
-package privval
-
-import (
-	"errors"
-	"fmt"
-	"net"
-	"sync"
-	"time"
-
-	"github.com/tendermint/tendermint/crypto"
-	cmn "github.com/tendermint/tendermint/libs/common"
-	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/types"
-)
-
-const (
-	defaultConnHeartBeatSeconds = 2
-	defaultDialRetries          = 10
-)
-
-// Socket errors.
-var (
-	ErrUnexpectedResponse = errors.New("received unexpected response")
-)
-
-var (
-	connHeartbeat = time.Second * defaultConnHeartBeatSeconds
-)
-
-// SocketValOption sets an optional parameter on the SocketVal.
-type SocketValOption func(*SocketVal)
-
-// SocketValHeartbeat sets the period on which to check the liveness of the
-// connected Signer connections.
-func SocketValHeartbeat(period time.Duration) SocketValOption {
-	return func(sc *SocketVal) { sc.connHeartbeat = period }
-}
-
-// SocketVal implements PrivValidator.
-// It listens for an external process to dial in and uses
-// the socket to request signatures.
-type SocketVal struct {
-	cmn.BaseService
-
-	listener net.Listener
-
-	// ping
-	cancelPing    chan struct{}
-	pingTicker    *time.Ticker
-	connHeartbeat time.Duration
-
-	// signer is mutable since it can be
-	// reset if the connection fails.
-	// failures are detected by a background
-	// ping routine.
-	// Methods on the underlying net.Conn itself
-	// are already gorountine safe.
-	mtx    sync.RWMutex
-	signer *RemoteSignerClient
-}
-
-// Check that SocketVal implements PrivValidator.
-var _ types.PrivValidator = (*SocketVal)(nil)
-
-// NewSocketVal returns an instance of SocketVal.
-func NewSocketVal(
-	logger log.Logger,
-	listener net.Listener,
-) *SocketVal {
-	sc := &SocketVal{
-		listener:      listener,
-		connHeartbeat: connHeartbeat,
-	}
-
-	sc.BaseService = *cmn.NewBaseService(logger, "SocketVal", sc)
-
-	return sc
-}
-
-//--------------------------------------------------------
-// Implement PrivValidator
-
-// GetPubKey implements PrivValidator.
-func (sc *SocketVal) GetPubKey() crypto.PubKey {
-	sc.mtx.RLock()
-	defer sc.mtx.RUnlock()
-	return sc.signer.GetPubKey()
-}
-
-// SignVote implements PrivValidator.
-func (sc *SocketVal) SignVote(chainID string, vote *types.Vote) error {
-	sc.mtx.RLock()
-	defer sc.mtx.RUnlock()
-	return sc.signer.SignVote(chainID, vote)
-}
-
-// SignProposal implements PrivValidator.
-func (sc *SocketVal) SignProposal(chainID string, proposal *types.Proposal) error {
-	sc.mtx.RLock()
-	defer sc.mtx.RUnlock()
-	return sc.signer.SignProposal(chainID, proposal)
-}
-
-//--------------------------------------------------------
-// More thread safe methods proxied to the signer
-
-// Ping is used to check connection health.
-func (sc *SocketVal) Ping() error {
-	sc.mtx.RLock()
-	defer sc.mtx.RUnlock()
-	return sc.signer.Ping()
-}
-
-// Close closes the underlying net.Conn.
-func (sc *SocketVal) Close() {
-	sc.mtx.RLock()
-	defer sc.mtx.RUnlock()
-	if sc.signer != nil {
-		if err := sc.signer.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)
-		}
-	}
-}
-
-//--------------------------------------------------------
-// Service start and stop
-
-// OnStart implements cmn.Service.
-func (sc *SocketVal) OnStart() error {
-	if closed, err := sc.reset(); err != nil {
-		sc.Logger.Error("OnStart", "err", err)
-		return err
-	} else if closed {
-		return fmt.Errorf("listener is closed")
-	}
-
-	// 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)
-					if err == ErrUnexpectedResponse {
-						return
-					}
-
-					closed, err := sc.reset()
-					if err != nil {
-						sc.Logger.Error("Reconnecting to remote signer failed", "err", err)
-						continue
-					}
-					if closed {
-						sc.Logger.Info("listener is closing")
-						return
-					}
-
-					sc.Logger.Info("Re-created connection to remote signer", "impl", sc)
-				}
-			case <-sc.cancelPing:
-				sc.pingTicker.Stop()
-				return
-			}
-		}
-	}()
-
-	return nil
-}
-
-// OnStop implements cmn.Service.
-func (sc *SocketVal) OnStop() {
-	if sc.cancelPing != nil {
-		close(sc.cancelPing)
-	}
-	sc.Close()
-}
-
-//--------------------------------------------------------
-// Connection and signer management
-
-// waits to accept and sets a new connection.
-// connection is closed in OnStop.
-// returns true if the listener is closed
-// (ie. it returns a nil conn).
-func (sc *SocketVal) reset() (bool, error) {
-	sc.mtx.Lock()
-	defer sc.mtx.Unlock()
-
-	// first check if the conn already exists and close it.
-	if sc.signer != nil {
-		if err := sc.signer.Close(); err != nil {
-			sc.Logger.Error("error closing connection", "err", err)
-		}
-	}
-
-	// wait for a new conn
-	conn, err := sc.waitConnection()
-	if err != nil {
-		return false, err
-	}
-
-	// listener is closed
-	if conn == nil {
-		return true, nil
-	}
-
-	sc.signer, err = NewRemoteSignerClient(conn)
-	if err != nil {
-		// failed to fetch the pubkey. close out the connection.
-		if err := conn.Close(); err != nil {
-			sc.Logger.Error("error closing connection", "err", err)
-		}
-		return false, err
-	}
-	return false, nil
-}
-
-func (sc *SocketVal) 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
-
-	}
-	return conn, nil
-}
-
-// waitConnection uses the configured wait timeout to error if no external
-// process connects in the time period.
-func (sc *SocketVal) 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/doc.go

@@ -1,21 +0,0 @@
-/*
-
-Package privval provides different implementations of the types.PrivValidator.
-
-FilePV
-
-FilePV is the simplest implementation and developer default. It uses one file for the private key and another to store state.
-
-SocketVal
-
-SocketVal establishes a connection to an external process, like a Key Management Server (KMS), using a socket.
-SocketVal listens for the external KMS process to dial in.
-SocketVal takes a listener, which determines the type of connection
-(ie. encrypted over tcp, or unencrypted over unix).
-
-RemoteSigner
-
-RemoteSigner is a simple wrapper around a net.Conn. It's used by both IPCVal and TCPVal.
-
-*/
-package privval

privval/ipc.go

@@ -0,0 +1,120 @@
+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

@@ -0,0 +1,132 @@
+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 {
+				rs.Logger.Error("AcceptUnix", "err", err)
+				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

@@ -0,0 +1,147 @@
+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/old_file_test.go

@@ -1,77 +0,0 @@
-package privval_test
-
-import (
-	"io/ioutil"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/tendermint/tendermint/privval"
-)
-
-const oldPrivvalContent = `{
-  "address": "1D8089FAFDFAE4A637F3D616E17B92905FA2D91D",
-  "pub_key": {
-    "type": "tendermint/PubKeyEd25519",
-    "value": "r3Yg2AhDZ745CNTpavsGU+mRZ8WpRXqoJuyqjN8mJq0="
-  },
-  "last_height": "5",
-  "last_round": "0",
-  "last_step": 3,
-  "last_signature": "CTr7b9ZQlrJJf+12rPl5t/YSCUc/KqV7jQogCfFJA24e7hof69X6OMT7eFLVQHyodPjD/QTA298XHV5ejxInDQ==",
-  "last_signbytes": "750802110500000000000000220B08B398F3E00510F48DA6402A480A20FC258973076512999C3E6839A22E9FBDB1B77CF993E8A9955412A41A59D4CAD312240A20C971B286ACB8AAA6FCA0365EB0A660B189EDC08B46B5AF2995DEFA51A28D215B10013211746573742D636861696E2D533245415533",
-  "priv_key": {
-    "type": "tendermint/PrivKeyEd25519",
-    "value": "7MwvTGEWWjsYwjn2IpRb+GYsWi9nnFsw8jPLLY1UtP6vdiDYCENnvjkI1Olq+wZT6ZFnxalFeqgm7KqM3yYmrQ=="
-  }
-}`
-
-func TestLoadAndUpgrade(t *testing.T) {
-
-	oldFilePath := initTmpOldFile(t)
-	defer os.Remove(oldFilePath)
-	newStateFile, err := ioutil.TempFile("", "priv_validator_state*.json")
-	defer os.Remove(newStateFile.Name())
-	require.NoError(t, err)
-	newKeyFile, err := ioutil.TempFile("", "priv_validator_key*.json")
-	defer os.Remove(newKeyFile.Name())
-	require.NoError(t, err)
-
-	oldPV, err := privval.LoadOldFilePV(oldFilePath)
-	assert.NoError(t, err)
-	newPV := oldPV.Upgrade(newKeyFile.Name(), newStateFile.Name())
-
-	assertEqualPV(t, oldPV, newPV)
-	assert.NoError(t, err)
-	upgradedPV := privval.LoadFilePV(newKeyFile.Name(), newStateFile.Name())
-	assertEqualPV(t, oldPV, upgradedPV)
-	oldPV, err = privval.LoadOldFilePV(oldFilePath + ".bak")
-	require.NoError(t, err)
-	assertEqualPV(t, oldPV, upgradedPV)
-}
-
-func assertEqualPV(t *testing.T, oldPV *privval.OldFilePV, newPV *privval.FilePV) {
-	assert.Equal(t, oldPV.Address, newPV.Key.Address)
-	assert.Equal(t, oldPV.Address, newPV.GetAddress())
-	assert.Equal(t, oldPV.PubKey, newPV.Key.PubKey)
-	assert.Equal(t, oldPV.PubKey, newPV.GetPubKey())
-	assert.Equal(t, oldPV.PrivKey, newPV.Key.PrivKey)
-
-	assert.Equal(t, oldPV.LastHeight, newPV.LastSignState.Height)
-	assert.Equal(t, oldPV.LastRound, newPV.LastSignState.Round)
-	assert.Equal(t, oldPV.LastSignature, newPV.LastSignState.Signature)
-	assert.Equal(t, oldPV.LastSignBytes, newPV.LastSignState.SignBytes)
-	assert.Equal(t, oldPV.LastStep, newPV.LastSignState.Step)
-}
-
-func initTmpOldFile(t *testing.T) string {
-	tmpfile, err := ioutil.TempFile("", "priv_validator_*.json")
-	require.NoError(t, err)
-	t.Logf("created test file %s", tmpfile.Name())
-	_, err = tmpfile.WriteString(oldPrivvalContent)
-	require.NoError(t, err)
-
-	return tmpfile.Name()
-}

privval/priv_validator.go

@@ -22,7 +22,6 @@ const (
 	stepPrecommit int8 = 3
 )
 
-// A vote is either stepPrevote or stepPrecommit.
 func voteToStep(vote *types.Vote) int8 {
 	switch vote.Type {
 	case types.PrevoteType:
@@ -30,7 +29,7 @@ func voteToStep(vote *types.Vote) int8 {
 	case types.PrecommitType:
 		return stepPrecommit
 	default:
-		panic("Unknown vote type")
+		cmn.PanicSanity("Unknown vote type")
 		return 0
 	}
 }
@@ -160,20 +159,9 @@ func GenFilePV(keyFilePath, stateFilePath string) *FilePV {
 }
 
 // LoadFilePV loads a FilePV from the filePaths.  The FilePV handles double
-// signing prevention by persisting data to the stateFilePath.  If either file path
-// does not exist, the program will exit.
+// signing prevention by persisting data to the stateFilePath.  If the filePaths
+// do not exist, the FilePV must be created manually and saved.
 func LoadFilePV(keyFilePath, stateFilePath string) *FilePV {
-	return loadFilePV(keyFilePath, stateFilePath, true)
-}
-
-// LoadFilePVEmptyState loads a FilePV from the given keyFilePath, with an empty LastSignState.
-// If the keyFilePath does not exist, the program will exit.
-func LoadFilePVEmptyState(keyFilePath, stateFilePath string) *FilePV {
-	return loadFilePV(keyFilePath, stateFilePath, false)
-}
-
-// If loadState is true, we load from the stateFilePath. Otherwise, we use an empty LastSignState.
-func loadFilePV(keyFilePath, stateFilePath string, loadState bool) *FilePV {
 	keyJSONBytes, err := ioutil.ReadFile(keyFilePath)
 	if err != nil {
 		cmn.Exit(err.Error())
@@ -189,16 +177,14 @@ func loadFilePV(keyFilePath, stateFilePath string, loadState bool) *FilePV {
 	pvKey.Address = pvKey.PubKey.Address()
 	pvKey.filePath = keyFilePath
 
+	stateJSONBytes, err := ioutil.ReadFile(stateFilePath)
+	if err != nil {
+		cmn.Exit(err.Error())
+	}
 	pvState := FilePVLastSignState{}
-	if loadState {
-		stateJSONBytes, err := ioutil.ReadFile(stateFilePath)
-		if err != nil {
-			cmn.Exit(err.Error())
-		}
-		err = cdc.UnmarshalJSON(stateJSONBytes, &pvState)
-		if err != nil {
-			cmn.Exit(fmt.Sprintf("Error reading PrivValidator state from %v: %v\n", stateFilePath, err))
-		}
+	err = cdc.UnmarshalJSON(stateJSONBytes, &pvState)
+	if err != nil {
+		cmn.Exit(fmt.Sprintf("Error reading PrivValidator state from %v: %v\n", stateFilePath, err))
 	}
 
 	pvState.filePath = stateFilePath

privval/priv_validator_test.go

@@ -35,34 +35,6 @@ func TestGenLoadValidator(t *testing.T) {
 	assert.Equal(height, privVal.LastSignState.Height, "expected privval.LastHeight to have been saved")
 }
 
-func TestResetValidator(t *testing.T) {
-	tempKeyFile, err := ioutil.TempFile("", "priv_validator_key_")
-	require.Nil(t, err)
-	tempStateFile, err := ioutil.TempFile("", "priv_validator_state_")
-	require.Nil(t, err)
-
-	privVal := GenFilePV(tempKeyFile.Name(), tempStateFile.Name())
-	emptyState := FilePVLastSignState{filePath: tempStateFile.Name()}
-
-	// new priv val has empty state
-	assert.Equal(t, privVal.LastSignState, emptyState)
-
-	// test vote
-	height, round := int64(10), 1
-	voteType := byte(types.PrevoteType)
-	blockID := types.BlockID{[]byte{1, 2, 3}, types.PartSetHeader{}}
-	vote := newVote(privVal.Key.Address, 0, height, round, voteType, blockID)
-	err = privVal.SignVote("mychainid", vote)
-	assert.NoError(t, err, "expected no error signing vote")
-
-	// priv val after signing is not same as empty
-	assert.NotEqual(t, privVal.LastSignState, emptyState)
-
-	// priv val after reset is same as empty
-	privVal.Reset()
-	assert.Equal(t, privVal.LastSignState, emptyState)
-}
-
 func TestLoadOrGenValidator(t *testing.T) {
 	assert := assert.New(t)
 

privval/remote_signer.go

@@ -4,8 +4,7 @@ import (
 	"fmt"
 	"io"
 	"net"
-
-	"github.com/pkg/errors"
+	"sync"
 
 	"github.com/tendermint/go-amino"
 	"github.com/tendermint/tendermint/crypto"
@@ -13,73 +12,68 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
-// Socket errors.
-var (
-	ErrConnTimeout = errors.New("remote signer timed out")
-)
-
-// RemoteSignerClient implements PrivValidator.
-// It uses a net.Conn to request signatures
+// RemoteSignerClient implements PrivValidator, it uses a socket to request signatures
 // from an external process.
 type RemoteSignerClient struct {
 	conn net.Conn
-
-	// memoized
-	consensusPubKey crypto.PubKey
+	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, error) {
-
-	// retrieve and memoize the consensus public key once.
-	pubKey, err := getPubKey(conn)
-	if err != nil {
-		return nil, cmn.ErrorWrap(err, "error while retrieving public key for remote signer")
+func NewRemoteSignerClient(
+	conn net.Conn,
+) *RemoteSignerClient {
+	sc := &RemoteSignerClient{
+		conn: conn,
 	}
-	return &RemoteSignerClient{
-		conn:            conn,
-		consensusPubKey: pubKey,
-	}, nil
+	return sc
 }
 
-// Close calls Close on the underlying net.Conn.
-func (sc *RemoteSignerClient) Close() error {
-	return sc.conn.Close()
+// 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 {
-	return sc.consensusPubKey
+	pubKey, err := sc.getPubKey()
+	if err != nil {
+		panic(err)
+	}
+
+	return pubKey
 }
 
-// not thread-safe (only called on startup).
-func getPubKey(conn net.Conn) (crypto.PubKey, error) {
-	err := writeMsg(conn, &PubKeyRequest{})
+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(conn)
+	res, err := readMsg(sc.conn)
 	if err != nil {
 		return nil, err
 	}
-	pubKeyResp, ok := res.(*PubKeyResponse)
-	if !ok {
-		return nil, errors.Wrap(ErrUnexpectedResponse, "response is not PubKeyResponse")
-	}
 
-	if pubKeyResp.Error != nil {
-		return nil, errors.Wrap(pubKeyResp.Error, "failed to get private validator's public key")
-	}
-
-	return pubKeyResp.PubKey, nil
+	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
@@ -107,6 +101,9 @@ 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
@@ -130,6 +127,9 @@ func (sc *RemoteSignerClient) SignProposal(
 
 // 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
@@ -152,8 +152,7 @@ type RemoteSignerMsg interface{}
 
 func RegisterRemoteSignerMsg(cdc *amino.Codec) {
 	cdc.RegisterInterface((*RemoteSignerMsg)(nil), nil)
-	cdc.RegisterConcrete(&PubKeyRequest{}, "tendermint/remotesigner/PubKeyRequest", nil)
-	cdc.RegisterConcrete(&PubKeyResponse{}, "tendermint/remotesigner/PubKeyResponse", 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)
@@ -162,13 +161,9 @@ func RegisterRemoteSignerMsg(cdc *amino.Codec) {
 	cdc.RegisterConcrete(&PingResponse{}, "tendermint/remotesigner/PingResponse", nil)
 }
 
-// PubKeyRequest requests the consensus public key from the remote signer.
-type PubKeyRequest struct{}
-
-// PubKeyResponse is a PrivValidatorSocket message containing the public key.
-type PubKeyResponse struct {
+// PubKeyMsg is a PrivValidatorSocket message containing the public key.
+type PubKeyMsg struct {
 	PubKey crypto.PubKey
-	Error  *RemoteSignerError
 }
 
 // SignVoteRequest is a PrivValidatorSocket message containing a vote.
@@ -232,10 +227,10 @@ func handleRequest(req RemoteSignerMsg, chainID string, privVal types.PrivValida
 	var err error
 
 	switch r := req.(type) {
-	case *PubKeyRequest:
+	case *PubKeyMsg:
 		var p crypto.PubKey
 		p = privVal.GetPubKey()
-		res = &PubKeyResponse{p, nil}
+		res = &PubKeyMsg{p}
 	case *SignVoteRequest:
 		err = privVal.SignVote(chainID, r.Vote)
 		if err != nil {

privval/socket.go

@@ -1,184 +0,0 @@
-package privval
-
-import (
-	"net"
-	"time"
-
-	"github.com/tendermint/tendermint/crypto/ed25519"
-	p2pconn "github.com/tendermint/tendermint/p2p/conn"
-)
-
-const (
-	defaultAcceptDeadlineSeconds = 3
-	defaultConnDeadlineSeconds   = 3
-)
-
-// timeoutError can be used to check if an error returned from the netp package
-// was due to a timeout.
-type timeoutError interface {
-	Timeout() bool
-}
-
-//------------------------------------------------------------------
-// TCP Listener
-
-// TCPListenerOption sets an optional parameter on the tcpListener.
-type TCPListenerOption func(*tcpListener)
-
-// TCPListenerAcceptDeadline sets the deadline for the listener.
-// A zero time value disables the deadline.
-func TCPListenerAcceptDeadline(deadline time.Duration) TCPListenerOption {
-	return func(tl *tcpListener) { tl.acceptDeadline = deadline }
-}
-
-// TCPListenerConnDeadline sets the read and write deadline for connections
-// from external signing processes.
-func TCPListenerConnDeadline(deadline time.Duration) TCPListenerOption {
-	return func(tl *tcpListener) { tl.connDeadline = deadline }
-}
-
-// tcpListener implements net.Listener.
-var _ net.Listener = (*tcpListener)(nil)
-
-// tcpListener wraps a *net.TCPListener to standardise protocol timeouts
-// and potentially other tuning parameters. It also returns encrypted connections.
-type tcpListener struct {
-	*net.TCPListener
-
-	secretConnKey ed25519.PrivKeyEd25519
-
-	acceptDeadline time.Duration
-	connDeadline   time.Duration
-}
-
-// NewTCPListener returns a listener that accepts authenticated encrypted connections
-// using the given secretConnKey and the default timeout values.
-func NewTCPListener(ln net.Listener, secretConnKey ed25519.PrivKeyEd25519) *tcpListener {
-	return &tcpListener{
-		TCPListener:    ln.(*net.TCPListener),
-		secretConnKey:  secretConnKey,
-		acceptDeadline: time.Second * defaultAcceptDeadlineSeconds,
-		connDeadline:   time.Second * defaultConnDeadlineSeconds,
-	}
-}
-
-// Accept implements net.Listener.
-func (ln *tcpListener) Accept() (net.Conn, error) {
-	err := ln.SetDeadline(time.Now().Add(ln.acceptDeadline))
-	if err != nil {
-		return nil, err
-	}
-
-	tc, err := ln.AcceptTCP()
-	if err != nil {
-		return nil, err
-	}
-
-	// Wrap the conn in our timeout and encryption wrappers
-	timeoutConn := newTimeoutConn(tc, ln.connDeadline)
-	secretConn, err := p2pconn.MakeSecretConnection(timeoutConn, ln.secretConnKey)
-	if err != nil {
-		return nil, err
-	}
-
-	return secretConn, nil
-}
-
-//------------------------------------------------------------------
-// Unix Listener
-
-// unixListener implements net.Listener.
-var _ net.Listener = (*unixListener)(nil)
-
-type UnixListenerOption func(*unixListener)
-
-// UnixListenerAcceptDeadline sets the deadline for the listener.
-// A zero time value disables the deadline.
-func UnixListenerAcceptDeadline(deadline time.Duration) UnixListenerOption {
-	return func(ul *unixListener) { ul.acceptDeadline = deadline }
-}
-
-// UnixListenerConnDeadline sets the read and write deadline for connections
-// from external signing processes.
-func UnixListenerConnDeadline(deadline time.Duration) UnixListenerOption {
-	return func(ul *unixListener) { ul.connDeadline = deadline }
-}
-
-// unixListener wraps a *net.UnixListener to standardise protocol timeouts
-// and potentially other tuning parameters. It returns unencrypted connections.
-type unixListener struct {
-	*net.UnixListener
-
-	acceptDeadline time.Duration
-	connDeadline   time.Duration
-}
-
-// NewUnixListener returns a listener that accepts unencrypted connections
-// using the default timeout values.
-func NewUnixListener(ln net.Listener) *unixListener {
-	return &unixListener{
-		UnixListener:   ln.(*net.UnixListener),
-		acceptDeadline: time.Second * defaultAcceptDeadlineSeconds,
-		connDeadline:   time.Second * defaultConnDeadlineSeconds,
-	}
-}
-
-// Accept implements net.Listener.
-func (ln *unixListener) Accept() (net.Conn, error) {
-	err := ln.SetDeadline(time.Now().Add(ln.acceptDeadline))
-	if err != nil {
-		return nil, err
-	}
-
-	tc, err := ln.AcceptUnix()
-	if err != nil {
-		return nil, err
-	}
-
-	// Wrap the conn in our timeout wrapper
-	conn := newTimeoutConn(tc, ln.connDeadline)
-
-	// TODO: wrap in something that authenticates
-	// with a MAC - https://github.com/tendermint/tendermint/issues/3099
-
-	return conn, nil
-}
-
-//------------------------------------------------------------------
-// Connection
-
-// timeoutConn implements net.Conn.
-var _ net.Conn = (*timeoutConn)(nil)
-
-// timeoutConn wraps a net.Conn to standardise protocol timeouts / deadline resets.
-type timeoutConn struct {
-	net.Conn
-
-	connDeadline time.Duration
-}
-
-// newTimeoutConn returns an instance of newTCPTimeoutConn.
-func newTimeoutConn(
-	conn net.Conn,
-	connDeadline time.Duration) *timeoutConn {
-	return &timeoutConn{
-		conn,
-		connDeadline,
-	}
-}
-
-// Read implements net.Conn.
-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.Conn.
-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)
-}

privval/tcp.go

@@ -0,0 +1,214 @@
+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

@@ -5,7 +5,6 @@ import (
 	"net"
 	"time"
 
-	"github.com/pkg/errors"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	"github.com/tendermint/tendermint/libs/log"
@@ -13,11 +12,6 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
-// Socket errors.
-var (
-	ErrDialRetryMax = errors.New("dialed maximum retries")
-)
-
 // RemoteSignerOption sets an optional parameter on the RemoteSigner.
 type RemoteSignerOption func(*RemoteSigner)
 
@@ -32,64 +26,38 @@ func RemoteSignerConnRetries(retries int) RemoteSignerOption {
 	return func(ss *RemoteSigner) { ss.connRetries = retries }
 }
 
-// RemoteSigner dials using its dialer and responds to any
-// signature requests using its privVal.
+// 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
 
-	dialer Dialer
-	conn   net.Conn
+	conn net.Conn
 }
 
-// Dialer dials a remote address and returns a net.Conn or an error.
-type Dialer func() (net.Conn, error)
-
-// DialTCPFn dials the given tcp addr, using the given connTimeout and privKey for the
-// authenticated encryption handshake.
-func DialTCPFn(addr string, connTimeout time.Duration, privKey ed25519.PrivKeyEd25519) Dialer {
-	return func() (net.Conn, error) {
-		conn, err := cmn.Connect(addr)
-		if err == nil {
-			err = conn.SetDeadline(time.Now().Add(connTimeout))
-		}
-		if err == nil {
-			conn, err = p2pconn.MakeSecretConnection(conn, privKey)
-		}
-		return conn, err
-	}
-}
-
-// DialUnixFn dials the given unix socket.
-func DialUnixFn(addr string) Dialer {
-	return func() (net.Conn, error) {
-		unixAddr := &net.UnixAddr{addr, "unix"}
-		return net.DialUnix("unix", nil, unixAddr)
-	}
-}
-
-// NewRemoteSigner return a RemoteSigner that will dial using the given
-// dialer and respond to any signature requests over the connection
-// using the given privVal.
+// NewRemoteSigner returns an instance of RemoteSigner.
 func NewRemoteSigner(
 	logger log.Logger,
-	chainID string,
+	chainID, socketAddr string,
 	privVal types.PrivValidator,
-	dialer Dialer,
+	privKey ed25519.PrivKeyEd25519,
 ) *RemoteSigner {
 	rs := &RemoteSigner{
+		addr:         socketAddr,
 		chainID:      chainID,
 		connDeadline: time.Second * defaultConnDeadlineSeconds,
 		connRetries:  defaultDialRetries,
+		privKey:      privKey,
 		privVal:      privVal,
-		dialer:       dialer,
 	}
 
 	rs.BaseService = *cmn.NewBaseService(logger, "RemoteSigner", rs)
+
 	return rs
 }
 
@@ -100,7 +68,6 @@ func (rs *RemoteSigner) OnStart() error {
 		rs.Logger.Error("OnStart", "err", err)
 		return err
 	}
-	rs.conn = conn
 
 	go rs.handleConnection(conn)
 
@@ -124,11 +91,36 @@ func (rs *RemoteSigner) connect() (net.Conn, error) {
 		if retries != rs.connRetries {
 			time.Sleep(rs.connDeadline)
 		}
-		conn, err := rs.dialer()
+
+		conn, err := cmn.Connect(rs.addr)
 		if err != nil {
-			rs.Logger.Error("dialing", "err", err)
+			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
 	}
 
@@ -147,7 +139,7 @@ func (rs *RemoteSigner) handleConnection(conn net.Conn) {
 		req, err := readMsg(conn)
 		if err != nil {
 			if err != io.EOF {
-				rs.Logger.Error("handleConnection readMsg", "err", err)
+				rs.Logger.Error("handleConnection", "err", err)
 			}
 			return
 		}
@@ -156,12 +148,12 @@ func (rs *RemoteSigner) handleConnection(conn net.Conn) {
 
 		if err != nil {
 			// only log the error; we'll reply with an error in res
-			rs.Logger.Error("handleConnection handleRequest", "err", err)
+			rs.Logger.Error("handleConnection", "err", err)
 		}
 
 		err = writeMsg(conn, res)
 		if err != nil {
-			rs.Logger.Error("handleConnection writeMsg", "err", err)
+			rs.Logger.Error("handleConnection", "err", err)
 			return
 		}
 	}

privval/tcp_socket.go

@@ -0,0 +1,90 @@
+package privval
+
+import (
+	"net"
+	"time"
+)
+
+// timeoutError can be used to check if an error returned from the netp package
+// was due to a timeout.
+type timeoutError interface {
+	Timeout() bool
+}
+
+// tcpTimeoutListener implements net.Listener.
+var _ net.Listener = (*tcpTimeoutListener)(nil)
+
+// tcpTimeoutListener wraps a *net.TCPListener to standardise protocol timeouts
+// and potentially other tuning parameters.
+type tcpTimeoutListener struct {
+	*net.TCPListener
+
+	acceptDeadline time.Duration
+	connDeadline   time.Duration
+	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,
+	acceptDeadline, connDeadline time.Duration,
+	period time.Duration,
+) tcpTimeoutListener {
+	return tcpTimeoutListener{
+		TCPListener:    ln.(*net.TCPListener),
+		acceptDeadline: acceptDeadline,
+		connDeadline:   connDeadline,
+		period:         period,
+	}
+}
+
+// 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))
+	if err != nil {
+		return nil, err
+	}
+
+	tc, err := ln.AcceptTCP()
+	if err != nil {
+		return nil, err
+	}
+
+	// Wrap the conn in our timeout wrapper
+	conn := newTimeoutConn(tc, ln.connDeadline)
+
+	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)
+}

privval/tcp_socket_test.go

@@ -4,31 +4,17 @@ import (
 	"net"
 	"testing"
 	"time"
-
-	"github.com/tendermint/tendermint/crypto/ed25519"
 )
 
-//-------------------------------------------
-// helper funcs
-
-func newPrivKey() ed25519.PrivKeyEd25519 {
-	return ed25519.GenPrivKey()
-}
-
-//-------------------------------------------
-// tests
-
-func TestTCPListenerAcceptDeadline(t *testing.T) {
+func TestTCPTimeoutListenerAcceptDeadline(t *testing.T) {
 	ln, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	tcpLn := NewTCPListener(ln, newPrivKey())
-	TCPListenerAcceptDeadline(time.Millisecond)(tcpLn)
-	TCPListenerConnDeadline(time.Second)(tcpLn)
+	ln = newTCPTimeoutListener(ln, time.Millisecond, time.Second, time.Second)
 
-	_, err = tcpLn.Accept()
+	_, err = ln.Accept()
 	opErr, ok := err.(*net.OpError)
 	if !ok {
 		t.Fatalf("have %v, want *net.OpError", err)
@@ -39,17 +25,14 @@ func TestTCPListenerAcceptDeadline(t *testing.T) {
 	}
 }
 
-func TestTCPListenerConnDeadline(t *testing.T) {
+func TestTCPTimeoutListenerConnDeadline(t *testing.T) {
 	ln, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	tcpLn := NewTCPListener(ln, newPrivKey())
-	TCPListenerAcceptDeadline(time.Second)(tcpLn)
-	TCPListenerConnDeadline(time.Millisecond)(tcpLn)
+	ln = newTCPTimeoutListener(ln, time.Second, time.Millisecond, time.Second)
 
-	readyc := make(chan struct{})
 	donec := make(chan struct{})
 	go func(ln net.Listener) {
 		defer close(donec)
@@ -58,7 +41,6 @@ func TestTCPListenerConnDeadline(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		<-readyc
 
 		time.Sleep(2 * time.Millisecond)
 
@@ -72,13 +54,12 @@ func TestTCPListenerConnDeadline(t *testing.T) {
 		if have, want := opErr.Op, "read"; have != want {
 			t.Errorf("have %v, want %v", have, want)
 		}
-	}(tcpLn)
+	}(ln)
 
-	dialer := DialTCPFn(ln.Addr().String(), testConnDeadline, newPrivKey())
-	_, err = dialer()
+	_, err = net.Dial("tcp", ln.Addr().String())
 	if err != nil {
 		t.Fatal(err)
 	}
-	close(readyc)
+
 	<-donec
 }

privval/tcp_test.go

@@ -17,16 +17,6 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
-var (
-	testAcceptDeadline = defaultAcceptDeadlineSeconds * time.Second
-
-	testConnDeadline    = 100 * time.Millisecond
-	testConnDeadline2o3 = 66 * time.Millisecond // 2/3 of the other one
-
-	testHeartbeatTimeout    = 10 * time.Millisecond
-	testHeartbeatTimeout3o2 = 6 * time.Millisecond // 3/2 of the other one
-)
-
 func TestSocketPVAddress(t *testing.T) {
 	var (
 		chainID = cmn.RandStr(12)
@@ -35,10 +25,15 @@ func TestSocketPVAddress(t *testing.T) {
 	defer sc.Stop()
 	defer rs.Stop()
 
-	serverAddr := rs.privVal.GetPubKey().Address()
-	clientAddr := sc.GetPubKey().Address()
+	serverAddr := rs.privVal.GetAddress()
+
+	clientAddr := sc.GetAddress()
 
 	assert.Equal(t, serverAddr, clientAddr)
+
+	// TODO(xla): Remove when PrivValidator2 replaced PrivValidator.
+	assert.Equal(t, serverAddr, sc.GetAddress())
+
 }
 
 func TestSocketPVPubKey(t *testing.T) {
@@ -49,11 +44,15 @@ func TestSocketPVPubKey(t *testing.T) {
 	defer sc.Stop()
 	defer rs.Stop()
 
-	clientKey := sc.GetPubKey()
+	clientKey, err := sc.getPubKey()
+	require.NoError(t, err)
 
-	privvalPubKey := rs.privVal.GetPubKey()
+	privKey := rs.privVal.GetPubKey()
 
-	assert.Equal(t, privvalPubKey, clientKey)
+	assert.Equal(t, privKey, clientKey)
+
+	// TODO(xla): Remove when PrivValidator2 replaced PrivValidator.
+	assert.Equal(t, privKey, sc.GetPubKey())
 }
 
 func TestSocketPVProposal(t *testing.T) {
@@ -104,14 +103,14 @@ func TestSocketPVVoteResetDeadline(t *testing.T) {
 	defer sc.Stop()
 	defer rs.Stop()
 
-	time.Sleep(testConnDeadline2o3)
+	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(testConnDeadline2o3)
+	time.Sleep(3 * time.Millisecond)
 
 	require.NoError(t, rs.privVal.SignVote(chainID, want))
 	require.NoError(t, sc.SignVote(chainID, have))
@@ -131,7 +130,7 @@ func TestSocketPVVoteKeepalive(t *testing.T) {
 	defer sc.Stop()
 	defer rs.Stop()
 
-	time.Sleep(testConnDeadline * 2)
+	time.Sleep(10 * time.Millisecond)
 
 	require.NoError(t, rs.privVal.SignVote(chainID, want))
 	require.NoError(t, sc.SignVote(chainID, have))
@@ -140,18 +139,23 @@ func TestSocketPVVoteKeepalive(t *testing.T) {
 
 func TestSocketPVDeadline(t *testing.T) {
 	var (
-		addr            = testFreeAddr(t)
-		listenc         = make(chan struct{})
-		thisConnTimeout = 100 * time.Millisecond
-		sc              = newSocketVal(log.TestingLogger(), addr, thisConnTimeout)
+		addr    = testFreeAddr(t)
+		listenc = make(chan struct{})
+		sc      = NewTCPVal(
+			log.TestingLogger(),
+			addr,
+			ed25519.GenPrivKey(),
+		)
 	)
 
-	go func(sc *SocketVal) {
+	TCPValConnTimeout(100 * time.Millisecond)(sc)
+
+	go func(sc *TCPVal) {
 		defer close(listenc)
 
-		assert.Equal(t, sc.Start().(cmn.Error).Data(), ErrConnTimeout)
+		require.NoError(t, sc.Start())
 
-		assert.False(t, sc.IsRunning())
+		assert.True(t, sc.IsRunning())
 	}(sc)
 
 	for {
@@ -170,6 +174,9 @@ func TestSocketPVDeadline(t *testing.T) {
 	}
 
 	<-listenc
+
+	_, err := sc.getPubKey()
+	assert.Equal(t, err.(cmn.Error).Data(), ErrConnTimeout)
 }
 
 func TestRemoteSignerRetry(t *testing.T) {
@@ -203,8 +210,9 @@ func TestRemoteSignerRetry(t *testing.T) {
 	rs := NewRemoteSigner(
 		log.TestingLogger(),
 		cmn.RandStr(12),
+		ln.Addr().String(),
 		types.NewMockPV(),
-		DialTCPFn(ln.Addr().String(), testConnDeadline, ed25519.GenPrivKey()),
+		ed25519.GenPrivKey(),
 	)
 	defer rs.Stop()
 
@@ -233,8 +241,15 @@ func TestRemoteSignVoteErrors(t *testing.T) {
 	defer sc.Stop()
 	defer rs.Stop()
 
-	err := sc.SignVote("", vote)
-	require.Equal(t, err.(*RemoteSignerError).Description, types.ErroringMockPVErr.Error())
+	err := writeMsg(sc.conn, &SignVoteRequest{Vote: vote})
+	require.NoError(t, err)
+
+	res, err := readMsg(sc.conn)
+	require.NoError(t, err)
+
+	resp := *res.(*SignedVoteResponse)
+	require.NotNil(t, resp.Error)
+	require.Equal(t, resp.Error.Description, types.ErroringMockPVErr.Error())
 
 	err = rs.privVal.SignVote(chainID, vote)
 	require.Error(t, err)
@@ -253,8 +268,15 @@ func TestRemoteSignProposalErrors(t *testing.T) {
 	defer sc.Stop()
 	defer rs.Stop()
 
-	err := sc.SignProposal("", proposal)
-	require.Equal(t, err.(*RemoteSignerError).Description, types.ErroringMockPVErr.Error())
+	err := writeMsg(sc.conn, &SignProposalRequest{Proposal: proposal})
+	require.NoError(t, err)
+
+	res, err := readMsg(sc.conn)
+	require.NoError(t, err)
+
+	resp := *res.(*SignedProposalResponse)
+	require.NotNil(t, resp.Error)
+	require.Equal(t, resp.Error.Description, types.ErroringMockPVErr.Error())
 
 	err = rs.privVal.SignProposal(chainID, proposal)
 	require.Error(t, err)
@@ -274,24 +296,28 @@ func TestErrUnexpectedResponse(t *testing.T) {
 		rs = NewRemoteSigner(
 			logger,
 			chainID,
+			addr,
 			types.NewMockPV(),
-			DialTCPFn(addr, testConnDeadline, ed25519.GenPrivKey()),
+			ed25519.GenPrivKey(),
+		)
+		sc = NewTCPVal(
+			logger,
+			addr,
+			ed25519.GenPrivKey(),
 		)
-		sc = newSocketVal(logger, addr, testConnDeadline)
 	)
 
 	testStartSocketPV(t, readyc, sc)
 	defer sc.Stop()
 	RemoteSignerConnDeadline(time.Millisecond)(rs)
-	RemoteSignerConnRetries(100)(rs)
+	RemoteSignerConnRetries(1e6)(rs)
+
 	// we do not want to Start() the remote signer here and instead use the connection to
 	// reply with intentionally wrong replies below:
 	rsConn, err := rs.connect()
 	defer rsConn.Close()
 	require.NoError(t, err)
 	require.NotNil(t, rsConn)
-	// send over public key to get the remote signer running:
-	go testReadWriteResponse(t, &PubKeyResponse{}, rsConn)
 	<-readyc
 
 	// Proposal:
@@ -315,73 +341,11 @@ func TestErrUnexpectedResponse(t *testing.T) {
 	require.Equal(t, err, ErrUnexpectedResponse)
 }
 
-func TestRetryTCPConnToRemoteSigner(t *testing.T) {
-	var (
-		addr    = testFreeAddr(t)
-		logger  = log.TestingLogger()
-		chainID = cmn.RandStr(12)
-		readyc  = make(chan struct{})
-
-		rs = NewRemoteSigner(
-			logger,
-			chainID,
-			types.NewMockPV(),
-			DialTCPFn(addr, testConnDeadline, ed25519.GenPrivKey()),
-		)
-		thisConnTimeout = testConnDeadline
-		sc              = newSocketVal(logger, addr, thisConnTimeout)
-	)
-	// Ping every:
-	SocketValHeartbeat(testHeartbeatTimeout)(sc)
-
-	RemoteSignerConnDeadline(testConnDeadline)(rs)
-	RemoteSignerConnRetries(10)(rs)
-
-	testStartSocketPV(t, readyc, sc)
-	defer sc.Stop()
-	require.NoError(t, rs.Start())
-	assert.True(t, rs.IsRunning())
-
-	<-readyc
-	time.Sleep(testHeartbeatTimeout * 2)
-
-	rs.Stop()
-	rs2 := NewRemoteSigner(
-		logger,
-		chainID,
-		types.NewMockPV(),
-		DialTCPFn(addr, testConnDeadline, ed25519.GenPrivKey()),
-	)
-	// let some pings pass
-	time.Sleep(testHeartbeatTimeout3o2)
-	require.NoError(t, rs2.Start())
-	assert.True(t, rs2.IsRunning())
-	defer rs2.Stop()
-
-	// give the client some time to re-establish the conn to the remote signer
-	// should see sth like this in the logs:
-	//
-	// E[10016-01-10|17:12:46.128] Ping                                         err="remote signer timed out"
-	// I[10016-01-10|17:16:42.447] Re-created connection to remote signer       impl=SocketVal
-	time.Sleep(testConnDeadline * 2)
-}
-
-func newSocketVal(logger log.Logger, addr string, connDeadline time.Duration) *SocketVal {
-	ln, err := net.Listen(cmn.ProtocolAndAddress(addr))
-	if err != nil {
-		panic(err)
-	}
-	tcpLn := NewTCPListener(ln, ed25519.GenPrivKey())
-	TCPListenerAcceptDeadline(testAcceptDeadline)(tcpLn)
-	TCPListenerConnDeadline(testConnDeadline)(tcpLn)
-	return NewSocketVal(logger, tcpLn)
-}
-
 func testSetupSocketPair(
 	t *testing.T,
 	chainID string,
 	privValidator types.PrivValidator,
-) (*SocketVal, *RemoteSigner) {
+) (*TCPVal, *RemoteSigner) {
 	var (
 		addr    = testFreeAddr(t)
 		logger  = log.TestingLogger()
@@ -390,16 +354,20 @@ func testSetupSocketPair(
 		rs      = NewRemoteSigner(
 			logger,
 			chainID,
+			addr,
 			privVal,
-			DialTCPFn(addr, testConnDeadline, ed25519.GenPrivKey()),
+			ed25519.GenPrivKey(),
+		)
+		sc = NewTCPVal(
+			logger,
+			addr,
+			ed25519.GenPrivKey(),
 		)
-
-		thisConnTimeout = testConnDeadline
-		sc              = newSocketVal(logger, addr, thisConnTimeout)
 	)
 
-	SocketValHeartbeat(testHeartbeatTimeout)(sc)
-	RemoteSignerConnDeadline(testConnDeadline)(rs)
+	TCPValConnTimeout(5 * time.Millisecond)(sc)
+	TCPValHeartbeat(2 * time.Millisecond)(sc)
+	RemoteSignerConnDeadline(5 * time.Millisecond)(rs)
 	RemoteSignerConnRetries(1e6)(rs)
 
 	testStartSocketPV(t, readyc, sc)
@@ -420,8 +388,8 @@ func testReadWriteResponse(t *testing.T, resp RemoteSignerMsg, rsConn net.Conn)
 	require.NoError(t, err)
 }
 
-func testStartSocketPV(t *testing.T, readyc chan struct{}, sc *SocketVal) {
-	go func(sc *SocketVal) {
+func testStartSocketPV(t *testing.T, readyc chan struct{}, sc *TCPVal) {
+	go func(sc *TCPVal) {
 		require.NoError(t, sc.Start())
 		assert.True(t, sc.IsRunning())
 

proxy/client.go

@@ -6,7 +6,6 @@ import (
 	"github.com/pkg/errors"
 
 	abcicli "github.com/tendermint/tendermint/abci/client"
-	"github.com/tendermint/tendermint/abci/example/counter"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/abci/types"
 )
@@ -65,15 +64,15 @@ func (r *remoteClientCreator) NewABCIClient() (abcicli.Client, error) {
 
 func DefaultClientCreator(addr, transport, dbDir string) ClientCreator {
 	switch addr {
-	case "counter":
-		return NewLocalClientCreator(counter.NewCounterApplication(false))
-	case "counter_serial":
-		return NewLocalClientCreator(counter.NewCounterApplication(true))
 	case "kvstore":
+		fallthrough
+	case "dummy":
 		return NewLocalClientCreator(kvstore.NewKVStoreApplication())
 	case "persistent_kvstore":
+		fallthrough
+	case "persistent_dummy":
 		return NewLocalClientCreator(kvstore.NewPersistentKVStoreApplication(dbDir))
-	case "noop":
+	case "nilapp":
 		return NewLocalClientCreator(types.NewBaseApplication())
 	default:
 		mustConnect := false // loop retrying

rpc/client/httpclient.go

@@ -109,24 +109,6 @@ func (c *HTTP) broadcastTX(route string, tx types.Tx) (*ctypes.ResultBroadcastTx
 	return result, nil
 }
 
-func (c *HTTP) UnconfirmedTxs(limit int) (*ctypes.ResultUnconfirmedTxs, error) {
-	result := new(ctypes.ResultUnconfirmedTxs)
-	_, err := c.rpc.Call("unconfirmed_txs", map[string]interface{}{"limit": limit}, result)
-	if err != nil {
-		return nil, errors.Wrap(err, "unconfirmed_txs")
-	}
-	return result, nil
-}
-
-func (c *HTTP) NumUnconfirmedTxs() (*ctypes.ResultUnconfirmedTxs, error) {
-	result := new(ctypes.ResultUnconfirmedTxs)
-	_, err := c.rpc.Call("num_unconfirmed_txs", map[string]interface{}{}, result)
-	if err != nil {
-		return nil, errors.Wrap(err, "num_unconfirmed_txs")
-	}
-	return result, nil
-}
-
 func (c *HTTP) NetInfo() (*ctypes.ResultNetInfo, error) {
 	result := new(ctypes.ResultNetInfo)
 	_, err := c.rpc.Call("net_info", map[string]interface{}{}, result)

rpc/client/interface.go

@@ -93,9 +93,3 @@ type NetworkClient interface {
 type EventsClient interface {
 	types.EventBusSubscriber
 }
-
-// MempoolClient shows us data about current mempool state.
-type MempoolClient interface {
-	UnconfirmedTxs(limit int) (*ctypes.ResultUnconfirmedTxs, error)
-	NumUnconfirmedTxs() (*ctypes.ResultUnconfirmedTxs, error)
-}

rpc/client/localclient.go

@@ -76,14 +76,6 @@ func (Local) BroadcastTxSync(tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
 	return core.BroadcastTxSync(tx)
 }
 
-func (Local) UnconfirmedTxs(limit int) (*ctypes.ResultUnconfirmedTxs, error) {
-	return core.UnconfirmedTxs(limit)
-}
-
-func (Local) NumUnconfirmedTxs() (*ctypes.ResultUnconfirmedTxs, error) {
-	return core.NumUnconfirmedTxs()
-}
-
 func (Local) NetInfo() (*ctypes.ResultNetInfo, error) {
 	return core.NetInfo()
 }

rpc/client/rpc_test.go

@@ -281,42 +281,6 @@ func TestBroadcastTxCommit(t *testing.T) {
 	}
 }
 
-func TestUnconfirmedTxs(t *testing.T) {
-	_, _, tx := MakeTxKV()
-
-	mempool := node.MempoolReactor().Mempool
-	_ = mempool.CheckTx(tx, nil)
-
-	for i, c := range GetClients() {
-		mc, ok := c.(client.MempoolClient)
-		require.True(t, ok, "%d", i)
-		txs, err := mc.UnconfirmedTxs(1)
-		require.Nil(t, err, "%d: %+v", i, err)
-		assert.Exactly(t, types.Txs{tx}, types.Txs(txs.Txs))
-	}
-
-	mempool.Flush()
-}
-
-func TestNumUnconfirmedTxs(t *testing.T) {
-	_, _, tx := MakeTxKV()
-
-	mempool := node.MempoolReactor().Mempool
-	_ = mempool.CheckTx(tx, nil)
-	mempoolSize := mempool.Size()
-
-	for i, c := range GetClients() {
-		mc, ok := c.(client.MempoolClient)
-		require.True(t, ok, "%d", i)
-		res, err := mc.NumUnconfirmedTxs()
-		require.Nil(t, err, "%d: %+v", i, err)
-
-		assert.Equal(t, mempoolSize, res.N)
-	}
-
-	mempool.Flush()
-}
-
 func TestTx(t *testing.T) {
 	// first we broadcast a tx
 	c := getHTTPClient()
@@ -428,10 +392,5 @@ func TestTxSearch(t *testing.T) {
 		if len(result.Txs) == 0 {
 			t.Fatal("expected a lot of transactions")
 		}
-
-		// query a non existing tx with page 1 and txsPerPage 1
-		result, err = c.TxSearch("app.creator='Cosmoshi Neetowoko'", true, 1, 1)
-		require.Nil(t, err, "%+v", err)
-		require.Len(t, result.Txs, 0)
 	}
 }

rpc/core/abci.go

@@ -15,11 +15,6 @@ import (
 //
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
-// err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // result, err := client.ABCIQuery("", "abcd", true)
 // ```
 //
@@ -74,11 +69,6 @@ func ABCIQuery(path string, data cmn.HexBytes, height int64, prove bool) (*ctype
 //
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
-// err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // info, err := client.ABCIInfo()
 // ```
 //

rpc/core/blocks.go

@@ -18,11 +18,6 @@ import (
 //
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
-// err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // info, err := client.BlockchainInfo(10, 10)
 // ```
 //
@@ -128,11 +123,6 @@ func filterMinMax(height, min, max, limit int64) (int64, int64, error) {
 //
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
-// err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // info, err := client.Block(10)
 // ```
 //
@@ -245,11 +235,6 @@ func Block(heightPtr *int64) (*ctypes.ResultBlock, error) {
 //
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
-// err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // info, err := client.Commit(11)
 // ```
 //
@@ -344,11 +329,6 @@ func Commit(heightPtr *int64) (*ctypes.ResultCommit, error) {
 //
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
-// err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // info, err := client.BlockResults(10)
 // ```
 //

rpc/core/consensus.go

@@ -16,11 +16,6 @@ import (
 //
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
-// err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // state, err := client.Validators()
 // ```
 //
@@ -72,11 +67,6 @@ func Validators(heightPtr *int64) (*ctypes.ResultValidators, error) {
 //
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
-// err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // state, err := client.DumpConsensusState()
 // ```
 //
@@ -235,11 +225,6 @@ func DumpConsensusState() (*ctypes.ResultDumpConsensusState, error) {
 //
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
-// err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // state, err := client.ConsensusState()
 // ```
 //
@@ -288,11 +273,6 @@ func ConsensusState() (*ctypes.ResultConsensusState, error) {
 //
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
-// err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // state, err := client.ConsensusParams()
 // ```
 //

rpc/core/events.go

@@ -55,10 +55,6 @@ import (
 //
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
 // err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // ctx, cancel := context.WithTimeout(context.Background(), timeout)
 // defer cancel()
 // query := query.MustParse("tm.event = 'Tx' AND tx.height = 3")
@@ -122,10 +118,6 @@ func Subscribe(wsCtx rpctypes.WSRPCContext, query string) (*ctypes.ResultSubscri
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
 // err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // err = client.Unsubscribe("test-client", query)
 // ```
 //
@@ -166,10 +158,6 @@ func Unsubscribe(wsCtx rpctypes.WSRPCContext, query string) (*ctypes.ResultUnsub
 // ```go
 // client := client.NewHTTP("tcp://0.0.0.0:26657", "/websocket")
 // err := client.Start()
-// if err != nil {
-//   // handle error
-// }
-// defer client.Stop()
 // err = client.UnsubscribeAll("test-client")
 // ```
 //