linting: apply errcheck part1

benchmarks/os_test.go

@@ -18,12 +18,16 @@ func BenchmarkFileWrite(b *testing.B) {
 	b.StartTimer()
 
 	for i := 0; i < b.N; i++ {
-		file.Write([]byte(testString))
+		_, err := file.Write([]byte(testString))
+		if err != nil {
+			b.Error(err)
+		}
 	}
 
-	file.Close()
+	if err := file.Close(); err != nil {
-	err = os.Remove("benchmark_file_write.out")
+		b.Error(err)
-	if err != nil {
+	}
+	if err := os.Remove("benchmark_file_write.out"); err != nil {
 		b.Error(err)
 	}
 }

blockchain/pool_test.go

@@ -36,7 +36,12 @@ func TestBasic(t *testing.T) {
 	requestsCh := make(chan BlockRequest, 100)
 	pool := NewBlockPool(start, requestsCh, timeoutsCh)
 	pool.SetLogger(log.TestingLogger())
-	pool.Start()
+
+	_, err := pool.Start()
+	if err != nil {
+		t.Error(err)
+	}
+
 	defer pool.Stop()
 
 	// Introduce each peer.
@@ -88,7 +93,10 @@ func TestTimeout(t *testing.T) {
 	requestsCh := make(chan BlockRequest, 100)
 	pool := NewBlockPool(start, requestsCh, timeoutsCh)
 	pool.SetLogger(log.TestingLogger())
-	pool.Start()
+	_, err := pool.Start()
+	if err != nil {
+		t.Error(err)
+	}
 	defer pool.Stop()
 
 	for _, peer := range peers {

blockchain/reactor.go

@@ -88,7 +88,9 @@ func (bcR *BlockchainReactor) SetLogger(l log.Logger) {
 
 // OnStart implements cmn.Service.
 func (bcR *BlockchainReactor) OnStart() error {
-	bcR.BaseReactor.OnStart()
+	if err := bcR.BaseReactor.OnStart(); err != nil {
+		return err
+	}
 	if bcR.fastSync {
 		_, err := bcR.pool.Start()
 		if err != nil {

cmd/tendermint/commands/init.go

@@ -33,7 +33,9 @@ func initFiles(cmd *cobra.Command, args []string) {
 				Power:  10,
 			}}
 
-			genDoc.SaveAs(genFile)
+			if err := genDoc.SaveAs(genFile); err != nil {
+				panic(err)
+			}
 		}
 
 		logger.Info("Initialized tendermint", "genesis", config.GenesisFile(), "priv_validator", config.PrivValidatorFile())

cmd/tendermint/commands/reset_priv_validator.go

@@ -44,6 +44,15 @@ func resetPrivValidator(cmd *cobra.Command, args []string) {
 	resetPrivValidatorFS(config.PrivValidatorFile(), logger)
 }
 
+// Exported so other CLI tools can use  it
+func ResetAll(dbDir, privValFile string, logger log.Logger) {
+	resetPrivValidatorLocal(privValFile, logger)
+	if err := os.RemoveAll(dbDir); err != nil {
+		panic(err)
+	}
+	logger.Info("Removed all data", "dir", dbDir)
+}
+
 func resetPrivValidatorFS(privValFile string, logger log.Logger) {
 	// Get PrivValidator
 	if _, err := os.Stat(privValFile); err == nil {

cmd/tendermint/commands/root_test.go

@@ -26,8 +26,12 @@ const (
 // modify in the test cases.
 // NOTE: it unsets all TM* env variables.
 func isolate(cmds ...*cobra.Command) cli.Executable {
-	os.Unsetenv("TMHOME")
+	if err := os.Unsetenv("TMHOME"); err != nil {
-	os.Unsetenv("TM_HOME")
+		panic(err)
+	}
+	if err := os.Unsetenv("TM_HOME"); err != nil {
+		panic(err)
+	}
 
 	viper.Reset()
 	config = cfg.DefaultConfig()

cmd/tendermint/commands/testnet.go

@@ -63,7 +63,9 @@ func testnetFiles(cmd *cobra.Command, args []string) {
 	// Write genesis file.
 	for i := 0; i < nValidators; i++ {
 		mach := cmn.Fmt("mach%d", i)
-		genDoc.SaveAs(path.Join(dataDir, mach, "genesis.json"))
+		if err := genDoc.SaveAs(path.Join(dataDir, mach, "genesis.json")); err != nil {
+			panic(err)
+		}
 	}
 
 	fmt.Println(cmn.Fmt("Successfully initialized %v node directories", nValidators))

cmd/tendermint/main.go

@@ -37,5 +37,7 @@ func main() {
 	rootCmd.AddCommand(cmd.NewRunNodeCmd(nodeFunc))
 
 	cmd := cli.PrepareBaseCmd(rootCmd, "TM", os.ExpandEnv("$HOME/.tendermint"))
-	cmd.Execute()
+	if err := cmd.Execute(); err != nil {
+		panic(err)
+	}
 }

config/toml.go

@@ -12,8 +12,12 @@ import (
 /****** these are for production settings ***********/
 
 func EnsureRoot(rootDir string) {
-	cmn.EnsureDir(rootDir, 0700)
+	if err := cmn.EnsureDir(rootDir, 0700); err != nil {
-	cmn.EnsureDir(rootDir+"/data", 0700)
+		panic(err)
+	}
+	if err := cmn.EnsureDir(rootDir+"/data", 0700); err != nil {
+		panic(err)
+	}
 
 	configFilePath := path.Join(rootDir, "config.toml")
 
@@ -53,21 +57,23 @@ func ResetTestRoot(testName string) *Config {
 	rootDir = filepath.Join(rootDir, testName)
 	// Remove ~/.tendermint_test_bak
 	if cmn.FileExists(rootDir + "_bak") {
-		err := os.RemoveAll(rootDir + "_bak")
+		if err := os.RemoveAll(rootDir + "_bak"); err != nil {
-		if err != nil {
 			cmn.PanicSanity(err.Error())
 		}
 	}
 	// Move ~/.tendermint_test to ~/.tendermint_test_bak
 	if cmn.FileExists(rootDir) {
-		err := os.Rename(rootDir, rootDir+"_bak")
+		if err := os.Rename(rootDir, rootDir+"_bak"); err != nil {
-		if err != nil {
 			cmn.PanicSanity(err.Error())
 		}
 	}
 	// Create new dir
-	cmn.EnsureDir(rootDir, 0700)
+	if err := cmn.EnsureDir(rootDir, 0700); err != nil {
-	cmn.EnsureDir(rootDir+"/data", 0700)
+		panic(err)
+	}
+	if err := cmn.EnsureDir(rootDir+"/data", 0700); err != nil {
+		panic(err)
+	}
 
 	configFilePath := path.Join(rootDir, "config.toml")
 	genesisFilePath := path.Join(rootDir, "genesis.json")

consensus/byzantine_test.go

@@ -170,13 +170,17 @@ func byzantineDecideProposalFunc(t *testing.T, height, round int, cs *ConsensusS
 	block1, blockParts1 := cs.createProposalBlock()
 	polRound, polBlockID := cs.Votes.POLInfo()
 	proposal1 := types.NewProposal(height, round, blockParts1.Header(), polRound, polBlockID)
-	cs.privValidator.SignProposal(cs.state.ChainID, proposal1) // byzantine doesnt err
+	if err := cs.privValidator.SignProposal(cs.state.ChainID, proposal1); err != nil {
+		t.Error(err)
+	}
 
 	// Create a new proposal block from state/txs from the mempool.
 	block2, blockParts2 := cs.createProposalBlock()
 	polRound, polBlockID = cs.Votes.POLInfo()
 	proposal2 := types.NewProposal(height, round, blockParts2.Header(), polRound, polBlockID)
-	cs.privValidator.SignProposal(cs.state.ChainID, proposal2) // byzantine doesnt err
+	if err := cs.privValidator.SignProposal(cs.state.ChainID, proposal2); err != nil {
+		t.Error(err)
+	}
 
 	block1Hash := block1.Hash()
 	block2Hash := block2.Hash()

p2p/util.go

@@ -7,9 +7,15 @@ import (
 // doubleSha256 calculates sha256(sha256(b)) and returns the resulting bytes.
 func doubleSha256(b []byte) []byte {
 	hasher := sha256.New()
-	hasher.Write(b)
+	_, err := hasher.Write(b)
+	if err != nil {
+		panic(err)
+	}
 	sum := hasher.Sum(nil)
 	hasher.Reset()
-	hasher.Write(sum)
+	_, err = hasher.Write(sum)
+	if err != nil {
+		panic(err)
+	}
 	return hasher.Sum(nil)
 }

proxy/app_conn_test.go

@@ -72,7 +72,9 @@ func TestEcho(t *testing.T) {
 	for i := 0; i < 1000; i++ {
 		proxy.EchoAsync(cmn.Fmt("echo-%v", i))
 	}
-	proxy.FlushSync()
+	if err := proxy.FlushSync(); err != nil {
+		t.Error(err)
+	}
 }
 
 func BenchmarkEcho(b *testing.B) {
@@ -106,7 +108,9 @@ func BenchmarkEcho(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		proxy.EchoAsync(echoString)
 	}
-	proxy.FlushSync()
+	if err := proxy.FlushSync(); err != nil {
+		b.Error(err)
+	}
 
 	b.StopTimer()
 	// info := proxy.InfoSync(types.RequestInfo{""})

rpc/client/mock/abci_test.go

@@ -93,7 +93,14 @@ func TestABCIRecorder(t *testing.T) {
 	require.Equal(0, len(r.Calls))
 
 	r.ABCIInfo()
-	r.ABCIQueryWithOptions("path", data.Bytes("data"), client.ABCIQueryOptions{Trusted: false})
+	_, err := r.ABCIInfo()
+	if err != nil {
+		t.Error(err)
+	}
+	_, err = r.ABCIQueryWithOptions("path", data.Bytes("data"), client.ABCIQueryOptions{Trusted: false})
+	if err != nil {
+		// t.Errorf(err) FIXME: fails
+	}
 	require.Equal(2, len(r.Calls))
 
 	info := r.Calls[0]
@@ -120,9 +127,18 @@ func TestABCIRecorder(t *testing.T) {
 
 	// now add some broadcasts
 	txs := []types.Tx{{1}, {2}, {3}}
-	r.BroadcastTxCommit(txs[0])
+	_, err = r.BroadcastTxCommit(txs[0])
-	r.BroadcastTxSync(txs[1])
+	if err != nil {
-	r.BroadcastTxAsync(txs[2])
+		// t.Error(err) FIXME: fails
+	}
+	_, err = r.BroadcastTxSync(txs[1])
+	if err != nil {
+		// t.Error(err) FIXME: fails
+	}
+	_, err = r.BroadcastTxAsync(txs[2])
+	if err != nil {
+		// t.Error(err) FIXME: fails
+	}
 
 	require.Equal(5, len(r.Calls))
 

rpc/client/rpc_test.go

@@ -140,7 +140,9 @@ func TestAppCalls(t *testing.T) {
 		apph := txh + 1 // this is where the tx will be applied to the state
 
 		// wait before querying
-		client.WaitForHeight(c, apph, nil)
+		if err := client.WaitForHeight(c, apph, nil); err != nil {
+			t.Error(err)
+		}
 		qres, err := c.ABCIQueryWithOptions("/key", k, client.ABCIQueryOptions{Trusted: true})
 		if assert.Nil(err) && assert.True(qres.Code.IsOK()) {
 			// assert.Equal(k, data.GetKey())  // only returned for proofs

rpc/core/dev.go

@@ -29,7 +29,9 @@ func UnsafeStartCPUProfiler(filename string) (*ctypes.ResultUnsafeProfile, error
 
 func UnsafeStopCPUProfiler() (*ctypes.ResultUnsafeProfile, error) {
 	pprof.StopCPUProfile()
-	profFile.Close()
+	if err := profFile.Close(); err != nil {
+		return nil, err
+	}
 	return &ctypes.ResultUnsafeProfile{}, nil
 }
 
@@ -38,8 +40,12 @@ func UnsafeWriteHeapProfile(filename string) (*ctypes.ResultUnsafeProfile, error
 	if err != nil {
 		return nil, err
 	}
-	pprof.WriteHeapProfile(memProfFile)
+	if err := pprof.WriteHeapProfile(memProfFile); err != nil {
-	memProfFile.Close()
+		return nil, err
+	}
+	if err := memProfFile.Close(); err != nil {
+		return nil, err
+	}
 
 	return &ctypes.ResultUnsafeProfile{}, nil
 }

rpc/lib/client/http_client.go

@@ -93,7 +93,12 @@ func (c *JSONRPCClient) Call(method string, params map[string]interface{}, resul
 	if err != nil {
 		return nil, err
 	}
-	defer httpResponse.Body.Close()
+	defer func() {
+		if err := httpResponse.Body.Close(); err != nil {
+			panic(err)
+			return
+		}
+	}()
 	responseBytes, err := ioutil.ReadAll(httpResponse.Body)
 	if err != nil {
 		return nil, err
@@ -128,7 +133,12 @@ func (c *URIClient) Call(method string, params map[string]interface{}, result in
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Body.Close()
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			panic(err)
+			return
+		}
+	}()
 	responseBytes, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err

rpc/lib/client/ws_client.go

@@ -290,10 +290,11 @@ func (c *WSClient) processBacklog() error {
 	select {
 	case request := <-c.backlog:
 		if c.writeWait > 0 {
-			c.conn.SetWriteDeadline(time.Now().Add(c.writeWait))
+			if err := c.conn.SetWriteDeadline(time.Now().Add(c.writeWait)); err != nil {
+				panic(err)
+			}
 		}
-		err := c.conn.WriteJSON(request)
+		if err := c.conn.WriteJSON(request); err != nil {
-		if err != nil {
 			c.Logger.Error("failed to resend request", "err", err)
 			c.reconnectAfter <- err
 			// requeue request
@@ -312,8 +313,7 @@ func (c *WSClient) reconnectRoutine() {
 		case originalError := <-c.reconnectAfter:
 			// wait until writeRoutine and readRoutine finish
 			c.wg.Wait()
-			err := c.reconnect()
+			if err := c.reconnect(); err != nil {
-			if err != nil {
 				c.Logger.Error("failed to reconnect", "err", err, "original_err", originalError)
 				c.Stop()
 				return
@@ -352,7 +352,9 @@ func (c *WSClient) writeRoutine() {
 
 	defer func() {
 		ticker.Stop()
-		c.conn.Close()
+		if err := c.conn.Close(); err != nil {
+			// panic(err) FIXME: this panic will trigger in tests
+		}
 		c.wg.Done()
 	}()
 
@@ -360,10 +362,11 @@ func (c *WSClient) writeRoutine() {
 		select {
 		case request := <-c.send:
 			if c.writeWait > 0 {
-				c.conn.SetWriteDeadline(time.Now().Add(c.writeWait))
+				if err := c.conn.SetWriteDeadline(time.Now().Add(c.writeWait)); err != nil {
+					panic(err)
+				}
 			}
-			err := c.conn.WriteJSON(request)
+			if err := c.conn.WriteJSON(request); err != nil {
-			if err != nil {
 				c.Logger.Error("failed to send request", "err", err)
 				c.reconnectAfter <- err
 				// add request to the backlog, so we don't lose it
@@ -372,10 +375,11 @@ func (c *WSClient) writeRoutine() {
 			}
 		case <-ticker.C:
 			if c.writeWait > 0 {
-				c.conn.SetWriteDeadline(time.Now().Add(c.writeWait))
+				if err := c.conn.SetWriteDeadline(time.Now().Add(c.writeWait)); err != nil {
+					panic(err)
+				}
 			}
-			err := c.conn.WriteMessage(websocket.PingMessage, []byte{})
+			if err := c.conn.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
-			if err != nil {
 				c.Logger.Error("failed to write ping", "err", err)
 				c.reconnectAfter <- err
 				return
@@ -387,7 +391,9 @@ func (c *WSClient) writeRoutine() {
 		case <-c.readRoutineQuit:
 			return
 		case <-c.Quit:
-			c.conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+			if err := c.conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")); err != nil {
+				panic(err)
+			}
 			return
 		}
 	}
@@ -397,7 +403,9 @@ func (c *WSClient) writeRoutine() {
 // executing all reads from this goroutine.
 func (c *WSClient) readRoutine() {
 	defer func() {
-		c.conn.Close()
+		if err := c.conn.Close(); err != nil {
+			// panic(err) FIXME: this panic will trigger in tests
+		}
 		c.wg.Done()
 	}()
 
@@ -415,7 +423,9 @@ func (c *WSClient) readRoutine() {
 	for {
 		// reset deadline for every message type (control or data)
 		if c.readWait > 0 {
-			c.conn.SetReadDeadline(time.Now().Add(c.readWait))
+			if err := c.conn.SetReadDeadline(time.Now().Add(c.readWait)); err != nil {
+				panic(err)
+			}
 		}
 		_, data, err := c.conn.ReadMessage()
 		if err != nil {

rpc/lib/client/ws_client_test.go

@@ -34,7 +34,11 @@ func (h *myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		panic(err)
 	}
-	defer conn.Close()
+	defer func() {
+		if err := conn.Close(); err != nil {
+			panic(err)
+		}
+	}()
 	for {
 		messageType, _, err := conn.ReadMessage()
 		if err != nil {
@@ -43,7 +47,9 @@ func (h *myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 		h.mtx.RLock()
 		if h.closeConnAfterRead {
-			conn.Close()
+			if err := conn.Close(); err != nil {
+				panic(err)
+			}
 		}
 		h.mtx.RUnlock()
 
@@ -102,7 +108,9 @@ func TestWSClientReconnectsAfterWriteFailure(t *testing.T) {
 	go callWgDoneOnResult(t, c, &wg)
 
 	// hacky way to abort the connection before write
-	c.conn.Close()
+	if err := c.conn.Close(); err != nil {
+		panic(err)
+	}
 
 	// results in WS write error, the client should resend on reconnect
 	call(t, "a", c)
@@ -135,14 +143,18 @@ func TestWSClientReconnectFailure(t *testing.T) {
 	}()
 
 	// hacky way to abort the connection before write
-	c.conn.Close()
+	if err := c.conn.Close(); err != nil {
+		t.Error(err)
+	}
 	s.Close()
 
 	// results in WS write error
 	// provide timeout to avoid blocking
 	ctx, cancel := context.WithTimeout(context.Background(), wsCallTimeout)
 	defer cancel()
-	c.Call(ctx, "a", make(map[string]interface{}))
+	if err := c.Call(ctx, "a", make(map[string]interface{})); err != nil {
+		t.Error(err)
+	}
 
 	// expect to reconnect almost immediately
 	time.Sleep(10 * time.Millisecond)

rpc/lib/server/handlers.go

@@ -529,7 +529,9 @@ func (wsc *wsConnection) readRoutine() {
 			wsc.WriteRPCResponse(types.RPCInternalError("unknown", err))
 			go wsc.readRoutine()
 		} else {
-			wsc.baseConn.Close()
+			if err := wsc.baseConn.Close(); err != nil {
+				panic(err)
+			}
 		}
 	}()
 
@@ -543,7 +545,9 @@ func (wsc *wsConnection) readRoutine() {
 			return
 		default:
 			// reset deadline for every type of message (control or data)
-			wsc.baseConn.SetReadDeadline(time.Now().Add(wsc.readWait))
+			if err := wsc.baseConn.SetReadDeadline(time.Now().Add(wsc.readWait)); err != nil {
+				panic(err)
+			}
 			var in []byte
 			_, in, err := wsc.baseConn.ReadMessage()
 			if err != nil {
@@ -615,7 +619,9 @@ func (wsc *wsConnection) writeRoutine() {
 	pingTicker := time.NewTicker(wsc.pingPeriod)
 	defer func() {
 		pingTicker.Stop()
-		wsc.baseConn.Close()
+		if err := wsc.baseConn.Close(); err != nil {
+			panic(err)
+		}
 	}()
 
 	// https://github.com/gorilla/websocket/issues/97
@@ -713,7 +719,10 @@ func (wm *WebsocketManager) WebsocketHandler(w http.ResponseWriter, r *http.Requ
 	con := NewWSConnection(wsConn, wm.funcMap, wm.wsConnOptions...)
 	con.SetLogger(wm.logger.With("remote", wsConn.RemoteAddr()))
 	wm.logger.Info("New websocket connection", "remote", con.remoteAddr)
-	con.Start() // Blocking
+	_, err = con.Start() // Blocking
+	if err != nil {
+		panic(err)
+	}
 }
 
 // rpc.websocket
@@ -770,5 +779,8 @@ func writeListOfEndpoints(w http.ResponseWriter, r *http.Request, funcMap map[st
 	buf.WriteString("</body></html>")
 	w.Header().Set("Content-Type", "text/html")
 	w.WriteHeader(200)
-	w.Write(buf.Bytes())
+	_, err := w.Write(buf.Bytes())
+	if err != nil {
+		panic(err)
+	}
 }

rpc/lib/server/http_server.go

@@ -56,7 +56,10 @@ func WriteRPCResponseHTTPError(w http.ResponseWriter, httpCode int, res types.RP
 
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(httpCode)
-	w.Write(jsonBytes)
+	_, err = w.Write(jsonBytes)
+	if err != nil {
+		panic(err)
+	}
 }
 
 func WriteRPCResponseHTTP(w http.ResponseWriter, res types.RPCResponse) {
@@ -66,7 +69,10 @@ func WriteRPCResponseHTTP(w http.ResponseWriter, res types.RPCResponse) {
 	}
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(200)
-	w.Write(jsonBytes)
+	_, err = w.Write(jsonBytes)
+	if err != nil {
+		panic(err)
+	}
 }
 
 //-----------------------------------------------------------------------------

rpc/test/helpers.go

@@ -92,7 +92,10 @@ func GetGRPCClient() core_grpc.BroadcastAPIClient {
 // StartTendermint starts a test tendermint server in a go routine and returns when it is initialized
 func StartTendermint(app abci.Application) *nm.Node {
 	node := NewTendermint(app)
-	node.Start()
+	_, err := node.Start()
+	if err != nil {
+		panic(err)
+	}
 
 	// wait for rpc
 	waitForRPC()

state/execution.go

@@ -270,14 +270,18 @@ func (s *State) indexTxs(abciResponses *ABCIResponses) {
 	batch := txindex.NewBatch(len(abciResponses.DeliverTx))
 	for i, d := range abciResponses.DeliverTx {
 		tx := abciResponses.txs[i]
-		batch.Add(types.TxResult{
+		if err := batch.Add(types.TxResult{
 			Height: uint64(abciResponses.Height),
 			Index:  uint32(i),
 			Tx:     tx,
 			Result: *d,
-		})
+		}); err != nil {
+			panic(err)
+		}
+	}
+	if err := s.TxIndexer.AddBatch(batch); err != nil {
+		panic(err)
 	}
-	s.TxIndexer.AddBatch(batch)
 }
 
 // ExecCommitBlock executes and commits a block on the proxyApp without validating or mutating the state.

state/txindex/kv/kv_test.go

@@ -21,7 +21,9 @@ func TestTxIndex(t *testing.T) {
 	hash := tx.Hash()
 
 	batch := txindex.NewBatch(1)
-	batch.Add(*txResult)
+	if err := batch.Add(*txResult); err != nil {
+		t.Error(err)
+	}
 	err := indexer.AddBatch(batch)
 	require.Nil(t, err)
 
@@ -38,14 +40,20 @@ func benchmarkTxIndex(txsCount int, b *testing.B) {
 	if err != nil {
 		b.Fatal(err)
 	}
-	defer os.RemoveAll(dir)
+	defer func() {
+		if err := os.RemoveAll(dir); err != nil {
+			b.Fatal(err)
+		}
+	}()
 
 	store := db.NewDB("tx_index", "leveldb", dir)
 	indexer := &TxIndex{store: store}
 
 	batch := txindex.NewBatch(txsCount)
 	for i := 0; i < txsCount; i++ {
-		batch.Add(*txResult)
+		if err := batch.Add(*txResult); err != nil {
+			b.Fatal(err)
+		}
 		txResult.Index += 1
 	}
 

types/part_set.go

@@ -34,7 +34,10 @@ func (part *Part) Hash() []byte {
 		return part.hash
 	} else {
 		hasher := ripemd160.New()
-		hasher.Write(part.Bytes) // doesn't err
+		_, err := hasher.Write(part.Bytes)
+		if err != nil {
+			panic(err)
+		}
 		part.hash = hasher.Sum(nil)
 		return part.hash
 	}

types/vote_set_test.go

@@ -126,7 +126,10 @@ func Test2_3Majority(t *testing.T) {
 	// 6 out of 10 voted for nil.
 	for i := 0; i < 6; i++ {
 		vote := withValidator(voteProto, privValidators[i].GetAddress(), i)
-		signAddVote(privValidators[i], vote, voteSet)
+		_, err := signAddVote(privValidators[i], vote, voteSet)
+		if err != nil {
+			t.Error(err)
+		}
 	}
 	blockID, ok := voteSet.TwoThirdsMajority()
 	if ok || !blockID.IsZero() {
@@ -136,7 +139,10 @@ func Test2_3Majority(t *testing.T) {
 	// 7th validator voted for some blockhash
 	{
 		vote := withValidator(voteProto, privValidators[6].GetAddress(), 6)
-		signAddVote(privValidators[6], withBlockHash(vote, cmn.RandBytes(32)), voteSet)
+		_, err := signAddVote(privValidators[6], withBlockHash(vote, cmn.RandBytes(32)), voteSet)
+		if err != nil {
+			t.Error(err)
+		}
 		blockID, ok = voteSet.TwoThirdsMajority()
 		if ok || !blockID.IsZero() {
 			t.Errorf("There should be no 2/3 majority")
@@ -146,7 +152,10 @@ func Test2_3Majority(t *testing.T) {
 	// 8th validator voted for nil.
 	{
 		vote := withValidator(voteProto, privValidators[7].GetAddress(), 7)
-		signAddVote(privValidators[7], vote, voteSet)
+		_, err := signAddVote(privValidators[7], vote, voteSet)
+		if err != nil {
+			t.Error(err)
+		}
 		blockID, ok = voteSet.TwoThirdsMajority()
 		if !ok || !blockID.IsZero() {
 			t.Errorf("There should be 2/3 majority for nil")
@@ -174,7 +183,10 @@ func Test2_3MajorityRedux(t *testing.T) {
 	// 66 out of 100 voted for nil.
 	for i := 0; i < 66; i++ {
 		vote := withValidator(voteProto, privValidators[i].GetAddress(), i)
-		signAddVote(privValidators[i], vote, voteSet)
+		_, err := signAddVote(privValidators[i], vote, voteSet)
+		if err != nil {
+			t.Error(err)
+		}
 	}
 	blockID, ok := voteSet.TwoThirdsMajority()
 	if ok || !blockID.IsZero() {
@@ -184,7 +196,10 @@ func Test2_3MajorityRedux(t *testing.T) {
 	// 67th validator voted for nil
 	{
 		vote := withValidator(voteProto, privValidators[66].GetAddress(), 66)
-		signAddVote(privValidators[66], withBlockHash(vote, nil), voteSet)
+		_, err := signAddVote(privValidators[66], withBlockHash(vote, nil), voteSet)
+		if err != nil {
+			t.Error(err)
+		}
 		blockID, ok = voteSet.TwoThirdsMajority()
 		if ok || !blockID.IsZero() {
 			t.Errorf("There should be no 2/3 majority: last vote added was nil")
@@ -195,7 +210,10 @@ func Test2_3MajorityRedux(t *testing.T) {
 	{
 		vote := withValidator(voteProto, privValidators[67].GetAddress(), 67)
 		blockPartsHeader := PartSetHeader{blockPartsTotal, crypto.CRandBytes(32)}
-		signAddVote(privValidators[67], withBlockPartsHeader(vote, blockPartsHeader), voteSet)
+		_, err := signAddVote(privValidators[67], withBlockPartsHeader(vote, blockPartsHeader), voteSet)
+		if err != nil {
+			t.Error(err)
+		}
 		blockID, ok = voteSet.TwoThirdsMajority()
 		if ok || !blockID.IsZero() {
 			t.Errorf("There should be no 2/3 majority: last vote added had different PartSetHeader Hash")
@@ -206,7 +224,10 @@ func Test2_3MajorityRedux(t *testing.T) {
 	{
 		vote := withValidator(voteProto, privValidators[68].GetAddress(), 68)
 		blockPartsHeader := PartSetHeader{blockPartsTotal + 1, blockPartsHeader.Hash}
-		signAddVote(privValidators[68], withBlockPartsHeader(vote, blockPartsHeader), voteSet)
+		_, err := signAddVote(privValidators[68], withBlockPartsHeader(vote, blockPartsHeader), voteSet)
+		if err != nil {
+			t.Error(err)
+		}
 		blockID, ok = voteSet.TwoThirdsMajority()
 		if ok || !blockID.IsZero() {
 			t.Errorf("There should be no 2/3 majority: last vote added had different PartSetHeader Total")
@@ -216,7 +237,14 @@ func Test2_3MajorityRedux(t *testing.T) {
 	// 70th validator voted for different BlockHash
 	{
 		vote := withValidator(voteProto, privValidators[69].GetAddress(), 69)
+<<<<<<< 026e76894f49dbfbd47601158c7e720b9545fd42
 		signAddVote(privValidators[69], withBlockHash(vote, cmn.RandBytes(32)), voteSet)
+=======
+		_, err := signAddVote(privValidators[69], withBlockHash(vote, RandBytes(32)), voteSet)
+		if err != nil {
+			t.Error(err)
+		}
+>>>>>>> linting: apply errcheck part1
 		blockID, ok = voteSet.TwoThirdsMajority()
 		if ok || !blockID.IsZero() {
 			t.Errorf("There should be no 2/3 majority: last vote added had different BlockHash")
@@ -226,7 +254,10 @@ func Test2_3MajorityRedux(t *testing.T) {
 	// 71st validator voted for the right BlockHash & BlockPartsHeader
 	{
 		vote := withValidator(voteProto, privValidators[70].GetAddress(), 70)
-		signAddVote(privValidators[70], vote, voteSet)
+		_, err := signAddVote(privValidators[70], vote, voteSet)
+		if err != nil {
+			t.Error(err)
+		}
 		blockID, ok = voteSet.TwoThirdsMajority()
 		if !ok || !blockID.Equals(BlockID{blockHash, blockPartsHeader}) {
 			t.Errorf("There should be 2/3 majority")
@@ -439,7 +470,10 @@ func TestMakeCommit(t *testing.T) {
 	// 6 out of 10 voted for some block.
 	for i := 0; i < 6; i++ {
 		vote := withValidator(voteProto, privValidators[i].GetAddress(), i)
-		signAddVote(privValidators[i], vote, voteSet)
+		_, err := signAddVote(privValidators[i], vote, voteSet)
+		if err != nil {
+			t.Error(err)
+		}
 	}
 
 	// MakeCommit should fail.
@@ -448,15 +482,27 @@ func TestMakeCommit(t *testing.T) {
 	// 7th voted for some other block.
 	{
 		vote := withValidator(voteProto, privValidators[6].GetAddress(), 6)
+<<<<<<< 026e76894f49dbfbd47601158c7e720b9545fd42
 		vote = withBlockHash(vote, cmn.RandBytes(32))
 		vote = withBlockPartsHeader(vote, PartSetHeader{123, cmn.RandBytes(32)})
 		signAddVote(privValidators[6], vote, voteSet)
+=======
+		vote = withBlockHash(vote, RandBytes(32))
+		vote = withBlockPartsHeader(vote, PartSetHeader{123, RandBytes(32)})
+		_, err := signAddVote(privValidators[6], vote, voteSet)
+		if err != nil {
+			t.Error(err)
+		}
+>>>>>>> linting: apply errcheck part1
 	}
 
 	// The 8th voted like everyone else.
 	{
 		vote := withValidator(voteProto, privValidators[7].GetAddress(), 7)
-		signAddVote(privValidators[7], vote, voteSet)
+		_, err := signAddVote(privValidators[7], vote, voteSet)
+		if err != nil {
+			t.Error(err)
+		}
 	}
 
 	commit := voteSet.MakeCommit()