cleanup go-config/viper and some unnamed imports

2025-04-25 06:42:16 +00:00 · 2017-04-25 14:50:20 -04:00 · 2017-04-25 14:50:20 -04:00 · fcf78a5da7
commit fcf78a5da7
parent 72c4be35e8
27 changed files with 124 additions and 160 deletions
--- a/blockchain/reactor.go
+++ b/blockchain/reactor.go
@ -8,7 +8,6 @@ import (

 	"github.com/spf13/viper"

-	cfg "github.com/tendermint/go-config"
 	"github.com/tendermint/go-wire"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/proxy"
--- a/cmd/tendermint/commands/root.go
+++ b/cmd/tendermint/commands/root.go
@ -2,7 +2,6 @@ package commands

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

 	tmcfg "github.com/tendermint/tendermint/config/tendermint"
 	"github.com/tendermint/tmlibs/logger"
--- a/cmd/tendermint/commands/run_node.go
+++ b/cmd/tendermint/commands/run_node.go
@ -7,9 +7,9 @@ import (

 	"github.com/spf13/cobra"

-	. "github.com/tendermint/tmlibs/common"
 	"github.com/tendermint/tendermint/node"
 	"github.com/tendermint/tendermint/types"
+	cmn "github.com/tendermint/tmlibs/common"
 )

 var runNodeCmd = &cobra.Command{
@ -90,11 +90,11 @@ func runNode(cmd *cobra.Command, args []string) error {
 	// TODO: If Mintnet gets deprecated or genesis_file is
 	// always available, remove.
 	genDocFile := config.GetString("genesis_file")
-	if !FileExists(genDocFile) {
-		log.Notice(Fmt("Waiting for genesis file %v...", genDocFile))
+	if !cmn.FileExists(genDocFile) {
+		log.Notice(cmn.Fmt("Waiting for genesis file %v...", genDocFile))
 		for {
 			time.Sleep(time.Second)
-			if !FileExists(genDocFile) {
+			if !cmn.FileExists(genDocFile) {
 				continue
 			}
 			jsonBlob, err := ioutil.ReadFile(genDocFile)
--- a/config/tendermint/config.go
+++ b/config/tendermint/config.go
@ -6,9 +6,7 @@ import (
 	"strings"

 	"github.com/spf13/viper"
-
-	cfg "github.com/tendermint/go-config"
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"
 )

 func getTMRoot(rootDir string) string {
@ -27,16 +25,16 @@ func getTMRoot(rootDir string) string {

 func initTMRoot(rootDir string) {
 	rootDir = getTMRoot(rootDir)
-	EnsureDir(rootDir, 0700)
-	EnsureDir(rootDir+"/data", 0700)
+	cmn.EnsureDir(rootDir, 0700)
+	cmn.EnsureDir(rootDir+"/data", 0700)

 	configFilePath := path.Join(rootDir, "config.toml")

 	// Write default config file if missing.
-	if !FileExists(configFilePath) {
+	if !cmn.FileExists(configFilePath) {
 		// Ask user for moniker
 		// moniker := cfg.Prompt("Type hostname: ", "anonymous")
-		MustWriteFile(configFilePath, []byte(defaultConfig("anonymous")), 0644)
+		cmn.MustWriteFile(configFilePath, []byte(defaultConfig("anonymous")), 0644)
 	}
 }

@ -50,16 +48,16 @@ func GetConfig(rootDir string) *viper.Viper {
 	config.AddConfigPath(rootDir)
 	err := config.ReadInConfig()
 	if err != nil {
-		Exit(Fmt("Could not read config from directory %v: %v", rootDir, err))
+		cmn.Exit(cmn.Fmt("Could not read config from directory %v: %v", rootDir, err))
 	}
 	//config.WatchConfig()

 	// Set defaults or panic
 	if config.IsSet("chain_id") {
-		Exit("Cannot set 'chain_id' via config.toml")
+		cmn.Exit("Cannot set 'chain_id' via config.toml")
 	}
 	if config.IsSet("revision_file") {
-		Exit("Cannot set 'revision_file' via config.toml. It must match what's in the Makefile")
+		cmn.Exit("Cannot set 'revision_file' via config.toml. It must match what's in the Makefile")
 	}
 	//mapConfig.SetRequired("chain_id") // blows up if you try to use it before setting.
 	config.SetDefault("genesis_file", rootDir+"/genesis.json")
--- a/config/tendermint_test/config.go
+++ b/config/tendermint_test/config.go
@ -10,7 +10,6 @@ import (

 	"github.com/spf13/viper"

-	cfg "github.com/tendermint/go-config"
 	. "github.com/tendermint/tmlibs/common"
 	"github.com/tendermint/tmlibs/logger"
 )
@ -46,7 +45,6 @@ func initTMRoot(rootDir string) {
 	// Write default config file if missing.
 	if !FileExists(configFilePath) {
 		// Ask user for moniker
-		// moniker := cfg.Prompt("Type hostname: ", "anonymous")
 		MustWriteFile(configFilePath, []byte(defaultConfig("anonymous")), 0644)
 	}
 	if !FileExists(genesisFilePath) {
--- a/consensus/byzantine_test.go
+++ b/consensus/byzantine_test.go
@ -8,8 +8,6 @@ import (
 	"github.com/spf13/viper"

 	"github.com/tendermint/tendermint/config/tendermint_test"
-
-	cfg "github.com/tendermint/go-config"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/types"
 	. "github.com/tendermint/tmlibs/common"
--- a/consensus/common_test.go
+++ b/consensus/common_test.go
@ -15,7 +15,6 @@ import (

 	abcicli "github.com/tendermint/abci/client"
 	abci "github.com/tendermint/abci/types"
-	cfg "github.com/tendermint/go-config"
 	bc "github.com/tendermint/tendermint/blockchain"
 	"github.com/tendermint/tendermint/config/tendermint_test"
 	mempl "github.com/tendermint/tendermint/mempool"
--- a/consensus/replay.go
+++ b/consensus/replay.go
@ -13,10 +13,9 @@ import (
 	"github.com/spf13/viper"

 	abci "github.com/tendermint/abci/types"
-	cfg "github.com/tendermint/go-config"
 	"github.com/tendermint/go-wire"
 	auto "github.com/tendermint/tmlibs/autofile"
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"

 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
@ -110,7 +109,7 @@ func (cs *ConsensusState) catchupReplay(csHeight int) error {
 		gr.Close()
 	}
 	if found {
-		return errors.New(Fmt("WAL should not contain #ENDHEIGHT %d.", csHeight))
+		return errors.New(cmn.Fmt("WAL should not contain #ENDHEIGHT %d.", csHeight))
 	}

 	// Search for last height marker
@ -145,7 +144,7 @@ func (cs *ConsensusState) catchupReplay(csHeight int) error {
 		}

 		// TODO (0.10.0): uncomment
-		// return errors.New(Fmt("Cannot replay height %d. WAL does not contain #ENDHEIGHT for %d.", csHeight, csHeight-1))
+		// return errors.New(cmn.Fmt("Cannot replay height %d. WAL does not contain #ENDHEIGHT for %d.", csHeight, csHeight-1))
 	}

 	log.Notice("Catchup by replaying consensus messages", "height", csHeight)
@ -223,7 +222,7 @@ func (h *Handshaker) Handshake(proxyApp proxy.AppConns) error {
 	// handshake is done via info request on the query conn
 	res, err := proxyApp.Query().InfoSync()
 	if err != nil {
-		return errors.New(Fmt("Error calling Info: %v", err))
+		return errors.New(cmn.Fmt("Error calling Info: %v", err))
 	}

 	blockHeight := int(res.LastBlockHeight) // XXX: beware overflow
@ -240,7 +239,7 @@ func (h *Handshaker) Handshake(proxyApp proxy.AppConns) error {
 		return nil

 	} else if err != nil {
-		return errors.New(Fmt("Error on replay: %v", err))
+		return errors.New(cmn.Fmt("Error on replay: %v", err))
 	}

 	log.Notice("Completed ABCI Handshake - Tendermint and App are synced", "appHeight", blockHeight, "appHash", appHash)
@ -268,11 +267,11 @@ func (h *Handshaker) ReplayBlocks(appHash []byte, appBlockHeight int, proxyApp p

 	} else if storeBlockHeight < stateBlockHeight {
 		// the state should never be ahead of the store (this is under tendermint's control)
-		PanicSanity(Fmt("StateBlockHeight (%d) > StoreBlockHeight (%d)", stateBlockHeight, storeBlockHeight))
+		cmn.PanicSanity(cmn.Fmt("StateBlockHeight (%d) > StoreBlockHeight (%d)", stateBlockHeight, storeBlockHeight))

 	} else if storeBlockHeight > stateBlockHeight+1 {
 		// store should be at most one ahead of the state (this is under tendermint's control)
-		PanicSanity(Fmt("StoreBlockHeight (%d) > StateBlockHeight + 1 (%d)", storeBlockHeight, stateBlockHeight+1))
+		cmn.PanicSanity(cmn.Fmt("StoreBlockHeight (%d) > StateBlockHeight + 1 (%d)", storeBlockHeight, stateBlockHeight+1))
 	}

 	// Now either store is equal to state, or one ahead.
@ -315,7 +314,7 @@ func (h *Handshaker) ReplayBlocks(appHash []byte, appBlockHeight int, proxyApp p

 	}

-	PanicSanity("Should never happen")
+	cmn.PanicSanity("Should never happen")
 	return nil, nil
 }

@ -370,7 +369,7 @@ func (h *Handshaker) replayBlock(height int, proxyApp proxy.AppConnConsensus) ([

 func (h *Handshaker) checkAppHash(appHash []byte) error {
 	if !bytes.Equal(h.state.AppHash, appHash) {
-		panic(errors.New(Fmt("Tendermint state.AppHash does not match AppHash after replay. Got %X, expected %X", appHash, h.state.AppHash)).Error())
+		panic(errors.New(cmn.Fmt("Tendermint state.AppHash does not match AppHash after replay. Got %X, expected %X", appHash, h.state.AppHash)).Error())
 		return nil
 	}
 	return nil
--- a/consensus/replay_file.go
+++ b/consensus/replay_file.go
@ -10,13 +10,12 @@ import (

 	"github.com/spf13/viper"

-	cfg "github.com/tendermint/go-config"
 	bc "github.com/tendermint/tendermint/blockchain"
 	mempl "github.com/tendermint/tendermint/mempool"
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"
 	dbm "github.com/tendermint/tmlibs/db"
 )

@ -27,7 +26,7 @@ func RunReplayFile(config *viper.Viper, walFile string, console bool) {
 	consensusState := newConsensusStateForReplay(config)

 	if err := consensusState.ReplayFile(walFile, console); err != nil {
-		Exit(Fmt("Error during consensus replay: %v", err))
+		cmn.Exit(cmn.Fmt("Error during consensus replay: %v", err))
 	}
 }

@ -116,7 +115,7 @@ func (pb *playback) replayReset(count int, newStepCh chan interface{}) error {
 	pb.fp = fp
 	pb.scanner = bufio.NewScanner(fp)
 	count = pb.count - count
-	log.Notice(Fmt("Reseting from %d to %d", pb.count, count))
+	log.Notice(cmn.Fmt("Reseting from %d to %d", pb.count, count))
 	pb.count = 0
 	pb.cs = newCS
 	for i := 0; pb.scanner.Scan() && i < count; i++ {
@ -151,9 +150,9 @@ func (pb *playback) replayConsoleLoop() int {
 		bufReader := bufio.NewReader(os.Stdin)
 		line, more, err := bufReader.ReadLine()
 		if more {
-			Exit("input is too long")
+			cmn.Exit("input is too long")
 		} else if err != nil {
-			Exit(err.Error())
+			cmn.Exit(err.Error())
 		}

 		tokens := strings.Split(string(line), " ")
@ -251,7 +250,7 @@ func newConsensusStateForReplay(config *viper.Viper) *ConsensusState {
 	proxyApp := proxy.NewAppConns(config, proxy.DefaultClientCreator(config), NewHandshaker(config, state, blockStore))
 	_, err := proxyApp.Start()
 	if err != nil {
-		Exit(Fmt("Error starting proxy app conns: %v", err))
+		cmn.Exit(cmn.Fmt("Error starting proxy app conns: %v", err))
 	}

 	// add the chainid to the global config
@ -260,7 +259,7 @@ func newConsensusStateForReplay(config *viper.Viper) *ConsensusState {
 	// Make event switch
 	eventSwitch := types.NewEventSwitch()
 	if _, err := eventSwitch.Start(); err != nil {
-		Exit(Fmt("Failed to start event switch: %v", err))
+		cmn.Exit(cmn.Fmt("Failed to start event switch: %v", err))
 	}

 	mempool := mempl.NewMempool(config, proxyApp.Mempool())
--- a/consensus/replay_test.go
+++ b/consensus/replay_test.go
@ -15,7 +15,6 @@ import (
 	"github.com/spf13/viper"

 	"github.com/tendermint/abci/example/dummy"
-	cfg "github.com/tendermint/go-config"
 	"github.com/tendermint/go-crypto"
 	"github.com/tendermint/go-wire"
 	"github.com/tendermint/tendermint/config/tendermint_test"
--- a/consensus/state.go
+++ b/consensus/state.go
@ -12,12 +12,11 @@ import (
 	"github.com/ebuchman/fail-test"
 	"github.com/spf13/viper"

-	cfg "github.com/tendermint/go-config"
 	"github.com/tendermint/go-wire"
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"
 )

 //-----------------------------------------------------------------------------
@ -223,7 +222,7 @@ type PrivValidator interface {

 // Tracks consensus state across block heights and rounds.
 type ConsensusState struct {
-	BaseService
+	cmn.BaseService

 	config       *viper.Viper
 	proxyAppConn proxy.AppConnConsensus
@ -277,7 +276,7 @@ func NewConsensusState(config *viper.Viper, state *sm.State, proxyAppConn proxy.
 	// Don't call scheduleRound0 yet.
 	// We do that upon Start().
 	cs.reconstructLastCommit(state)
-	cs.BaseService = *NewBaseService(log, "ConsensusState", cs)
+	cs.BaseService = *cmn.NewBaseService(log, "ConsensusState", cs)
 	return cs
 }

@ -291,7 +290,7 @@ func (cs *ConsensusState) SetEventSwitch(evsw types.EventSwitch) {

 func (cs *ConsensusState) String() string {
 	// better not to access shared variables
-	return Fmt("ConsensusState") //(H:%v R:%v S:%v", cs.Height, cs.Round, cs.Step)
+	return cmn.Fmt("ConsensusState") //(H:%v R:%v S:%v", cs.Height, cs.Round, cs.Step)
 }

 func (cs *ConsensusState) GetState() *sm.State {
@ -399,7 +398,7 @@ func (cs *ConsensusState) Wait() {

 // Open file to log all consensus messages and timeouts for deterministic accountability
 func (cs *ConsensusState) OpenWAL(walFile string) (err error) {
-	err = EnsureDir(path.Dir(walFile), 0700)
+	err = cmn.EnsureDir(path.Dir(walFile), 0700)
 	if err != nil {
 		log.Error("Error ensuring ConsensusState wal dir", "error", err.Error())
 		return err
@ -520,11 +519,11 @@ func (cs *ConsensusState) reconstructLastCommit(state *sm.State) {
 		}
 		added, err := lastPrecommits.AddVote(precommit)
 		if !added || err != nil {
-			PanicCrisis(Fmt("Failed to reconstruct LastCommit: %v", err))
+			cmn.PanicCrisis(cmn.Fmt("Failed to reconstruct LastCommit: %v", err))
 		}
 	}
 	if !lastPrecommits.HasTwoThirdsMajority() {
-		PanicSanity("Failed to reconstruct LastCommit: Does not have +2/3 maj")
+		cmn.PanicSanity("Failed to reconstruct LastCommit: Does not have +2/3 maj")
 	}
 	cs.LastCommit = lastPrecommits
 }
@ -533,13 +532,13 @@ func (cs *ConsensusState) reconstructLastCommit(state *sm.State) {
 // The round becomes 0 and cs.Step becomes RoundStepNewHeight.
 func (cs *ConsensusState) updateToState(state *sm.State) {
 	if cs.CommitRound > -1 && 0 < cs.Height && cs.Height != state.LastBlockHeight {
-		PanicSanity(Fmt("updateToState() expected state height of %v but found %v",
+		cmn.PanicSanity(cmn.Fmt("updateToState() expected state height of %v but found %v",
 			cs.Height, state.LastBlockHeight))
 	}
 	if cs.state != nil && cs.state.LastBlockHeight+1 != cs.Height {
 		// This might happen when someone else is mutating cs.state.
 		// Someone forgot to pass in state.Copy() somewhere?!
-		PanicSanity(Fmt("Inconsistent cs.state.LastBlockHeight+1 %v vs cs.Height %v",
+		cmn.PanicSanity(cmn.Fmt("Inconsistent cs.state.LastBlockHeight+1 %v vs cs.Height %v",
 			cs.state.LastBlockHeight+1, cs.Height))
 	}

@ -556,7 +555,7 @@ func (cs *ConsensusState) updateToState(state *sm.State) {
 	lastPrecommits := (*types.VoteSet)(nil)
 	if cs.CommitRound > -1 && cs.Votes != nil {
 		if !cs.Votes.Precommits(cs.CommitRound).HasTwoThirdsMajority() {
-			PanicSanity("updateToState(state) called but last Precommit round didn't have +2/3")
+			cmn.PanicSanity("updateToState(state) called but last Precommit round didn't have +2/3")
 		}
 		lastPrecommits = cs.Votes.Precommits(cs.CommitRound)
 	}
@ -724,7 +723,7 @@ func (cs *ConsensusState) handleTimeout(ti timeoutInfo, rs RoundState) {
 		types.FireEventTimeoutWait(cs.evsw, cs.RoundStateEvent())
 		cs.enterNewRound(ti.Height, ti.Round+1)
 	default:
-		panic(Fmt("Invalid timeout step: %v", ti.Step))
+		panic(cmn.Fmt("Invalid timeout step: %v", ti.Step))
 	}

 }
@ -739,7 +738,7 @@ func (cs *ConsensusState) handleTimeout(ti timeoutInfo, rs RoundState) {
 // NOTE: cs.StartTime was already set for height.
 func (cs *ConsensusState) enterNewRound(height int, round int) {
 	if cs.Height != height || round < cs.Round || (cs.Round == round && cs.Step != RoundStepNewHeight) {
-		log.Debug(Fmt("enterNewRound(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+		log.Debug(cmn.Fmt("enterNewRound(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
 		return
 	}

@ -747,7 +746,7 @@ func (cs *ConsensusState) enterNewRound(height int, round int) {
 		log.Warn("Need to set a buffer and log.Warn() here for sanity.", "startTime", cs.StartTime, "now", now)
 	}

-	log.Notice(Fmt("enterNewRound(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+	log.Notice(cmn.Fmt("enterNewRound(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))

 	// Increment validators if necessary
 	validators := cs.Validators
@ -781,10 +780,10 @@ func (cs *ConsensusState) enterNewRound(height int, round int) {
 // Enter: from NewRound(height,round).
 func (cs *ConsensusState) enterPropose(height int, round int) {
 	if cs.Height != height || round < cs.Round || (cs.Round == round && RoundStepPropose <= cs.Step) {
-		log.Debug(Fmt("enterPropose(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+		log.Debug(cmn.Fmt("enterPropose(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
 		return
 	}
-	log.Info(Fmt("enterPropose(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+	log.Info(cmn.Fmt("enterPropose(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))

 	defer func() {
 		// Done enterPropose:
@ -851,7 +850,7 @@ func (cs *ConsensusState) defaultDecideProposal(height, round int) {
 			cs.sendInternalMessage(msgInfo{&BlockPartMessage{cs.Height, cs.Round, part}, ""})
 		}
 		log.Info("Signed proposal", "height", height, "round", round, "proposal", proposal)
-		log.Debug(Fmt("Signed proposal block: %v", block))
+		log.Debug(cmn.Fmt("Signed proposal block: %v", block))
 	} else {
 		if !cs.replayMode {
 			log.Warn("enterPropose: Error signing proposal", "height", height, "round", round, "error", err)
@ -907,7 +906,7 @@ func (cs *ConsensusState) createProposalBlock() (block *types.Block, blockParts
 // Otherwise vote nil.
 func (cs *ConsensusState) enterPrevote(height int, round int) {
 	if cs.Height != height || round < cs.Round || (cs.Round == round && RoundStepPrevote <= cs.Step) {
-		log.Debug(Fmt("enterPrevote(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+		log.Debug(cmn.Fmt("enterPrevote(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
 		return
 	}

@ -925,7 +924,7 @@ func (cs *ConsensusState) enterPrevote(height int, round int) {
 		// TODO: catchup event?
 	}

-	log.Info(Fmt("enterPrevote(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+	log.Info(cmn.Fmt("enterPrevote(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))

 	// Sign and broadcast vote as necessary
 	cs.doPrevote(height, round)
@ -968,13 +967,13 @@ func (cs *ConsensusState) defaultDoPrevote(height int, round int) {
 // Enter: any +2/3 prevotes at next round.
 func (cs *ConsensusState) enterPrevoteWait(height int, round int) {
 	if cs.Height != height || round < cs.Round || (cs.Round == round && RoundStepPrevoteWait <= cs.Step) {
-		log.Debug(Fmt("enterPrevoteWait(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+		log.Debug(cmn.Fmt("enterPrevoteWait(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
 		return
 	}
 	if !cs.Votes.Prevotes(round).HasTwoThirdsAny() {
-		PanicSanity(Fmt("enterPrevoteWait(%v/%v), but Prevotes does not have any +2/3 votes", height, round))
+		cmn.PanicSanity(cmn.Fmt("enterPrevoteWait(%v/%v), but Prevotes does not have any +2/3 votes", height, round))
 	}
-	log.Info(Fmt("enterPrevoteWait(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+	log.Info(cmn.Fmt("enterPrevoteWait(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))

 	defer func() {
 		// Done enterPrevoteWait:
@ -994,11 +993,11 @@ func (cs *ConsensusState) enterPrevoteWait(height int, round int) {
 // else, precommit nil otherwise.
 func (cs *ConsensusState) enterPrecommit(height int, round int) {
 	if cs.Height != height || round < cs.Round || (cs.Round == round && RoundStepPrecommit <= cs.Step) {
-		log.Debug(Fmt("enterPrecommit(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+		log.Debug(cmn.Fmt("enterPrecommit(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
 		return
 	}

-	log.Info(Fmt("enterPrecommit(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+	log.Info(cmn.Fmt("enterPrecommit(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))

 	defer func() {
 		// Done enterPrecommit:
@ -1025,7 +1024,7 @@ func (cs *ConsensusState) enterPrecommit(height int, round int) {
 	// the latest POLRound should be this round
 	polRound, _ := cs.Votes.POLInfo()
 	if polRound < round {
-		PanicSanity(Fmt("This POLRound should be %v but got %", round, polRound))
+		cmn.PanicSanity(cmn.Fmt("This POLRound should be %v but got %", round, polRound))
 	}

 	// +2/3 prevoted nil. Unlock and precommit nil.
@ -1059,7 +1058,7 @@ func (cs *ConsensusState) enterPrecommit(height int, round int) {
 		log.Notice("enterPrecommit: +2/3 prevoted proposal block. Locking", "hash", blockID.Hash)
 		// Validate the block.
 		if err := cs.state.ValidateBlock(cs.ProposalBlock); err != nil {
-			PanicConsensus(Fmt("enterPrecommit: +2/3 prevoted for an invalid block: %v", err))
+			cmn.PanicConsensus(cmn.Fmt("enterPrecommit: +2/3 prevoted for an invalid block: %v", err))
 		}
 		cs.LockedRound = round
 		cs.LockedBlock = cs.ProposalBlock
@ -1088,13 +1087,13 @@ func (cs *ConsensusState) enterPrecommit(height int, round int) {
 // Enter: any +2/3 precommits for next round.
 func (cs *ConsensusState) enterPrecommitWait(height int, round int) {
 	if cs.Height != height || round < cs.Round || (cs.Round == round && RoundStepPrecommitWait <= cs.Step) {
-		log.Debug(Fmt("enterPrecommitWait(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+		log.Debug(cmn.Fmt("enterPrecommitWait(%v/%v): Invalid args. Current step: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
 		return
 	}
 	if !cs.Votes.Precommits(round).HasTwoThirdsAny() {
-		PanicSanity(Fmt("enterPrecommitWait(%v/%v), but Precommits does not have any +2/3 votes", height, round))
+		cmn.PanicSanity(cmn.Fmt("enterPrecommitWait(%v/%v), but Precommits does not have any +2/3 votes", height, round))
 	}
-	log.Info(Fmt("enterPrecommitWait(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))
+	log.Info(cmn.Fmt("enterPrecommitWait(%v/%v). Current: %v/%v/%v", height, round, cs.Height, cs.Round, cs.Step))

 	defer func() {
 		// Done enterPrecommitWait:
@ -1110,10 +1109,10 @@ func (cs *ConsensusState) enterPrecommitWait(height int, round int) {
 // Enter: +2/3 precommits for block
 func (cs *ConsensusState) enterCommit(height int, commitRound int) {
 	if cs.Height != height || RoundStepCommit <= cs.Step {
-		log.Debug(Fmt("enterCommit(%v/%v): Invalid args. Current step: %v/%v/%v", height, commitRound, cs.Height, cs.Round, cs.Step))
+		log.Debug(cmn.Fmt("enterCommit(%v/%v): Invalid args. Current step: %v/%v/%v", height, commitRound, cs.Height, cs.Round, cs.Step))
 		return
 	}
-	log.Info(Fmt("enterCommit(%v/%v). Current: %v/%v/%v", height, commitRound, cs.Height, cs.Round, cs.Step))
+	log.Info(cmn.Fmt("enterCommit(%v/%v). Current: %v/%v/%v", height, commitRound, cs.Height, cs.Round, cs.Step))

 	defer func() {
 		// Done enterCommit:
@ -1129,7 +1128,7 @@ func (cs *ConsensusState) enterCommit(height int, commitRound int) {

 	blockID, ok := cs.Votes.Precommits(commitRound).TwoThirdsMajority()
 	if !ok {
-		PanicSanity("RunActionCommit() expects +2/3 precommits")
+		cmn.PanicSanity("RunActionCommit() expects +2/3 precommits")
 	}

 	// The Locked* fields no longer matter.
@ -1156,7 +1155,7 @@ func (cs *ConsensusState) enterCommit(height int, commitRound int) {
 // If we have the block AND +2/3 commits for it, finalize.
 func (cs *ConsensusState) tryFinalizeCommit(height int) {
 	if cs.Height != height {
-		PanicSanity(Fmt("tryFinalizeCommit() cs.Height: %v vs height: %v", cs.Height, height))
+		cmn.PanicSanity(cmn.Fmt("tryFinalizeCommit() cs.Height: %v vs height: %v", cs.Height, height))
 	}

 	blockID, ok := cs.Votes.Precommits(cs.CommitRound).TwoThirdsMajority()
@ -1177,7 +1176,7 @@ func (cs *ConsensusState) tryFinalizeCommit(height int) {
 // Increment height and goto RoundStepNewHeight
 func (cs *ConsensusState) finalizeCommit(height int) {
 	if cs.Height != height || cs.Step != RoundStepCommit {
-		log.Debug(Fmt("finalizeCommit(%v): Invalid args. Current step: %v/%v/%v", height, cs.Height, cs.Round, cs.Step))
+		log.Debug(cmn.Fmt("finalizeCommit(%v): Invalid args. Current step: %v/%v/%v", height, cs.Height, cs.Round, cs.Step))
 		return
 	}

@ -1185,21 +1184,21 @@ func (cs *ConsensusState) finalizeCommit(height int) {
 	block, blockParts := cs.ProposalBlock, cs.ProposalBlockParts

 	if !ok {
-		PanicSanity(Fmt("Cannot finalizeCommit, commit does not have two thirds majority"))
+		cmn.PanicSanity(cmn.Fmt("Cannot finalizeCommit, commit does not have two thirds majority"))
 	}
 	if !blockParts.HasHeader(blockID.PartsHeader) {
-		PanicSanity(Fmt("Expected ProposalBlockParts header to be commit header"))
+		cmn.PanicSanity(cmn.Fmt("Expected ProposalBlockParts header to be commit header"))
 	}
 	if !block.HashesTo(blockID.Hash) {
-		PanicSanity(Fmt("Cannot finalizeCommit, ProposalBlock does not hash to commit hash"))
+		cmn.PanicSanity(cmn.Fmt("Cannot finalizeCommit, ProposalBlock does not hash to commit hash"))
 	}
 	if err := cs.state.ValidateBlock(block); err != nil {
-		PanicConsensus(Fmt("+2/3 committed an invalid block: %v", err))
+		cmn.PanicConsensus(cmn.Fmt("+2/3 committed an invalid block: %v", err))
 	}

-	log.Notice(Fmt("Finalizing commit of block with %d txs", block.NumTxs),
+	log.Notice(cmn.Fmt("Finalizing commit of block with %d txs", block.NumTxs),
 		"height", block.Height, "hash", block.Hash(), "root", block.AppHash)
-	log.Info(Fmt("%v", block))
+	log.Info(cmn.Fmt("%v", block))

 	fail.Fail() // XXX

@ -1394,7 +1393,7 @@ func (cs *ConsensusState) addVote(vote *types.Vote, peerKey string) (added bool,
 		}
 		added, err = cs.LastCommit.AddVote(vote)
 		if added {
-			log.Info(Fmt("Added to lastPrecommits: %v", cs.LastCommit.StringShort()))
+			log.Info(cmn.Fmt("Added to lastPrecommits: %v", cs.LastCommit.StringShort()))
 			types.FireEventVote(cs.evsw, types.EventDataVote{vote})

 			// if we can skip timeoutCommit and have all the votes now,
@ -1475,7 +1474,7 @@ func (cs *ConsensusState) addVote(vote *types.Vote, peerKey string) (added bool,
 					cs.enterPrecommitWait(height, vote.Round)
 				}
 			default:
-				PanicSanity(Fmt("Unexpected vote type %X", vote.Type)) // Should not happen.
+				cmn.PanicSanity(cmn.Fmt("Unexpected vote type %X", vote.Type)) // Should not happen.
 			}
 		}
 		// Either duplicate, or error upon cs.Votes.AddByIndex()
--- a/glide.lock
+++ b/glide.lock
@ -1,12 +1,10 @@
-hash: 9096fc4e29eff8fac3708ed30deacac67b7a181f0192b177006105dccdb16686
-updated: 2017-04-21T18:39:37.154946943-04:00
+hash: 6f8962f6ca0e25b8e43bc6e496bd46c9ff3a79dcf789578efeeaee2fffc39c6e
+updated: 2017-04-25T14:48:36.999444976-04:00
 imports:
 - name: github.com/btcsuite/btcd
  version: 583684b21bfbde9b5fc4403916fd7c807feb0289
  subpackages:
  - btcec
- name: github.com/BurntSushi/toml
-  version: 99064174e013895bbd9b025c31100bd1d9b590ca
 - name: github.com/davecgh/go-spew
  version: 6d212800a42e8ab5c146b8ace3490ee17e5225f9
  subpackages:
@ -55,7 +53,7 @@ imports:
 - name: github.com/pelletier/go-buffruneio
  version: c37440a7cf42ac63b919c752ca73a85067e05992
 - name: github.com/pelletier/go-toml
-  version: fe206efb84b2bc8e8cfafe6b4c1826622be969e3
+  version: 13d49d4606eb801b8f01ae542b4afc4c6ee3d84a
 - name: github.com/pkg/errors
  version: 645ef00459ed84a119197bfb8d8205042c6df63d
 - name: github.com/pmezard/go-difflib
@ -67,7 +65,7 @@ imports:
  subpackages:
  - mem
 - name: github.com/spf13/cast
-  version: ce135a4ebeee6cfe9a26c93ee0d37825f26113c7
+  version: acbeb36b902d72a7a4c18e8f3241075e7ab763e4
 - name: github.com/spf13/cobra
  version: fcd0c5a1df88f5d6784cb4feead962c3f3d0b66c
 - name: github.com/spf13/jwalterweatherman
@ -75,7 +73,7 @@ imports:
 - name: github.com/spf13/pflag
  version: 9ff6c6923cfffbcd502984b8e0c80539a94968b7
 - name: github.com/spf13/viper
-  version: 84f94806c67f59dd7ae87bc5351f7a9c94a4558d
+  version: 5d46e70da8c0b6f812e0b170b7a985753b5c63cb
 - name: github.com/stretchr/testify
  version: 69483b4bd14f5845b5a1e55bca19e954e827f1d0
  subpackages:
@ -97,7 +95,7 @@ imports:
  - leveldb/table
  - leveldb/util
 - name: github.com/tendermint/abci
-  version: be61e273cebeb64866a83c578f92b22cf2169cdd
+  version: c709d3cc857929a8dd36a90da3640122d7e75770
  subpackages:
  - client
  - example/counter
@ -109,10 +107,6 @@ imports:
  subpackages:
  - edwards25519
  - extra25519
- name: github.com/tendermint/go-common
-  version: 6af2364fa91ef2f3afc8ba0db33b66d9d3ae006c
-  subpackages:
-  - test
 - name: github.com/tendermint/go-crypto
  version: 9b95da8fa4187f6799558d89b271dc8ab6485615
 - name: github.com/tendermint/go-wire
--- a/glide.yaml
+++ b/glide.yaml
@ -10,6 +10,7 @@ import:
 - package: github.com/gorilla/websocket
 - package: github.com/pkg/errors
 - package: github.com/spf13/cobra
+- package: github.com/spf13/viper
 - package: github.com/stretchr/testify
  subpackages:
  - require
@ -19,8 +20,6 @@ import:
  - client
  - example/dummy
  - types
- package: github.com/tendermint/go-config
-  version: develop
 - package: github.com/tendermint/go-crypto
  version: develop
 - package: github.com/tendermint/go-wire
@ -39,17 +38,6 @@ import:
  - flowrate
  - logger
  - merkle
- package: github.com/gogo/protobuf
-  version: ^0.3
-  subpackages:
-  - proto
- package: github.com/gorilla/websocket
-  version: ^1.1.0
- package: github.com/spf13/cobra
- package: github.com/spf13/viper
- package: github.com/spf13/pflag
- package: github.com/pkg/errors
-  version: ^0.8.0
 - package: golang.org/x/crypto
  subpackages:
  - nacl/box
--- a/mempool/mempool.go
+++ b/mempool/mempool.go
@ -10,7 +10,6 @@ import (
 	"github.com/spf13/viper"

 	abci "github.com/tendermint/abci/types"
-	cfg "github.com/tendermint/go-config"
 	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 	auto "github.com/tendermint/tmlibs/autofile"
--- a/mempool/reactor.go
+++ b/mempool/reactor.go
@ -9,7 +9,6 @@ import (
 	"github.com/spf13/viper"

 	abci "github.com/tendermint/abci/types"
-	cfg "github.com/tendermint/go-config"
 	"github.com/tendermint/go-wire"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/types"
--- a/node/node.go
+++ b/node/node.go
@ -10,7 +10,6 @@ import (
 	"github.com/spf13/viper"

 	abci "github.com/tendermint/abci/types"
-	cfg "github.com/tendermint/go-config"
 	crypto "github.com/tendermint/go-crypto"
 	wire "github.com/tendermint/go-wire"
 	bc "github.com/tendermint/tendermint/blockchain"
--- a/p2p/config.go
+++ b/p2p/config.go
@ -1,7 +1,7 @@
 package p2p

 import (
-	cfg "github.com/tendermint/go-config"
+	"github.com/spf13/viper"
 )

 const (
@ -24,7 +24,7 @@ const (
 	configFuzzProbSleep            = "fuzz_prob_sleep"
 )

-func setConfigDefaults(config cfg.Config) {
+func setConfigDefaults(config *viper.Viper) {
 	// Switch default config
 	config.SetDefault(configKeyDialTimeoutSeconds, 3)
 	config.SetDefault(configKeyHandshakeTimeoutSeconds, 20)
--- a/p2p/switch.go
+++ b/p2p/switch.go
@ -7,7 +7,8 @@ import (
 	"net"
 	"time"

-	cfg "github.com/tendermint/go-config"
+	"github.com/spf13/viper"
+
 	crypto "github.com/tendermint/go-crypto"
 	"github.com/tendermint/log15"
 	. "github.com/tendermint/tmlibs/common"
@ -61,7 +62,7 @@ incoming messages are received on the reactor.
 type Switch struct {
 	BaseService

-	config       cfg.Config
+	config       *viper.Viper
 	listeners    []Listener
 	reactors     map[string]Reactor
 	chDescs      []*ChannelDescriptor
@ -80,7 +81,7 @@ var (
 	ErrSwitchMaxPeersPerIPRange = errors.New("IP range has too many peers")
 )

-func NewSwitch(config cfg.Config) *Switch {
+func NewSwitch(config *viper.Viper) *Switch {
 	setConfigDefaults(config)

 	sw := &Switch{
@ -529,7 +530,7 @@ func makeSwitch(i int, network, version string, initSwitch func(int, *Switch) *S
 	privKey := crypto.GenPrivKeyEd25519()
 	// new switch, add reactors
 	// TODO: let the config be passed in?
-	s := initSwitch(i, NewSwitch(cfg.NewMapConfig(nil)))
+	s := initSwitch(i, NewSwitch(viper.New()))
 	s.SetNodeInfo(&NodeInfo{
 		PubKey:     privKey.PubKey().Unwrap().(crypto.PubKeyEd25519),
 		Moniker:    Fmt("switch%d", i),
@ -572,7 +573,7 @@ func (sw *Switch) addPeerWithConnectionAndConfig(conn net.Conn, config *PeerConf
 	return nil
 }

-func peerConfigFromGoConfig(config cfg.Config) *PeerConfig {
+func peerConfigFromGoConfig(config *viper.Viper) *PeerConfig {
 	return &PeerConfig{
 		AuthEnc:          config.GetBool(configKeyAuthEnc),
 		Fuzz:             config.GetBool(configFuzzEnable),
--- a/p2p/switch_test.go
+++ b/p2p/switch_test.go
@ -8,20 +8,21 @@ import (
 	"testing"
 	"time"

+	"github.com/spf13/viper"
+
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	. "github.com/tendermint/tmlibs/common"
-	cfg "github.com/tendermint/go-config"
 	crypto "github.com/tendermint/go-crypto"
 	wire "github.com/tendermint/go-wire"
+	. "github.com/tendermint/tmlibs/common"
 )

 var (
-	config cfg.Config
+	config *viper.Viper
 )

 func init() {
-	config = cfg.NewMapConfig(nil)
+	config = viper.New()
 	setConfigDefaults(config)
 }

--- a/proxy/app_conn_test.go
+++ b/proxy/app_conn_test.go
@ -4,11 +4,11 @@ import (
 	"strings"
 	"testing"

-	. "github.com/tendermint/tmlibs/common"
 	abcicli "github.com/tendermint/abci/client"
 	"github.com/tendermint/abci/example/dummy"
 	"github.com/tendermint/abci/server"
 	"github.com/tendermint/abci/types"
+	cmn "github.com/tendermint/tmlibs/common"
 )

 //----------------------------------------
@ -44,43 +44,43 @@ func (app *appConnTest) InfoSync() (types.ResponseInfo, error) {
 var SOCKET = "socket"

 func TestEcho(t *testing.T) {
-	sockPath := Fmt("unix:///tmp/echo_%v.sock", RandStr(6))
+	sockPath := cmn.Fmt("unix:///tmp/echo_%v.sock", cmn.RandStr(6))
 	clientCreator := NewRemoteClientCreator(sockPath, SOCKET, true)

 	// Start server
 	s, err := server.NewSocketServer(sockPath, dummy.NewDummyApplication())
 	if err != nil {
-		Exit(err.Error())
+		cmn.Exit(err.Error())
 	}
 	defer s.Stop()
 	// Start client
 	cli, err := clientCreator.NewABCIClient()
 	if err != nil {
-		Exit(err.Error())
+		cmn.Exit(err.Error())
 	}
 	proxy := NewAppConnTest(cli)
 	t.Log("Connected")

 	for i := 0; i < 1000; i++ {
-		proxy.EchoAsync(Fmt("echo-%v", i))
+		proxy.EchoAsync(cmn.Fmt("echo-%v", i))
 	}
 	proxy.FlushSync()
 }

 func BenchmarkEcho(b *testing.B) {
 	b.StopTimer() // Initialize
-	sockPath := Fmt("unix:///tmp/echo_%v.sock", RandStr(6))
+	sockPath := cmn.Fmt("unix:///tmp/echo_%v.sock", cmn.RandStr(6))
 	clientCreator := NewRemoteClientCreator(sockPath, SOCKET, true)
 	// Start server
 	s, err := server.NewSocketServer(sockPath, dummy.NewDummyApplication())
 	if err != nil {
-		Exit(err.Error())
+		cmn.Exit(err.Error())
 	}
 	defer s.Stop()
 	// Start client
 	cli, err := clientCreator.NewABCIClient()
 	if err != nil {
-		Exit(err.Error())
+		cmn.Exit(err.Error())
 	}
 	proxy := NewAppConnTest(cli)
 	b.Log("Connected")
@ -98,18 +98,18 @@ func BenchmarkEcho(b *testing.B) {
 }

 func TestInfo(t *testing.T) {
-	sockPath := Fmt("unix:///tmp/echo_%v.sock", RandStr(6))
+	sockPath := cmn.Fmt("unix:///tmp/echo_%v.sock", cmn.RandStr(6))
 	clientCreator := NewRemoteClientCreator(sockPath, SOCKET, true)
 	// Start server
 	s, err := server.NewSocketServer(sockPath, dummy.NewDummyApplication())
 	if err != nil {
-		Exit(err.Error())
+		cmn.Exit(err.Error())
 	}
 	defer s.Stop()
 	// Start client
 	cli, err := clientCreator.NewABCIClient()
 	if err != nil {
-		Exit(err.Error())
+		cmn.Exit(err.Error())
 	}
 	proxy := NewAppConnTest(cli)
 	t.Log("Connected")
--- a/proxy/multi_app_conn.go
+++ b/proxy/multi_app_conn.go
@ -2,7 +2,6 @@ package proxy

 import (
 	"github.com/spf13/viper"
-	cfg "github.com/tendermint/go-config"
 	cmn "github.com/tendermint/tmlibs/common"
 )

--- a/rpc/tendermint/core/pipe.go
+++ b/rpc/tendermint/core/pipe.go
@ -2,7 +2,6 @@ package core

 import (
 	"github.com/spf13/viper"
-	cfg "github.com/tendermint/go-config"

 	crypto "github.com/tendermint/go-crypto"
 	"github.com/tendermint/tendermint/consensus"
--- a/rpc/tendermint/test/helpers.go
+++ b/rpc/tendermint/test/helpers.go
@ -15,7 +15,6 @@ import (
 	logger "github.com/tendermint/tmlibs/logger"

 	abci "github.com/tendermint/abci/types"
-	cfg "github.com/tendermint/go-config"
 	"github.com/tendermint/tendermint/config/tendermint_test"
 	nm "github.com/tendermint/tendermint/node"
 	"github.com/tendermint/tendermint/proxy"
--- a/state/errors.go
+++ b/state/errors.go
@ -1,7 +1,7 @@
 package state

 import (
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"
 )

 type (
@ -36,20 +36,20 @@ type (
 )

 func (e ErrUnknownBlock) Error() string {
-	return Fmt("Could not find block #%d", e.Height)
+	return cmn.Fmt("Could not find block #%d", e.Height)
 }

 func (e ErrBlockHashMismatch) Error() string {
-	return Fmt("App block hash (%X) does not match core block hash (%X) for height %d", e.AppHash, e.CoreHash, e.Height)
+	return cmn.Fmt("App block hash (%X) does not match core block hash (%X) for height %d", e.AppHash, e.CoreHash, e.Height)
 }

 func (e ErrAppBlockHeightTooHigh) Error() string {
-	return Fmt("App block height (%d) is higher than core (%d)", e.AppHeight, e.CoreHeight)
+	return cmn.Fmt("App block height (%d) is higher than core (%d)", e.AppHeight, e.CoreHeight)
 }
 func (e ErrLastStateMismatch) Error() string {
-	return Fmt("Latest tendermint block (%d) LastAppHash (%X) does not match app's AppHash (%X)", e.Height, e.Core, e.App)
+	return cmn.Fmt("Latest tendermint block (%d) LastAppHash (%X) does not match app's AppHash (%X)", e.Height, e.Core, e.App)
 }

 func (e ErrStateMismatch) Error() string {
-	return Fmt("State after replay does not match saved state. Got ----\n%v\nExpected ----\n%v\n", e.Got, e.Expected)
+	return cmn.Fmt("State after replay does not match saved state. Got ----\n%v\nExpected ----\n%v\n", e.Got, e.Expected)
 }
--- a/state/execution.go
+++ b/state/execution.go
@ -6,11 +6,11 @@ import (

 	fail "github.com/ebuchman/fail-test"
 	abci "github.com/tendermint/abci/types"
-	. "github.com/tendermint/tmlibs/common"
 	crypto "github.com/tendermint/go-crypto"
 	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/state/txindex"
 	"github.com/tendermint/tendermint/types"
+	cmn "github.com/tendermint/tmlibs/common"
 )

 //--------------------------------------------------
@ -126,7 +126,7 @@ func updateValidators(validators *types.ValidatorSet, changedValidators []*abci.
 		power := int64(v.Power)
 		// mind the overflow from uint64
 		if power < 0 {
-			return errors.New(Fmt("Power (%d) overflows int64", v.Power))
+			return errors.New(cmn.Fmt("Power (%d) overflows int64", v.Power))
 		}

 		_, val := validators.GetByAddress(address)
@ -134,20 +134,20 @@ func updateValidators(validators *types.ValidatorSet, changedValidators []*abci.
 			// add val
 			added := validators.Add(types.NewValidator(pubkey, power))
 			if !added {
-				return errors.New(Fmt("Failed to add new validator %X with voting power %d", address, power))
+				return errors.New(cmn.Fmt("Failed to add new validator %X with voting power %d", address, power))
 			}
 		} else if v.Power == 0 {
 			// remove val
 			_, removed := validators.Remove(address)
 			if !removed {
-				return errors.New(Fmt("Failed to remove validator %X)"))
+				return errors.New(cmn.Fmt("Failed to remove validator %X)"))
 			}
 		} else {
 			// update val
 			val.VotingPower = power
 			updated := validators.Update(val)
 			if !updated {
-				return errors.New(Fmt("Failed to update validator %X with voting power %d", address, power))
+				return errors.New(cmn.Fmt("Failed to update validator %X with voting power %d", address, power))
 			}
 		}
 	}
@ -156,8 +156,8 @@ func updateValidators(validators *types.ValidatorSet, changedValidators []*abci.

 // return a bit array of validators that signed the last commit
 // NOTE: assumes commits have already been authenticated
-func commitBitArrayFromBlock(block *types.Block) *BitArray {
-	signed := NewBitArray(len(block.LastCommit.Precommits))
+func commitBitArrayFromBlock(block *types.Block) *cmn.BitArray {
+	signed := cmn.NewBitArray(len(block.LastCommit.Precommits))
 	for i, precommit := range block.LastCommit.Precommits {
 		if precommit != nil {
 			signed.SetIndex(i, true) // val_.LastCommitHeight = block.Height - 1
@ -187,7 +187,7 @@ func (s *State) validateBlock(block *types.Block) error {
 		}
 	} else {
 		if len(block.LastCommit.Precommits) != s.LastValidators.Size() {
-			return errors.New(Fmt("Invalid block commit size. Expected %v, got %v",
+			return errors.New(cmn.Fmt("Invalid block commit size. Expected %v, got %v",
 				s.LastValidators.Size(), len(block.LastCommit.Precommits)))
 		}
 		err := s.LastValidators.VerifyCommit(
--- a/state/state.go
+++ b/state/state.go
@ -8,8 +8,7 @@ import (

 	"github.com/spf13/viper"
 	abci "github.com/tendermint/abci/types"
-	cfg "github.com/tendermint/go-config"
-	. "github.com/tendermint/tmlibs/common"
+	cmn "github.com/tendermint/tmlibs/common"
 	dbm "github.com/tendermint/tmlibs/db"

 	"github.com/tendermint/go-wire"
@ -66,7 +65,7 @@ func loadState(db dbm.DB, key []byte) *State {
 		wire.ReadBinaryPtr(&s, r, 0, n, err)
 		if *err != nil {
 			// DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
-			Exit(Fmt("LoadState: Data has been corrupted or its spec has changed: %v\n", *err))
+			cmn.Exit(cmn.Fmt("LoadState: Data has been corrupted or its spec has changed: %v\n", *err))
 		}
 		// TODO: ensure that buf is completely read.
 	}
@ -110,7 +109,7 @@ func (s *State) LoadABCIResponses() *ABCIResponses {
 		wire.ReadBinaryPtr(abciResponses, r, 0, n, err)
 		if *err != nil {
 			// DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
-			Exit(Fmt("LoadABCIResponses: Data has been corrupted or its spec has changed: %v\n", *err))
+			cmn.Exit(cmn.Fmt("LoadABCIResponses: Data has been corrupted or its spec has changed: %v\n", *err))
 		}
 		// TODO: ensure that buf is completely read.
 	}
@ -125,7 +124,7 @@ func (s *State) Bytes() []byte {
 	buf, n, err := new(bytes.Buffer), new(int), new(error)
 	wire.WriteBinary(s, buf, n, err)
 	if *err != nil {
-		PanicCrisis(*err)
+		cmn.PanicCrisis(*err)
 	}
 	return buf.Bytes()
 }
@ -205,7 +204,7 @@ func (a *ABCIResponses) Bytes() []byte {
 	buf, n, err := new(bytes.Buffer), new(int), new(error)
 	wire.WriteBinary(*a, buf, n, err)
 	if *err != nil {
-		PanicCrisis(*err)
+		cmn.PanicCrisis(*err)
 	}
 	return buf.Bytes()
 }
@ -219,11 +218,11 @@ func (a *ABCIResponses) Bytes() []byte {
 func MakeGenesisStateFromFile(db dbm.DB, genDocFile string) *State {
 	genDocJSON, err := ioutil.ReadFile(genDocFile)
 	if err != nil {
-		Exit(Fmt("Couldn't read GenesisDoc file: %v", err))
+		cmn.Exit(cmn.Fmt("Couldn't read GenesisDoc file: %v", err))
 	}
 	genDoc, err := types.GenesisDocFromJSON(genDocJSON)
 	if err != nil {
-		Exit(Fmt("Error reading GenesisDoc: %v", err))
+		cmn.Exit(cmn.Fmt("Error reading GenesisDoc: %v", err))
 	}
 	return MakeGenesisState(db, genDoc)
 }
@ -233,7 +232,7 @@ func MakeGenesisStateFromFile(db dbm.DB, genDocFile string) *State {
 // Used in tests.
 func MakeGenesisState(db dbm.DB, genDoc *types.GenesisDoc) *State {
 	if len(genDoc.Validators) == 0 {
-		Exit(Fmt("The genesis file has no validators"))
+		cmn.Exit(cmn.Fmt("The genesis file has no validators"))
 	}

 	if genDoc.GenesisTime.IsZero() {
--- a/test/test_libs.sh
+++ b/test/test_libs.sh
@ -14,8 +14,8 @@ fi

 # some libs are tested with go, others with make
 # TODO: should be all make (post repo merge)
-LIBS_GO_TEST=(tmlibs/clist tmlibs/common go-config go-crypto tmlibs/db tmlibs/events go-merkle tendermint/p2p)
-LIBS_MAKE_TEST=(tendermint/rpc go-wire abci)
+LIBS_GO_TEST=(tmlibs go-crypto)
+LIBS_MAKE_TEST=(go-wire abci)

 for lib in "${LIBS_GO_TEST[@]}"; do