From 6ab0c3936a4873c6881d489cf2c11b833dd6f0aa Mon Sep 17 00:00:00 2001
From: Aaron Craelius <aaron@regen.network>
Date: Sun, 24 Mar 2019 21:55:59 -0400
Subject: [PATCH 1/9] #13 WIP on improvements to upgrade module

---
 app.go                        |  22 +++++-
 testnets/next/genesis.json    |  15 +++-
 x/consortium/actions.go       |  28 +++++--
 x/consortium/client/cli/tx.go |  27 +++++--
 x/consortium/keeper.go        |  22 +++++-
 x/group/types.go              |   2 +-
 x/proposal/client/cli/tx.go   |   7 +-
 x/proposal/handler.go         |  14 +++-
 x/proposal/keeper.go          |  24 ++----
 x/proposal/msgs.go            |  28 ++++---
 x/proposal/router.go          |   2 +-
 x/upgrade/keeper.go           | 145 +++++++++++++++++++++++-----------
 12 files changed, 230 insertions(+), 106 deletions(-)

diff --git a/app.go b/app.go
index 9c591622d1..8c81ab32dd 100644
--- a/app.go
+++ b/app.go
@@ -11,7 +11,12 @@ import (
 	"github.com/regen-network/regen-ledger/x/group"
 	"github.com/regen-network/regen-ledger/x/proposal"
 	"github.com/regen-network/regen-ledger/x/upgrade"
+	"github.com/spf13/viper"
+	"github.com/tendermint/tendermint/libs/cli"
 	"github.com/tendermint/tendermint/libs/log"
+	"io/ioutil"
+	"path/filepath"
+
 	//"os"
 
 	"github.com/cosmos/cosmos-sdk/codec"
@@ -152,7 +157,11 @@ func NewXrnApp(logger log.Logger, db dbm.DB, postgresUrl string) *xrnApp {
 
 	app.espKeeper = esp.NewKeeper(app.espStoreKey, app.agentKeeper, app.geoKeeper, cdc)
 
-	app.upgradeKeeper = upgrade.NewKeeper(app.upgradeStoreKey, cdc, 1000)
+	app.upgradeKeeper = upgrade.NewKeeper(app.upgradeStoreKey, cdc)
+	app.upgradeKeeper.SetBeforeShutdowner(app.willUpgrade)
+	app.upgradeKeeper.SetUpgradeHandler("test3", func(ctx sdk.Context, plan upgrade.UpgradePlan) {
+		ctx.Logger().Info("In upgrade 3 handler!")
+	})
 
 	app.consortiumKeeper = consortium.NewKeeper(app.consortiumStoreKey, cdc, app.agentKeeper, app.upgradeKeeper)
 
@@ -230,8 +239,8 @@ func (app *xrnApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci.
 		app.accountKeeper.SetAccount(ctx, acc)
 	}
 
-	for _, group := range genesisState.Groups {
-		app.agentKeeper.CreateGroup(ctx, group)
+	for _, g := range genesisState.Groups {
+		app.agentKeeper.CreateGroup(ctx, g)
 	}
 
 	app.consortiumKeeper.SetValidators(ctx, req.Validators)
@@ -242,6 +251,13 @@ func (app *xrnApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci.
 	return abci.ResponseInitChain{}
 }
 
+func (app *xrnApp) willUpgrade(plan upgrade.UpgradePlan) {
+	if len(plan.Memo) != 0 {
+		home := viper.GetString(cli.HomeFlag)
+		_ = ioutil.WriteFile(filepath.Join(home, "data", "upgrade-info"), []byte(plan.Memo), 0644)
+	}
+}
+
 func (app *xrnApp) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock) abci.ResponseBeginBlock {
 	app.upgradeKeeper.BeginBlocker(ctx, req)
 	return abci.ResponseBeginBlock{}
diff --git a/testnets/next/genesis.json b/testnets/next/genesis.json
index 4b6024c291..794770e3dc 100644
--- a/testnets/next/genesis.json
+++ b/testnets/next/genesis.json
@@ -1,6 +1,6 @@
 {
   "genesis_time": "2018-12-19T20:40:06.463846Z",
-  "chain_id": "xrn-test-2",
+  "chain_id": "xrn-test-next",
   "consensus_params": {
     "block_size": {
       "max_bytes": "22020096",
@@ -60,7 +60,18 @@
         "sequence": "0"
       }
     ],
-    "groups": [],
+    "groups": [
+      {
+        "decision_threshold": "1",
+        "members": [
+          {
+            "address": "xrn:1xrsmkqh305m09tc5x73v4t3wtcuqmf6cgy2taw",
+            "weight": "1"
+          }
+        ],
+        "memo": "Regen Consortium"
+      }
+    ],
     "auth": {
       "collected_fees": null,
       "params": {
diff --git a/x/consortium/actions.go b/x/consortium/actions.go
index ce8e4eb3d2..e979af77ce 100644
--- a/x/consortium/actions.go
+++ b/x/consortium/actions.go
@@ -8,7 +8,10 @@ import (
 )
 
 type ActionScheduleUpgrade struct {
-	UpgradeInfo upgrade.UpgradeInfo `json:"upgrade_info"`
+	Plan upgrade.UpgradePlan `json:"upgrade_plan"`
+}
+
+type ActionCancelUpgrade struct {
 }
 
 /*
@@ -24,16 +27,29 @@ type ActionChangeValidatorSet struct {
 
 func (action ActionScheduleUpgrade) Route() string { return "consortium" }
 
-func (action ActionScheduleUpgrade) Type() string { return "upgrade" }
+func (action ActionScheduleUpgrade) Type() string { return "consortium.upgrade" }
 
 func (action ActionScheduleUpgrade) ValidateBasic() sdk.Error {
-	if action.UpgradeInfo.Height <= 0 {
-		return sdk.ErrUnknownRequest("Upgrade height must be greater than 0")
+	return action.Plan.ValidateBasic()
+}
+
+func (action ActionScheduleUpgrade) GetSignBytes() []byte {
+	b, err := json.Marshal(action)
+	if err != nil {
+		panic(err)
 	}
+	return sdk.MustSortJSON(b)
+}
+
+func (ActionCancelUpgrade) Route() string { return "consortium" }
+
+func (ActionCancelUpgrade) Type() string { return "consortium.cancel-upgrade" }
+
+func (ActionCancelUpgrade) ValidateBasic() sdk.Error {
 	return nil
 }
 
-func (action ActionScheduleUpgrade) GetSignBytes() []byte {
+func (action ActionCancelUpgrade) GetSignBytes() []byte {
 	b, err := json.Marshal(action)
 	if err != nil {
 		panic(err)
@@ -43,7 +59,7 @@ func (action ActionScheduleUpgrade) GetSignBytes() []byte {
 
 func (action ActionChangeValidatorSet) Route() string { return "consortium" }
 
-func (action ActionChangeValidatorSet) Type() string { return "changeValidatorSet" }
+func (action ActionChangeValidatorSet) Type() string { return "consortium.changeValidatorSet" }
 
 func (action ActionChangeValidatorSet) ValidateBasic() sdk.Error {
 	panic("implement me")
diff --git a/x/consortium/client/cli/tx.go b/x/consortium/client/cli/tx.go
index 43c7b5fe38..b49b737fd5 100644
--- a/x/consortium/client/cli/tx.go
+++ b/x/consortium/client/cli/tx.go
@@ -6,32 +6,43 @@ import (
 	proposalcli "github.com/regen-network/regen-ledger/x/proposal/client/cli"
 	"github.com/regen-network/regen-ledger/x/upgrade"
 	"github.com/spf13/cobra"
-	"strconv"
+	"time"
 
 	"github.com/cosmos/cosmos-sdk/codec"
 )
 
 func GetCmdProposeUpgrade(cdc *codec.Codec) *cobra.Command {
+	var timeStr string
+	var height int64
 	var memo string
 
 	cmd := proposalcli.GetCmdPropose(cdc, func(cmd *cobra.Command, args []string) (action proposal.ProposalAction, e error) {
-		blockHeightStr := args[0]
-		blockHeight, err := strconv.ParseInt(blockHeightStr, 10, 64)
-		if err != nil {
-			return nil, err
+		name := args[0]
+
+		var t time.Time
+		var err error
+		if len(timeStr) != 0 {
+			t, err = time.Parse(time.RFC3339, timeStr)
+			if err != nil {
+				panic(err)
+			}
 		}
 
 		return consortium.ActionScheduleUpgrade{
-			UpgradeInfo: upgrade.UpgradeInfo{
-				Height: blockHeight,
+			Plan: upgrade.UpgradePlan{
+				Name:   name,
+				Time:   t,
+				Height: height,
 				Memo:   memo,
 			},
 		}, nil
 	})
 
 	cmd.Args = cobra.ExactArgs(1)
-	cmd.Use = "propose-upgrade <block-height> [--upgrade-memo <memo>]"
+	cmd.Use = "propose-upgrade <name> [--upgrade-time <time> | --upgrade-height <height>] [--upgrade-memo <memo>]"
 	cmd.Short = "Propose an ESP version"
+	cmd.Flags().StringVar(&timeStr, "upgrade-time", "", "The time after which the upgrade must happen in ISO8601/RFC3339 format (omit if using --upgrade-height)")
+	cmd.Flags().Int64Var(&height, "upgrade-height", 0, "The height at which the upgrade must happen (omit if using --upgrade-time)")
 	cmd.Flags().StringVar(&memo, "upgrade-memo", "", "Any memo to attach to the upgrade plan such as a git commit hash")
 	return cmd
 }
diff --git a/x/consortium/keeper.go b/x/consortium/keeper.go
index c06a874c7b..2d0772b7bd 100644
--- a/x/consortium/keeper.go
+++ b/x/consortium/keeper.go
@@ -35,6 +35,8 @@ func (keeper Keeper) CheckProposal(ctx sdk.Context, action proposal.ProposalActi
 	switch action.(type) {
 	case ActionScheduleUpgrade:
 		return true, sdk.Result{Code: sdk.CodeOK}
+	case ActionCancelUpgrade:
+		return true, sdk.Result{Code: sdk.CodeOK}
 	case ActionChangeValidatorSet:
 		return true, sdk.Result{Code: sdk.CodeOK}
 	default:
@@ -46,6 +48,8 @@ func (keeper Keeper) HandleProposal(ctx sdk.Context, action proposal.ProposalAct
 	switch action := action.(type) {
 	case ActionScheduleUpgrade:
 		return keeper.handleActionScheduleUpgrade(ctx, action, voters)
+	case ActionCancelUpgrade:
+		return keeper.handleActionCancelUpgrade(ctx, action, voters)
 	case ActionChangeValidatorSet:
 		return keeper.handleActionChangeValidatorSet(ctx, action, voters)
 	default:
@@ -58,14 +62,26 @@ func (keeper Keeper) handleActionScheduleUpgrade(ctx sdk.Context, action ActionS
 	if !keeper.agentKeeper.Authorize(ctx, consortiumGroupId, signers) {
 		return sdk.Result{Code: sdk.CodeUnauthorized}
 	}
-	keeper.upgradeKeeper.ScheduleUpgrade(ctx, action.UpgradeInfo)
-	return sdk.Result{Code: sdk.CodeOK}
+	err := keeper.upgradeKeeper.ScheduleUpgrade(ctx, action.Plan)
+	if err != nil {
+		return err.Result()
+	}
+	return sdk.Result{}
+}
+
+func (keeper Keeper) handleActionCancelUpgrade(ctx sdk.Context, _ ActionCancelUpgrade, signers []sdk.AccAddress) sdk.Result {
+	if !keeper.agentKeeper.Authorize(ctx, consortiumGroupId, signers) {
+		return sdk.Result{Code: sdk.CodeUnauthorized}
+	}
+	keeper.upgradeKeeper.ClearUpgradePlan(ctx)
+	return sdk.Result{}
 }
 
 func (keeper Keeper) handleActionChangeValidatorSet(ctx sdk.Context, action ActionChangeValidatorSet, signers []sdk.AccAddress) sdk.Result {
 	keeper.SetValidators(ctx, action.Validators)
-	return sdk.Result{Code: sdk.CodeOK}
+	return sdk.Result{}
 }
+
 func (keeper Keeper) GetValidators(ctx sdk.Context) []abci.ValidatorUpdate {
 	store := ctx.KVStore(keeper.storeKey)
 	bz := store.Get(keyValidators)
diff --git a/x/group/types.go b/x/group/types.go
index a9e5143d9f..92a6badf78 100644
--- a/x/group/types.go
+++ b/x/group/types.go
@@ -11,7 +11,7 @@ import (
 // It could be used by a single user to manage multiple devices and setup a multisig policy.
 type Group struct {
 	// The members of the group and their associated weight
-	Members []Member `json:"addresses,omitempty"`
+	Members []Member `json:"members,omitempty"`
 	// Specifies the number of votes that must be accumulated in order for a decision to be made by the group.
 	// A member gets as many votes as is indicated by their Weight field.
 	// A big integer is used here to avoid any potential vulnerabilities from overflow errors
diff --git a/x/proposal/client/cli/tx.go b/x/proposal/client/cli/tx.go
index 860dbed470..156374b66f 100644
--- a/x/proposal/client/cli/tx.go
+++ b/x/proposal/client/cli/tx.go
@@ -14,7 +14,9 @@ import (
 type ActionCreator func(cmd *cobra.Command, args []string) (proposal.ProposalAction, error)
 
 func GetCmdPropose(cdc *codec.Codec, actionCreator ActionCreator) *cobra.Command {
-	return &cobra.Command{
+	var exec bool
+
+	cmd := &cobra.Command{
 		RunE: func(cmd *cobra.Command, args []string) error {
 			cliCtx := context.NewCLIContext().WithCodec(cdc).WithAccountDecoder(cdc)
 
@@ -35,6 +37,7 @@ func GetCmdPropose(cdc *codec.Codec, actionCreator ActionCreator) *cobra.Command
 			msg := proposal.MsgCreateProposal{
 				Proposer: account,
 				Action:   action,
+				Exec:     exec,
 			}
 			err = msg.ValidateBasic()
 			if err != nil {
@@ -46,6 +49,8 @@ func GetCmdPropose(cdc *codec.Codec, actionCreator ActionCreator) *cobra.Command
 			return utils.CompleteAndBroadcastTxCLI(txBldr, cliCtx, []sdk.Msg{msg})
 		},
 	}
+	cmd.Flags().BoolVar(&exec, "exec", false, "try to execute the proposal immediately")
+	return cmd
 }
 
 func getRunVote(cdc *codec.Codec, approve bool) func(cmd *cobra.Command, args []string) error {
diff --git a/x/proposal/handler.go b/x/proposal/handler.go
index c5894b98db..b12a67a35e 100644
--- a/x/proposal/handler.go
+++ b/x/proposal/handler.go
@@ -24,9 +24,18 @@ func NewHandler(keeper Keeper) sdk.Handler {
 	}
 }
 
-
 func handleMsgCreateProposal(ctx sdk.Context, keeper Keeper, msg MsgCreateProposal) sdk.Result {
-	return keeper.Propose(ctx, msg.Proposer, msg.Action)
+	id, res := keeper.Propose(ctx, msg.Proposer, msg.Action)
+	if res.Code != sdk.CodeOK {
+		return res
+	}
+	if msg.Exec {
+		res := keeper.TryExecute(ctx, id)
+		if res.Code == sdk.CodeOK {
+			return res
+		}
+	}
+	return res
 }
 
 func handleMsgVote(ctx sdk.Context, keeper Keeper, msg MsgVote) sdk.Result {
@@ -40,4 +49,3 @@ func handleMsgTryExecuteProposal(ctx sdk.Context, keeper Keeper, msg MsgTryExecu
 func handleMsgWithdrawProposal(ctx sdk.Context, keeper Keeper, msg MsgWithdrawProposal) sdk.Result {
 	return keeper.Withdraw(ctx, msg.ProposalId, msg.Proposer)
 }
-
diff --git a/x/proposal/keeper.go b/x/proposal/keeper.go
index e38014566f..84a655b34a 100644
--- a/x/proposal/keeper.go
+++ b/x/proposal/keeper.go
@@ -35,18 +35,15 @@ func MustDecodeProposalIDBech32(bech string) []byte {
 	return id
 }
 
-func (keeper Keeper) Propose(ctx sdk.Context, proposer sdk.AccAddress, action ProposalAction) sdk.Result {
+func (keeper Keeper) Propose(ctx sdk.Context, proposer sdk.AccAddress, action ProposalAction) ([]byte, sdk.Result) {
 	canHandle, res := keeper.handler.CheckProposal(ctx, action)
 
 	if !canHandle {
-		return sdk.Result{
-			Code: sdk.CodeUnknownRequest,
-			Log:  "unknown proposal type",
-		}
+		return nil, sdk.ErrUnknownRequest("unknown proposal type").Result()
 	}
 
 	if res.Code != sdk.CodeOK {
-		return res
+		return nil, res
 	}
 
 	store := ctx.KVStore(keeper.storeKey)
@@ -54,10 +51,7 @@ func (keeper Keeper) Propose(ctx sdk.Context, proposer sdk.AccAddress, action Pr
 	id := hashBz[:]
 	bech := mustEncodeProposalIDBech32(id)
 	if store.Has(id) {
-		return sdk.Result{
-			Code: sdk.CodeUnknownRequest,
-			Log:  fmt.Sprintf("proposal %s already exists", bech),
-		}
+		return id, sdk.ErrUnknownRequest(fmt.Sprintf("proposal %s already exists", bech)).Result()
 	}
 
 	prop := Proposal{
@@ -69,10 +63,9 @@ func (keeper Keeper) Propose(ctx sdk.Context, proposer sdk.AccAddress, action Pr
 	keeper.storeProposal(ctx, id, &prop)
 
 	res.Tags = res.Tags.
-		AppendTag("proposal.id", bech).
+		AppendTag("proposal.id", mustEncodeProposalIDBech32(id)).
 		AppendTag("proposal.action", action.Type())
-
-	return res
+	return id, res
 }
 
 func (keeper Keeper) storeProposal(ctx sdk.Context, id []byte, proposal *Proposal) {
@@ -168,10 +161,7 @@ func (keeper Keeper) TryExecute(ctx sdk.Context, proposalId []byte) sdk.Result {
 	proposal, err := keeper.GetProposal(ctx, proposalId)
 
 	if err != nil {
-		return sdk.Result{
-			Code: sdk.CodeUnknownRequest,
-			Log:  "can't find proposal",
-		}
+		return sdk.ErrUnknownRequest("can't find proposal").Result()
 	}
 
 	res := keeper.handler.HandleProposal(ctx, proposal.Action, proposal.Approvers)
diff --git a/x/proposal/msgs.go b/x/proposal/msgs.go
index a843516146..30e4507bea 100644
--- a/x/proposal/msgs.go
+++ b/x/proposal/msgs.go
@@ -1,29 +1,31 @@
 package proposal
 
 import (
-"encoding/json"
-sdk "github.com/cosmos/cosmos-sdk/types"
+	"encoding/json"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
 type MsgCreateProposal struct {
 	Proposer sdk.AccAddress `json:"proposer"`
-	Action ProposalAction `json:"action"`
+	Action   ProposalAction `json:"action"`
+	// Whether to try to execute this propose right away upon creation
+	Exec bool `json:"exec,omitempty"`
 }
 
 type MsgVote struct {
-	ProposalId []byte `json:"proposal_id"`
-	Voter sdk.AccAddress `json:"voter"`
-	Vote bool `json:"vote"`
+	ProposalId []byte         `json:"proposal_id"`
+	Voter      sdk.AccAddress `json:"voter"`
+	Vote       bool           `json:"vote"`
 }
 
 type MsgTryExecuteProposal struct {
-	ProposalId []byte `json:"proposal_id"`
-	Signer sdk.AccAddress `json:"signer"`
+	ProposalId []byte         `json:"proposal_id"`
+	Signer     sdk.AccAddress `json:"signer"`
 }
 
 type MsgWithdrawProposal struct {
-	ProposalId []byte `json:"proposal_id"`
-	Proposer sdk.AccAddress `json:"proposer"`
+	ProposalId []byte         `json:"proposal_id"`
+	Proposer   sdk.AccAddress `json:"proposer"`
 }
 
 func (msg MsgCreateProposal) Route() string { return "proposal" }
@@ -81,7 +83,7 @@ func (msg MsgTryExecuteProposal) GetSignBytes() []byte {
 }
 
 func (msg MsgTryExecuteProposal) GetSigners() []sdk.AccAddress {
-    return []sdk.AccAddress{msg.Signer}
+	return []sdk.AccAddress{msg.Signer}
 }
 
 func (msg MsgWithdrawProposal) Route() string { return "proposal" }
@@ -89,7 +91,7 @@ func (msg MsgWithdrawProposal) Route() string { return "proposal" }
 func (msg MsgWithdrawProposal) Type() string { return "proposal.withdraw" }
 
 func (msg MsgWithdrawProposal) ValidateBasic() sdk.Error {
-    return nil
+	return nil
 }
 
 func (msg MsgWithdrawProposal) GetSignBytes() []byte {
@@ -101,5 +103,5 @@ func (msg MsgWithdrawProposal) GetSignBytes() []byte {
 }
 
 func (msg MsgWithdrawProposal) GetSigners() []sdk.AccAddress {
-    return []sdk.AccAddress{msg.Proposer}
+	return []sdk.AccAddress{msg.Proposer}
 }
diff --git a/x/proposal/router.go b/x/proposal/router.go
index aae25f78d3..1965c7510e 100644
--- a/x/proposal/router.go
+++ b/x/proposal/router.go
@@ -41,7 +41,7 @@ func (rtr *Router) CheckProposal(ctx sdk.Context, action ProposalAction) (bool,
 			}
 		}
 	}
-	return false, sdk.Result{Code: sdk.CodeUnknownRequest}
+	return false, sdk.ErrUnknownRequest("can't handle proposal").Result()
 }
 
 func (rtr *Router) HandleProposal(ctx sdk.Context, action ProposalAction, voters []sdk.AccAddress) sdk.Result {
diff --git a/x/upgrade/keeper.go b/x/upgrade/keeper.go
index 5f9db3f736..ecd8c3a195 100644
--- a/x/upgrade/keeper.go
+++ b/x/upgrade/keeper.go
@@ -8,99 +8,148 @@ import (
 )
 
 type Keeper struct {
-	storeKey          sdk.StoreKey
-	cdc               *codec.Codec
-	lastUpgradeHeight int64
-	info              UpgradeInfo
-	haveCachedInfo    bool
-	willUpgrader      func(info UpgradeInfo)
-	beforeShutdowner  func(info UpgradeInfo)
-	doShutdowner      func()
-}
-
-type UpgradeInfo struct {
-	// The height at which the upgrade must be performed
-	Height int64 `json:"height"`
-
-	// Any application specific upgrade info to be included on-chain
-	// such as a git commit that validators could automatically upgrade to
-	Memo string `json:"memo,omitempty"`
+	storeKey         sdk.StoreKey
+	cdc              *codec.Codec
+	plan             UpgradePlan
+	haveCachedInfo   bool
+	willUpgrader     func(UpgradePlan)
+	beforeShutdowner func(UpgradePlan)
+	doShutdowner     func()
+	upgradeHandlers  map[string]UpgradeHandler
 }
 
 const (
-	infoKey = "info"
+	planKey = "plan"
 )
 
-func NewKeeper(storeKey sdk.StoreKey, cdc *codec.Codec, lastUpgradeHeight int64) Keeper {
+func NewKeeper(storeKey sdk.StoreKey, cdc *codec.Codec) Keeper {
 	return Keeper{
-		storeKey:          storeKey,
-		cdc:               cdc,
-		lastUpgradeHeight: lastUpgradeHeight,
-		haveCachedInfo:    false,
+		storeKey:        storeKey,
+		cdc:             cdc,
+		haveCachedInfo:  false,
+		upgradeHandlers: map[string]UpgradeHandler{},
 	}
 }
 
-func (keeper Keeper) ScheduleUpgrade(ctx sdk.Context, info UpgradeInfo) {
-	store := ctx.KVStore(keeper.storeKey)
-	bz, err := keeper.cdc.MarshalBinaryBare(info)
+// Sets an upgrade handler for the upgrade specified by name. This handler will be called when the upgrade
+// with this name is applied. In order for an upgrade with the given name to proceed, a handler for this upgrade
+// must be set even if it is a no-op function.
+func (keeper Keeper) SetUpgradeHandler(name string, upgradeHandler UpgradeHandler) {
+	keeper.upgradeHandlers[name] = upgradeHandler
+}
+
+func (keeper Keeper) ScheduleUpgrade(ctx sdk.Context, plan UpgradePlan) sdk.Error {
+	err := plan.ValidateBasic()
 	if err != nil {
-		panic(err)
+		return err
+	}
+	if !plan.Time.IsZero() {
+		if plan.Time.Before(ctx.BlockHeader().Time) {
+			return sdk.ErrUnknownRequest("Upgrade cannot be scheduled in the past")
+		}
+	} else {
+		if plan.Height <= ctx.BlockHeight() {
+			return sdk.ErrUnknownRequest("Upgrade cannot be scheduled in the past")
+		}
+	}
+	store := ctx.KVStore(keeper.storeKey)
+	if store.Has(upgradeDoneKey(plan.Name)) {
+		return sdk.ErrUnknownRequest(fmt.Sprintf("Upgrade with name %s has already been completed", plan.Name))
+	}
+	bz := keeper.cdc.MustMarshalBinaryBare(plan)
+	store.Set([]byte(planKey), bz)
+	return nil
+}
+
+func (keeper Keeper) ClearUpgradePlan(ctx sdk.Context) {
+	store := ctx.KVStore(keeper.storeKey)
+	store.Delete([]byte(planKey))
+}
+
+func (plan UpgradePlan) ValidateBasic() sdk.Error {
+	if len(plan.Name) == 0 {
+		return sdk.ErrUnknownRequest("Name cannot be empty")
+
 	}
-	store.Set([]byte(infoKey), bz)
+	return nil
 }
 
-func (keeper Keeper) GetUpgradeInfo(ctx sdk.Context, info *UpgradeInfo) sdk.Error {
+func (keeper Keeper) GetUpgradeInfo(ctx sdk.Context, plan *UpgradePlan) sdk.Error {
 	store := ctx.KVStore(keeper.storeKey)
-	bz := store.Get([]byte(infoKey))
+	bz := store.Get([]byte(planKey))
 	if bz == nil {
 		return sdk.ErrUnknownRequest("Not found")
 	}
-	marshalErr := keeper.cdc.UnmarshalBinaryBare(bz, &info)
+	marshalErr := keeper.cdc.UnmarshalBinaryBare(bz, &plan)
 	if marshalErr != nil {
 		return sdk.ErrUnknownRequest(marshalErr.Error())
 	}
 	return nil
 }
 
-func (keeper Keeper) SetWillUpgrader(ctx sdk.Context, willUpgrader func(info UpgradeInfo)) {
+func (keeper Keeper) SetWillUpgrader(willUpgrader func(plan UpgradePlan)) {
 	keeper.willUpgrader = willUpgrader
 }
 
-func (keeper Keeper) SetBeforeShutdowner(ctx sdk.Context, beforeShutdowner func(info UpgradeInfo)) {
+func (keeper Keeper) SetBeforeShutdowner(beforeShutdowner func(plan UpgradePlan)) {
 	keeper.beforeShutdowner = beforeShutdowner
 }
 
-func (keeper Keeper) SetDoShutdowner(ctx sdk.Context, doShutdowner func()) {
+func (keeper Keeper) SetDoShutdowner(doShutdowner func()) {
 	keeper.doShutdowner = doShutdowner
 }
 
+func upgradeDoneKey(name string) []byte {
+	return []byte(fmt.Sprintf("done/%s", name))
+}
+
 func (keeper Keeper) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock) {
+	blockTime := ctx.BlockHeader().Time
+	blockHeight := ctx.BlockHeight()
+
 	if !keeper.haveCachedInfo {
-		err := keeper.GetUpgradeInfo(ctx, &keeper.info)
+		err := keeper.GetUpgradeInfo(ctx, &keeper.plan)
 		if err != nil {
 			return
 		}
 		keeper.haveCachedInfo = true
-		if keeper.info.Height > keeper.lastUpgradeHeight {
+		// TODO verify this will always get called at the right time
+		if (!keeper.plan.Time.IsZero() && keeper.plan.Time.After(blockTime)) || keeper.plan.Height > blockHeight {
 			willUpgrader := keeper.willUpgrader
 			if willUpgrader != nil {
-				willUpgrader(keeper.info)
+				willUpgrader(keeper.plan)
 			}
 		}
 	}
 
-	upgradeHeight := keeper.info.Height
-	if upgradeHeight > keeper.lastUpgradeHeight && ctx.BlockHeight() >= upgradeHeight {
-		beforeShutdowner := keeper.beforeShutdowner
-		if beforeShutdowner != nil {
-			beforeShutdowner(keeper.info)
-		}
+	if keeper.haveCachedInfo {
+		upgradeTime := keeper.plan.Time
+		upgradeHeight := keeper.plan.Height
+		if (!upgradeTime.IsZero() && (upgradeTime.Before(blockTime) || upgradeTime.Equal(blockTime))) || upgradeHeight <= blockHeight {
+			handler, ok := keeper.upgradeHandlers[keeper.plan.Name]
+			if ok {
+				// We have an upgrade handler for this upgrade name, so apply the upgrade
+				ctx.Logger().Info(fmt.Sprintf("Applying upgrade \"%s\" at height %d", keeper.plan.Name, blockHeight))
+				handler(ctx, keeper.plan)
+				keeper.ClearUpgradePlan(ctx)
+				// Mark this upgrade name as being done so the name can't be reused accidentally
+				store := ctx.KVStore(keeper.storeKey)
+				store.Set(upgradeDoneKey(keeper.plan.Name), []byte("1"))
+			} else {
+				// We don't have an upgrade handler for this upgrade name, meaning this software is out of date so shutdown
+
+				beforeShutdowner := keeper.beforeShutdowner
+				if beforeShutdowner != nil {
+					beforeShutdowner(keeper.plan)
+				}
 
-		doShutdowner := keeper.doShutdowner
-		if doShutdowner != nil {
-			doShutdowner()
-		} else {
-			panic(fmt.Sprintf("UPGRADE NEEDED at height %d: %s", upgradeHeight, keeper.info.Memo))
+				doShutdowner := keeper.doShutdowner
+				if doShutdowner != nil {
+					doShutdowner()
+				} else {
+					panic(fmt.Sprintf("UPGRADE NEEDED \"%s\" needed at height %d: %s", keeper.plan.Name, blockHeight, keeper.plan.Memo))
+				}
+			}
 		}
 	}
 }

From 2d6d1a45c7f40df227e3d25b2a9cb41fd365c089 Mon Sep 17 00:00:00 2001
From: Aaron Craelius <aaron@regen.network>
Date: Mon, 25 Mar 2019 10:18:03 -0400
Subject: [PATCH 2/9] #13 WIP on improvements to upgrade module

---
 app.go              |   9 +-
 default.nix         |  15 +-
 deps.nix            | 534 --------------------------------------------
 module.nix          |   2 +-
 x/upgrade/keeper.go |  35 +--
 x/upgrade/types.go  |  28 +++
 6 files changed, 50 insertions(+), 573 deletions(-)
 delete mode 100644 deps.nix
 create mode 100644 x/upgrade/types.go

diff --git a/app.go b/app.go
index 8c81ab32dd..dd59b17600 100644
--- a/app.go
+++ b/app.go
@@ -2,6 +2,7 @@ package app
 
 import (
 	"encoding/json"
+	"fmt"
 	"github.com/cosmos/cosmos-sdk/x/params"
 	"github.com/regen-network/regen-ledger/index/postgresql"
 	"github.com/regen-network/regen-ledger/x/consortium"
@@ -15,8 +16,8 @@ import (
 	"github.com/tendermint/tendermint/libs/cli"
 	"github.com/tendermint/tendermint/libs/log"
 	"io/ioutil"
+	"os"
 	"path/filepath"
-
 	//"os"
 
 	"github.com/cosmos/cosmos-sdk/codec"
@@ -158,7 +159,7 @@ func NewXrnApp(logger log.Logger, db dbm.DB, postgresUrl string) *xrnApp {
 	app.espKeeper = esp.NewKeeper(app.espStoreKey, app.agentKeeper, app.geoKeeper, cdc)
 
 	app.upgradeKeeper = upgrade.NewKeeper(app.upgradeStoreKey, cdc)
-	app.upgradeKeeper.SetBeforeShutdowner(app.willUpgrade)
+	app.upgradeKeeper.SetDoShutdowner(app.shutdownOnUpgrade)
 	app.upgradeKeeper.SetUpgradeHandler("test3", func(ctx sdk.Context, plan upgrade.UpgradePlan) {
 		ctx.Logger().Info("In upgrade 3 handler!")
 	})
@@ -251,11 +252,13 @@ func (app *xrnApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci.
 	return abci.ResponseInitChain{}
 }
 
-func (app *xrnApp) willUpgrade(plan upgrade.UpgradePlan) {
+func (app *xrnApp) shutdownOnUpgrade(ctx sdk.Context, plan upgrade.UpgradePlan) {
 	if len(plan.Memo) != 0 {
 		home := viper.GetString(cli.HomeFlag)
 		_ = ioutil.WriteFile(filepath.Join(home, "data", "upgrade-info"), []byte(plan.Memo), 0644)
 	}
+	ctx.Logger().Error(fmt.Sprintf("UPGRADE \"%s\" NEEDED needed at height %d: %s", plan.Name, ctx.BlockHeight(), plan.Memo))
+	os.Exit(1)
 }
 
 func (app *xrnApp) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock) abci.ResponseBeginBlock {
diff --git a/default.nix b/default.nix
index fec144a131..7b227bc513 100644
--- a/default.nix
+++ b/default.nix
@@ -1,6 +1,6 @@
 with import <nixpkgs>{};
 
-buildGoPackage rec {
+buildGoModule rec {
   name = "regen-ledger";
 
   goPackagePath = "github.com/regen-network/regen-ledger";
@@ -8,18 +8,9 @@ buildGoPackage rec {
 
   src = ./.;
 
-  # buildInputs = [ makeWrapper ];
-  # binPath = lib.makeBinPath [ ];
-
-  goDeps = ./deps.nix;
-
-  #postInstall = ''
-  #  wrapProgram $bin/bin/dep2nix --prefix PATH ':' ${binPath}
-  #'';
-
   meta = with stdenv.lib; {
-    description = "Regen Networks's Regen Ledger distributed ledger for planetary regeneration";
-    # TODO license = licenses.bsd3;
+    description = "Distributed ledger for planetary regeneration";
+    license = licenses.asl20;
     homepage = https://github.com/regen-network/regen-ledger;
   };
 }
\ No newline at end of file
diff --git a/deps.nix b/deps.nix
deleted file mode 100644
index a691f47dee..0000000000
--- a/deps.nix
+++ /dev/null
@@ -1,534 +0,0 @@
-# file generated from Gopkg.lock using dep2nix (https://github.com/nixcloud/dep2nix)
-[
-  {
-    goPackagePath  = "github.com/ZondaX/hid-go";
-    fetch = {
-      type = "git";
-      url = "https://github.com/ZondaX/hid-go";
-      rev =  "48b08affede2cea076a3cf13b2e3f72ed262b743";
-      sha256 = "1s3bpxnbcbn67xzivjjb1r5ys15m61wkc98l7kcg45n4wfkqak8a";
-    };
-  }
-  {
-    goPackagePath  = "github.com/ZondaX/ledger-go";
-    fetch = {
-      type = "git";
-      url = "https://github.com/ZondaX/ledger-go";
-      rev =  "c3225ab10c2f53397d4aa419a588466493572b22";
-      sha256 = "1bis35gyxgywk8xmnpm0zlx5gs6b8jwifdk7ig0d1m7pbjazxrjq";
-    };
-  }
-  {
-    goPackagePath  = "github.com/bartekn/go-bip39";
-    fetch = {
-      type = "git";
-      url = "https://github.com/bartekn/go-bip39";
-      rev =  "a05967ea095d81c8fe4833776774cfaff8e5036c";
-      sha256 = "01dhv6556d9fiia4901qi18kyvxgrxzv1p9fbhfvpvnmfrw96zli";
-    };
-  }
-  {
-    goPackagePath  = "github.com/beorn7/perks";
-    fetch = {
-      type = "git";
-      url = "https://github.com/beorn7/perks";
-      rev =  "3a771d992973f24aa725d07868b467d1ddfceafb";
-      sha256 = "1l2lns4f5jabp61201sh88zf3b0q793w4zdgp9nll7mmfcxxjif3";
-    };
-  }
-  {
-    goPackagePath  = "github.com/bgentry/speakeasy";
-    fetch = {
-      type = "git";
-      url = "https://github.com/bgentry/speakeasy";
-      rev =  "4aabc24848ce5fd31929f7d1e4ea74d3709c14cd";
-      sha256 = "02dfrj0wyphd3db9zn2mixqxwiz1ivnyc5xc7gkz58l5l27nzp8s";
-    };
-  }
-  {
-    goPackagePath  = "github.com/btcsuite/btcd";
-    fetch = {
-      type = "git";
-      url = "https://github.com/btcsuite/btcd";
-      rev =  "7d2daa5bfef28c5e282571bc06416516936115ee";
-      sha256 = "1ygy6m2mdbir2kln3zh5amb56d1ypiymq3m0pj3f4c071aqsrpr6";
-    };
-  }
-  {
-    goPackagePath  = "github.com/btcsuite/btcutil";
-    fetch = {
-      type = "git";
-      url = "https://github.com/btcsuite/btcutil";
-      rev =  "d4cc87b860166d00d6b5b9e0d3b3d71d6088d4d4";
-      sha256 = "11ipk4g3j3px821pni8r483jyd3zjnvpdn8sr62vkgjjwdfv4ygw";
-    };
-  }
-  {
-    goPackagePath  = "github.com/cosmos/cosmos-sdk";
-    fetch = {
-      type = "git";
-      url = "https://github.com/regen-network/cosmos-sdk";
-      rev =  "1a6bed2b19bbdde46b97d228200f8904e4abb261";
-      sha256 = "142r6fidmrlyyiwsi5hynvb6dkp6lxz9j0p08pr8zxplbqip0n11";
-    };
-  }
-  {
-    goPackagePath  = "github.com/cosmos/go-bip39";
-    fetch = {
-      type = "git";
-      url = "https://github.com/cosmos/go-bip39";
-      rev =  "52158e4697b87de16ed390e1bdaf813e581008fa";
-      sha256 = "05a95z4vmij6ijw7fi209hzfvicb86cyh8cvn7ldqq60kiz1mdsg";
-    };
-  }
-  {
-    goPackagePath  = "github.com/davecgh/go-spew";
-    fetch = {
-      type = "git";
-      url = "https://github.com/davecgh/go-spew";
-      rev =  "8991bc29aa16c548c550c7ff78260e27b9ab7c73";
-      sha256 = "0hka6hmyvp701adzag2g26cxdj47g21x6jz4sc6jjz1mn59d474y";
-    };
-  }
-  {
-    goPackagePath  = "github.com/fsnotify/fsnotify";
-    fetch = {
-      type = "git";
-      url = "https://github.com/fsnotify/fsnotify";
-      rev =  "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9";
-      sha256 = "07va9crci0ijlivbb7q57d2rz9h27zgn2fsm60spjsqpdbvyrx4g";
-    };
-  }
-  {
-    goPackagePath  = "github.com/go-kit/kit";
-    fetch = {
-      type = "git";
-      url = "https://github.com/go-kit/kit";
-      rev =  "4dc7be5d2d12881735283bcab7352178e190fc71";
-      sha256 = "0w2lh1dkhrnd08jk8y0g4wzrg8d43zngh9igg5jpvh5jdblp4cxk";
-    };
-  }
-  {
-    goPackagePath  = "github.com/go-logfmt/logfmt";
-    fetch = {
-      type = "git";
-      url = "https://github.com/go-logfmt/logfmt";
-      rev =  "07c9b44f60d7ffdfb7d8efe1ad539965737836dc";
-      sha256 = "06smxc112xmixz78nyvk3b2hmc7wasf2sl5vxj1xz62kqcq9lzm9";
-    };
-  }
-  {
-    goPackagePath  = "github.com/go-stack/stack";
-    fetch = {
-      type = "git";
-      url = "https://github.com/go-stack/stack";
-      rev =  "2fee6af1a9795aafbe0253a0cfbdf668e1fb8a9a";
-      sha256 = "0wk25751ryyvxclyp8jdk5c3ar0cmfr8lrjb66qbg4808x66b96v";
-    };
-  }
-  {
-    goPackagePath  = "github.com/gogo/protobuf";
-    fetch = {
-      type = "git";
-      url = "https://github.com/gogo/protobuf";
-      rev =  "636bf0302bc95575d69441b25a2603156ffdddf1";
-      sha256 = "1525pq7r6h3s8dncvq8gxi893p2nq8dxpzvq0nfl5b4p6mq0v1c2";
-    };
-  }
-  {
-    goPackagePath  = "github.com/golang/protobuf";
-    fetch = {
-      type = "git";
-      url = "https://github.com/golang/protobuf";
-      rev =  "b4deda0973fb4c70b50d226b1af49f3da59f5265";
-      sha256 = "0ya4ha7m20bw048m1159ppqzlvda4x0vdprlbk5sdgmy74h3xcdq";
-    };
-  }
-  {
-    goPackagePath  = "github.com/golang/snappy";
-    fetch = {
-      type = "git";
-      url = "https://github.com/golang/snappy";
-      rev =  "2e65f85255dbc3072edf28d6b5b8efc472979f5a";
-      sha256 = "05w6mpc4qcy0pv8a2bzng8nf4s5rf5phfang4jwy9rgf808q0nxf";
-    };
-  }
-  {
-    goPackagePath  = "github.com/gorilla/context";
-    fetch = {
-      type = "git";
-      url = "https://github.com/gorilla/context";
-      rev =  "08b5f424b9271eedf6f9f0ce86cb9396ed337a42";
-      sha256 = "03p4hn87vcmfih0p9w663qbx9lpsf7i7j3lc7yl7n84la3yz63m4";
-    };
-  }
-  {
-    goPackagePath  = "github.com/gorilla/mux";
-    fetch = {
-      type = "git";
-      url = "https://github.com/gorilla/mux";
-      rev =  "e3702bed27f0d39777b0b37b664b6280e8ef8fbf";
-      sha256 = "0pvzm23hklxysspnz52mih6h1q74vfrdhjfm1l3sa9r8hhqmmld2";
-    };
-  }
-  {
-    goPackagePath  = "github.com/gorilla/websocket";
-    fetch = {
-      type = "git";
-      url = "https://github.com/gorilla/websocket";
-      rev =  "66b9c49e59c6c48f0ffce28c2d8b8a5678502c6d";
-      sha256 = "00i4vb31nsfkzzk7swvx3i75r2d960js3dri1875vypk3v2s0pzk";
-    };
-  }
-  {
-    goPackagePath  = "github.com/hashicorp/hcl";
-    fetch = {
-      type = "git";
-      url = "https://github.com/hashicorp/hcl";
-      rev =  "8cb6e5b959231cc1119e43259c4a608f9c51a241";
-      sha256 = "0q6ml0qqs0yil76mpn4mdx4lp94id8vbv575qm60jzl1ijcl5i66";
-    };
-  }
-  {
-    goPackagePath  = "github.com/inconshreveable/mousetrap";
-    fetch = {
-      type = "git";
-      url = "https://github.com/inconshreveable/mousetrap";
-      rev =  "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75";
-      sha256 = "1mn0kg48xkd74brf48qf5hzp0bc6g8cf5a77w895rl3qnlpfw152";
-    };
-  }
-  {
-    goPackagePath  = "github.com/jmhodges/levigo";
-    fetch = {
-      type = "git";
-      url = "https://github.com/jmhodges/levigo";
-      rev =  "c42d9e0ca023e2198120196f842701bb4c55d7b9";
-      sha256 = "1pdm8pwjj0dix559657gdbbs2cvrwlnnwhh7qqab4a0psg6ssalg";
-    };
-  }
-  {
-    goPackagePath  = "github.com/kr/logfmt";
-    fetch = {
-      type = "git";
-      url = "https://github.com/kr/logfmt";
-      rev =  "b84e30acd515aadc4b783ad4ff83aff3299bdfe0";
-      sha256 = "02ldzxgznrfdzvghfraslhgp19la1fczcbzh7wm2zdc6lmpd1qq9";
-    };
-  }
-  {
-    goPackagePath  = "github.com/magiconair/properties";
-    fetch = {
-      type = "git";
-      url = "https://github.com/magiconair/properties";
-      rev =  "c2353362d570a7bfa228149c62842019201cfb71";
-      sha256 = "1a10362wv8a8qwb818wygn2z48lgzch940hvpv81hv8gc747ajxn";
-    };
-  }
-  {
-    goPackagePath  = "github.com/mattn/go-isatty";
-    fetch = {
-      type = "git";
-      url = "https://github.com/mattn/go-isatty";
-      rev =  "6ca4dbf54d38eea1a992b3c722a76a5d1c4cb25c";
-      sha256 = "0zs92j2cqaw9j8qx1sdxpv3ap0rgbs0vrvi72m40mg8aa36gd39w";
-    };
-  }
-  {
-    goPackagePath  = "github.com/matttproud/golang_protobuf_extensions";
-    fetch = {
-      type = "git";
-      url = "https://github.com/matttproud/golang_protobuf_extensions";
-      rev =  "c12348ce28de40eed0136aa2b644d0ee0650e56c";
-      sha256 = "1d0c1isd2lk9pnfq2nk0aih356j30k3h1gi2w0ixsivi5csl7jya";
-    };
-  }
-  {
-    goPackagePath  = "github.com/mitchellh/mapstructure";
-    fetch = {
-      type = "git";
-      url = "https://github.com/mitchellh/mapstructure";
-      rev =  "3536a929edddb9a5b34bd6861dc4a9647cb459fe";
-      sha256 = "03bpv28jz9zhn4947saqwi328ydj7f6g6pf1m2d4m5zdh5jlfkrr";
-    };
-  }
-  {
-    goPackagePath  = "github.com/pelletier/go-toml";
-    fetch = {
-      type = "git";
-      url = "https://github.com/pelletier/go-toml";
-      rev =  "c01d1270ff3e442a8a57cddc1c92dc1138598194";
-      sha256 = "1fjzpcjng60mc3a4b2ql5a00d5gah84wj740dabv9kq67mpg8fxy";
-    };
-  }
-  {
-    goPackagePath  = "github.com/pkg/errors";
-    fetch = {
-      type = "git";
-      url = "https://github.com/pkg/errors";
-      rev =  "645ef00459ed84a119197bfb8d8205042c6df63d";
-      sha256 = "001i6n71ghp2l6kdl3qq1v2vmghcz3kicv9a5wgcihrzigm75pp5";
-    };
-  }
-  {
-    goPackagePath  = "github.com/pmezard/go-difflib";
-    fetch = {
-      type = "git";
-      url = "https://github.com/pmezard/go-difflib";
-      rev =  "792786c7400a136282c1664665ae0a8db921c6c2";
-      sha256 = "0c1cn55m4rypmscgf0rrb88pn58j3ysvc2d0432dp3c6fqg6cnzw";
-    };
-  }
-  {
-    goPackagePath  = "github.com/prometheus/client_golang";
-    fetch = {
-      type = "git";
-      url = "https://github.com/prometheus/client_golang";
-      rev =  "abad2d1bd44235a26707c172eab6bca5bf2dbad3";
-      sha256 = "01gnylazia30pcp069xcng482gwmm3xcx5zgrlwdkhic1lyb6i9l";
-    };
-  }
-  {
-    goPackagePath  = "github.com/prometheus/client_model";
-    fetch = {
-      type = "git";
-      url = "https://github.com/prometheus/client_model";
-      rev =  "5c3871d89910bfb32f5fcab2aa4b9ec68e65a99f";
-      sha256 = "04psf81l9fjcwascsys428v03fx4fi894h7fhrj2vvcz723q57k0";
-    };
-  }
-  {
-    goPackagePath  = "github.com/prometheus/common";
-    fetch = {
-      type = "git";
-      url = "https://github.com/prometheus/common";
-      rev =  "4724e9255275ce38f7179b2478abeae4e28c904f";
-      sha256 = "0pcx8hlnrxx5nnmpk786cn99rsgqk1jrd3c9f6fsx8qd8y5iwjy6";
-    };
-  }
-  {
-    goPackagePath  = "github.com/prometheus/procfs";
-    fetch = {
-      type = "git";
-      url = "https://github.com/prometheus/procfs";
-      rev =  "aa55a523dc0a8297edf51bb75e8eec13eb3be45d";
-      sha256 = "1s44rwqx67n2w9xjvkcpslz44gghbw73izxavlls503zccr4hhb9";
-    };
-  }
-  {
-    goPackagePath  = "github.com/rakyll/statik";
-    fetch = {
-      type = "git";
-      url = "https://github.com/rakyll/statik";
-      rev =  "aa8a7b1baecd0f31a436bf7956fcdcc609a83035";
-      sha256 = "00q9akb9m66wv9m895vbm3kywi6a2gidn27kz29h19ada998kz12";
-    };
-  }
-  {
-    goPackagePath  = "github.com/rcrowley/go-metrics";
-    fetch = {
-      type = "git";
-      url = "https://github.com/rcrowley/go-metrics";
-      rev =  "e2704e165165ec55d062f5919b4b29494e9fa790";
-      sha256 = "1yvvwqyfdnnjgnc3j4y0g1b897ad0wwlgn6x4dx83s20ax2lyz2q";
-    };
-  }
-  {
-    goPackagePath  = "github.com/rs/cors";
-    fetch = {
-      type = "git";
-      url = "https://github.com/rs/cors";
-      rev =  "9a47f48565a795472d43519dd49aac781f3034fb";
-      sha256 = "12j838rj6xl9y1xqs1mnh9zkc3dkpn94iqkp6jkdkxw631aa94dr";
-    };
-  }
-  {
-    goPackagePath  = "github.com/satori/go.uuid";
-    fetch = {
-      type = "git";
-      url = "https://github.com/satori/go.uuid";
-      rev =  "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3";
-      sha256 = "1j4s5pfg2ldm35y8ls8jah4dya2grfnx2drb4jcbjsyrp4cm5yfb";
-    };
-  }
-  {
-    goPackagePath  = "github.com/spf13/afero";
-    fetch = {
-      type = "git";
-      url = "https://github.com/spf13/afero";
-      rev =  "d40851caa0d747393da1ffb28f7f9d8b4eeffebd";
-      sha256 = "0miv4faf5ihjfifb1zv6aia6f6ik7h1s4954kcb8n6ixzhx9ck6k";
-    };
-  }
-  {
-    goPackagePath  = "github.com/spf13/cast";
-    fetch = {
-      type = "git";
-      url = "https://github.com/spf13/cast";
-      rev =  "8c9545af88b134710ab1cd196795e7f2388358d7";
-      sha256 = "0xq1ffqj8y8h7dcnm0m9lfrh0ga7pssnn2c1dnr09chqbpn4bdc5";
-    };
-  }
-  {
-    goPackagePath  = "github.com/spf13/cobra";
-    fetch = {
-      type = "git";
-      url = "https://github.com/spf13/cobra";
-      rev =  "ef82de70bb3f60c65fb8eebacbb2d122ef517385";
-      sha256 = "1q1nsx05svyv9fv3fy6xv6gs9ffimkyzsfm49flvl3wnvf1ncrkd";
-    };
-  }
-  {
-    goPackagePath  = "github.com/spf13/jwalterweatherman";
-    fetch = {
-      type = "git";
-      url = "https://github.com/spf13/jwalterweatherman";
-      rev =  "4a4406e478ca629068e7768fc33f3f044173c0a6";
-      sha256 = "093fmmvavv84pv4q84hav7ph3fmrq87bvspjj899q0qsx37yvdr8";
-    };
-  }
-  {
-    goPackagePath  = "github.com/spf13/pflag";
-    fetch = {
-      type = "git";
-      url = "https://github.com/spf13/pflag";
-      rev =  "298182f68c66c05229eb03ac171abe6e309ee79a";
-      sha256 = "1cj3cjm7d3zk0mf1xdybh0jywkbbw7a6yr3y22x9sis31scprswd";
-    };
-  }
-  {
-    goPackagePath  = "github.com/spf13/viper";
-    fetch = {
-      type = "git";
-      url = "https://github.com/spf13/viper";
-      rev =  "a1b837276271029e31f796ae5d03ba9ffb017244";
-      sha256 = "0a01ljf1niz86v2il97m31ivbq73zj4kh6wl5cc4kaqr5zryxq2q";
-    };
-  }
-  {
-    goPackagePath  = "github.com/stretchr/testify";
-    fetch = {
-      type = "git";
-      url = "https://github.com/stretchr/testify";
-      rev =  "12b6f73e6084dad08a7c6e575284b177ecafbc71";
-      sha256 = "01f80s0q64pw5drfgqwwk1wfwwkvd2lhbs56lhhkff4ni83k73fd";
-    };
-  }
-  {
-    goPackagePath  = "github.com/syndtr/goleveldb";
-    fetch = {
-      type = "git";
-      url = "https://github.com/syndtr/goleveldb";
-      rev =  "b001fa50d6b27f3f0bb175a87d0cb55426d0a0ae";
-      sha256 = "1k7085a5vbdlbw0ymba31smxxaqlx41ji585ncxcrrs7xnnsaz32";
-    };
-  }
-  {
-    goPackagePath  = "github.com/tendermint/btcd";
-    fetch = {
-      type = "git";
-      url = "https://github.com/tendermint/btcd";
-      rev =  "e5840949ff4fff0c56f9b6a541e22b63581ea9df";
-      sha256 = "14wxgv8pny40vnwb4jad596sxsj7vk66av9yf0f495p458ymi7l4";
-    };
-  }
-  {
-    goPackagePath  = "github.com/tendermint/go-amino";
-    fetch = {
-      type = "git";
-      url = "https://github.com/tendermint/go-amino";
-      rev =  "dc14acf9ef15f85828bfbc561ed9dd9d2a284885";
-      sha256 = "0mz3h5k5rbkkgajm4rnl5wxkds8qk6nsq5adwg8z5fxvimxxf5bi";
-    };
-  }
-  {
-    goPackagePath  = "github.com/tendermint/iavl";
-    fetch = {
-      type = "git";
-      url = "https://github.com/tendermint/iavl";
-      rev =  "de0740903a67b624d887f9055d4c60175dcfa758";
-      sha256 = "1ghwxvd0f6iiwqi0m2bgyjllm4nhz72k71ajp5byf4w4zlwy8fzl";
-    };
-  }
-  {
-    goPackagePath  = "github.com/tendermint/tendermint";
-    fetch = {
-      type = "git";
-      url = "https://github.com/tendermint/tendermint";
-      rev =  "0138530df202f5b8e8be1edb9c2f705e404a79cb";
-      sha256 = "0456a8islcy80n4w8lgyl81qaah3i4xw1lvjaq3basljpqhdxmsj";
-    };
-  }
-  {
-    goPackagePath  = "github.com/zondax/ledger-cosmos-go";
-    fetch = {
-      type = "git";
-      url = "https://github.com/zondax/ledger-cosmos-go";
-      rev =  "d4aed6d929a703bb555a2d79fe9c470afe61f648";
-      sha256 = "17hvgb42q5k9k96sgx519plb0y1dvxjqnmrk09ldkid6yvc917ih";
-    };
-  }
-  {
-    goPackagePath  = "golang.org/x/crypto";
-    fetch = {
-      type = "git";
-      url = "https://github.com/tendermint/crypto";
-      rev =  "3764759f34a542a3aef74d6b02e35be7ab893bba";
-      sha256 = "0hpar8rj0xnxnrrxi3g6695lq24ibp5i9k1hif7ki6mrl2xciws2";
-    };
-  }
-  {
-    goPackagePath  = "golang.org/x/net";
-    fetch = {
-      type = "git";
-      url = "https://go.googlesource.com/net";
-      rev =  "292b43bbf7cb8d35ddf40f8d5100ef3837cced3f";
-      sha256 = "0n3d0hh6ip64g41ha80gdx508r8ycsj3mxcp7h7dqknrk2aqsp6y";
-    };
-  }
-  {
-    goPackagePath  = "golang.org/x/sys";
-    fetch = {
-      type = "git";
-      url = "https://go.googlesource.com/sys";
-      rev =  "4ed8d59d0b35e1e29334a206d1b3f38b1e5dfb31";
-      sha256 = "0yj125avhqv9d3r0dcndzgd5kgzf1cv9b3z3gv0dlr5fcb18ikbw";
-    };
-  }
-  {
-    goPackagePath  = "golang.org/x/text";
-    fetch = {
-      type = "git";
-      url = "https://go.googlesource.com/text";
-      rev =  "f21a4dfb5e38f5895301dc265a8def02365cc3d0";
-      sha256 = "0r6x6zjzhr8ksqlpiwm5gdd7s209kwk5p4lw54xjvz10cs3qlq19";
-    };
-  }
-  {
-    goPackagePath  = "google.golang.org/genproto";
-    fetch = {
-      type = "git";
-      url = "https://github.com/google/go-genproto";
-      rev =  "bd91e49a0898e27abb88c339b432fa53d7497ac0";
-      sha256 = "1f5q04h03q6fksbfkhz13ai5849rkkb8xrmmi7cxs4lzsi6ixkg8";
-    };
-  }
-  {
-    goPackagePath  = "google.golang.org/grpc";
-    fetch = {
-      type = "git";
-      url = "https://github.com/grpc/grpc-go";
-      rev =  "2e463a05d100327ca47ac218281906921038fd95";
-      sha256 = "0a9xl6c5j7lvsb4q6ry5p892rjm86p47d4f8xrf0r8lxblf79qbg";
-    };
-  }
-  {
-    goPackagePath  = "gopkg.in/yaml.v2";
-    fetch = {
-      type = "git";
-      url = "https://github.com/go-yaml/yaml";
-      rev =  "51d6538a90f86fe93ac480b35f37b2be17fef232";
-      sha256 = "01wj12jzsdqlnidpyjssmj0r4yavlqy7dwrg7adqd8dicjc4ncsa";
-    };
-  }
-]
\ No newline at end of file
diff --git a/module.nix b/module.nix
index 1e4c6fbb8c..93028dfb44 100644
--- a/module.nix
+++ b/module.nix
@@ -97,7 +97,7 @@ in
         };
     })
 
-    (mkIf xrndCfg.restServer {
+    (mkIf (xrndCfg.enable && xrndCfg.restServer) {
         users.groups.xrn = {};
 
         users.users.xrnrest = {
diff --git a/x/upgrade/keeper.go b/x/upgrade/keeper.go
index ecd8c3a195..ba9f1e56ee 100644
--- a/x/upgrade/keeper.go
+++ b/x/upgrade/keeper.go
@@ -8,14 +8,13 @@ import (
 )
 
 type Keeper struct {
-	storeKey         sdk.StoreKey
-	cdc              *codec.Codec
-	plan             UpgradePlan
-	haveCachedInfo   bool
-	willUpgrader     func(UpgradePlan)
-	beforeShutdowner func(UpgradePlan)
-	doShutdowner     func()
-	upgradeHandlers  map[string]UpgradeHandler
+	storeKey        sdk.StoreKey
+	cdc             *codec.Codec
+	plan            UpgradePlan
+	haveCachedInfo  bool
+	willUpgrader    func(UpgradePlan)
+	doShutdowner    func(sdk.Context, UpgradePlan)
+	upgradeHandlers map[string]UpgradeHandler
 }
 
 const (
@@ -87,15 +86,11 @@ func (keeper Keeper) GetUpgradeInfo(ctx sdk.Context, plan *UpgradePlan) sdk.Erro
 	return nil
 }
 
-func (keeper Keeper) SetWillUpgrader(willUpgrader func(plan UpgradePlan)) {
+func (keeper *Keeper) SetWillUpgrader(willUpgrader func(plan UpgradePlan)) {
 	keeper.willUpgrader = willUpgrader
 }
 
-func (keeper Keeper) SetBeforeShutdowner(beforeShutdowner func(plan UpgradePlan)) {
-	keeper.beforeShutdowner = beforeShutdowner
-}
-
-func (keeper Keeper) SetDoShutdowner(doShutdowner func()) {
+func (keeper *Keeper) SetDoShutdowner(doShutdowner func(ctx sdk.Context, plan UpgradePlan)) {
 	keeper.doShutdowner = doShutdowner
 }
 
@@ -103,7 +98,7 @@ func upgradeDoneKey(name string) []byte {
 	return []byte(fmt.Sprintf("done/%s", name))
 }
 
-func (keeper Keeper) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock) {
+func (keeper *Keeper) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock) {
 	blockTime := ctx.BlockHeader().Time
 	blockHeight := ctx.BlockHeight()
 
@@ -137,17 +132,11 @@ func (keeper Keeper) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock) {
 				store.Set(upgradeDoneKey(keeper.plan.Name), []byte("1"))
 			} else {
 				// We don't have an upgrade handler for this upgrade name, meaning this software is out of date so shutdown
-
-				beforeShutdowner := keeper.beforeShutdowner
-				if beforeShutdowner != nil {
-					beforeShutdowner(keeper.plan)
-				}
-
 				doShutdowner := keeper.doShutdowner
 				if doShutdowner != nil {
-					doShutdowner()
+					doShutdowner(ctx, keeper.plan)
 				} else {
-					panic(fmt.Sprintf("UPGRADE NEEDED \"%s\" needed at height %d: %s", keeper.plan.Name, blockHeight, keeper.plan.Memo))
+					panic(fmt.Sprintf("UPGRADE \"%s\" NEEDED needed at height %d: %s", keeper.plan.Name, blockHeight, keeper.plan.Memo))
 				}
 			}
 		}
diff --git a/x/upgrade/types.go b/x/upgrade/types.go
new file mode 100644
index 0000000000..e51c9df45d
--- /dev/null
+++ b/x/upgrade/types.go
@@ -0,0 +1,28 @@
+package upgrade
+
+import "time"
+import sdk "github.com/cosmos/cosmos-sdk/types"
+
+type UpgradePlan struct {
+	// Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any
+	// special "on-upgrade" commands during the first BeginBlock method after the upgrade is applied. It is also used
+	// to detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been
+	// set in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height
+	// is reached and the software will exit.
+	Name string `json:"name,omitempty"`
+
+	// The time after which the upgrade must be performed.
+	// Leave set to its zero value to use a pre-defined Height instead.
+	Time time.Time `json:"time,omitempty"`
+
+	// The height at which the upgrade must be performed.
+	// Only used if Time is not set.
+	Height int64 `json:"height,omitempty"`
+
+	// Any application specific upgrade info to be included on-chain
+	// such as a git commit that validators could automatically upgrade to
+	Memo string `json:"memo,omitempty"`
+}
+
+// The type of function that is called when an upgrade is applied
+type UpgradeHandler func(ctx sdk.Context, plan UpgradePlan)

From 8f092913029a6df442c7c554ca34e0af81545a21 Mon Sep 17 00:00:00 2001
From: Aaron Craelius <aaron@regen.network>
Date: Mon, 25 Mar 2019 12:04:50 -0400
Subject: [PATCH 3/9] #13 Full test coverage for upgrade module

---
 app.go                   |   1 +
 go.mod                   |   1 +
 x/upgrade/codec.go       |  10 +++
 x/upgrade/keeper.go      |  24 ++-----
 x/upgrade/keeper_test.go | 141 +++++++++++++++++++++++++++++++++++++++
 5 files changed, 158 insertions(+), 19 deletions(-)
 create mode 100644 x/upgrade/codec.go
 create mode 100644 x/upgrade/keeper_test.go

diff --git a/app.go b/app.go
index dd59b17600..5a19eddb21 100644
--- a/app.go
+++ b/app.go
@@ -350,6 +350,7 @@ func MakeCodec() *codec.Codec {
 	group.RegisterCodec(cdc)
 	proposal.RegisterCodec(cdc)
 	consortium.RegisterCodec(cdc)
+	upgrade.RegisterCodec(cdc)
 	sdk.RegisterCodec(cdc)
 	codec.RegisterCrypto(cdc)
 	return cdc
diff --git a/go.mod b/go.mod
index 81aff250bb..f098bfd6ef 100644
--- a/go.mod
+++ b/go.mod
@@ -45,6 +45,7 @@ require (
 	github.com/spf13/jwalterweatherman v1.0.0 // indirect
 	github.com/spf13/pflag v1.0.3 // indirect
 	github.com/spf13/viper v1.0.3
+	github.com/stretchr/testify v1.2.2
 	github.com/syndtr/goleveldb v0.0.0-20181128100959-b001fa50d6b2 // indirect
 	github.com/tendermint/btcd v0.0.0-20180816174608-e5840949ff4f // indirect
 	github.com/tendermint/go-amino v0.14.1
diff --git a/x/upgrade/codec.go b/x/upgrade/codec.go
new file mode 100644
index 0000000000..3e95c05bea
--- /dev/null
+++ b/x/upgrade/codec.go
@@ -0,0 +1,10 @@
+package upgrade
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+)
+
+// RegisterCodec registers concrete types on the Amino codec
+func RegisterCodec(cdc *codec.Codec) {
+	cdc.RegisterConcrete(UpgradePlan{}, "upgrade/UpgradePlan", nil)
+}
diff --git a/x/upgrade/keeper.go b/x/upgrade/keeper.go
index ba9f1e56ee..70171cacde 100644
--- a/x/upgrade/keeper.go
+++ b/x/upgrade/keeper.go
@@ -12,7 +12,6 @@ type Keeper struct {
 	cdc             *codec.Codec
 	plan            UpgradePlan
 	haveCachedInfo  bool
-	willUpgrader    func(UpgradePlan)
 	doShutdowner    func(sdk.Context, UpgradePlan)
 	upgradeHandlers map[string]UpgradeHandler
 }
@@ -43,7 +42,7 @@ func (keeper Keeper) ScheduleUpgrade(ctx sdk.Context, plan UpgradePlan) sdk.Erro
 		return err
 	}
 	if !plan.Time.IsZero() {
-		if plan.Time.Before(ctx.BlockHeader().Time) {
+		if !plan.Time.After(ctx.BlockHeader().Time) {
 			return sdk.ErrUnknownRequest("Upgrade cannot be scheduled in the past")
 		}
 	} else {
@@ -79,17 +78,10 @@ func (keeper Keeper) GetUpgradeInfo(ctx sdk.Context, plan *UpgradePlan) sdk.Erro
 	if bz == nil {
 		return sdk.ErrUnknownRequest("Not found")
 	}
-	marshalErr := keeper.cdc.UnmarshalBinaryBare(bz, &plan)
-	if marshalErr != nil {
-		return sdk.ErrUnknownRequest(marshalErr.Error())
-	}
+	keeper.cdc.MustUnmarshalBinaryBare(bz, &plan)
 	return nil
 }
 
-func (keeper *Keeper) SetWillUpgrader(willUpgrader func(plan UpgradePlan)) {
-	keeper.willUpgrader = willUpgrader
-}
-
 func (keeper *Keeper) SetDoShutdowner(doShutdowner func(ctx sdk.Context, plan UpgradePlan)) {
 	keeper.doShutdowner = doShutdowner
 }
@@ -108,19 +100,12 @@ func (keeper *Keeper) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock)
 			return
 		}
 		keeper.haveCachedInfo = true
-		// TODO verify this will always get called at the right time
-		if (!keeper.plan.Time.IsZero() && keeper.plan.Time.After(blockTime)) || keeper.plan.Height > blockHeight {
-			willUpgrader := keeper.willUpgrader
-			if willUpgrader != nil {
-				willUpgrader(keeper.plan)
-			}
-		}
 	}
 
 	if keeper.haveCachedInfo {
 		upgradeTime := keeper.plan.Time
 		upgradeHeight := keeper.plan.Height
-		if (!upgradeTime.IsZero() && (upgradeTime.Before(blockTime) || upgradeTime.Equal(blockTime))) || upgradeHeight <= blockHeight {
+		if (!upgradeTime.IsZero() && !blockTime.Before(upgradeTime)) || upgradeHeight <= blockHeight {
 			handler, ok := keeper.upgradeHandlers[keeper.plan.Name]
 			if ok {
 				// We have an upgrade handler for this upgrade name, so apply the upgrade
@@ -132,11 +117,12 @@ func (keeper *Keeper) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock)
 				store.Set(upgradeDoneKey(keeper.plan.Name), []byte("1"))
 			} else {
 				// We don't have an upgrade handler for this upgrade name, meaning this software is out of date so shutdown
+				ctx.Logger().Error(fmt.Sprintf("UPGRADE \"%s\" NEEDED needed at height %d: %s", keeper.plan.Name, blockHeight, keeper.plan.Memo))
 				doShutdowner := keeper.doShutdowner
 				if doShutdowner != nil {
 					doShutdowner(ctx, keeper.plan)
 				} else {
-					panic(fmt.Sprintf("UPGRADE \"%s\" NEEDED needed at height %d: %s", keeper.plan.Name, blockHeight, keeper.plan.Memo))
+					panic("UPGRADE REQUIRED!")
 				}
 			}
 		}
diff --git a/x/upgrade/keeper_test.go b/x/upgrade/keeper_test.go
new file mode 100644
index 0000000000..09b73b8f7b
--- /dev/null
+++ b/x/upgrade/keeper_test.go
@@ -0,0 +1,141 @@
+package upgrade
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/store"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/suite"
+	abci "github.com/tendermint/tendermint/abci/types"
+	dbm "github.com/tendermint/tendermint/libs/db"
+	"github.com/tendermint/tendermint/libs/log"
+	"testing"
+	"time"
+)
+
+type TestSuite struct {
+	suite.Suite
+	keeper Keeper
+	ctx    sdk.Context
+	cms    store.CommitMultiStore
+}
+
+func (s *TestSuite) SetupTest() {
+	db := dbm.NewMemDB()
+	s.cms = store.NewCommitMultiStore(db)
+	key := sdk.NewKVStoreKey("upgrade")
+	cdc := codec.New()
+	RegisterCodec(cdc)
+	s.keeper = NewKeeper(key, cdc)
+	s.cms.MountStoreWithDB(key, sdk.StoreTypeIAVL, db)
+	_ = s.cms.LoadLatestVersion()
+	s.ctx = sdk.NewContext(s.cms, abci.Header{Height: 10, Time: time.Now()}, false, log.NewNopLogger())
+}
+
+func (s *TestSuite) TestRequireName() {
+	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{})
+	s.Require().NotNil(err)
+	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
+}
+
+func (s *TestSuite) TestRequireFutureTime() {
+	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Time: s.ctx.BlockHeader().Time})
+	s.Require().NotNil(err)
+	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
+}
+
+func (s *TestSuite) TestRequireFutureBlock() {
+	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Height: s.ctx.BlockHeight()})
+	s.Require().NotNil(err)
+	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
+}
+
+func (s *TestSuite) TestDoTimeUpgrade() {
+	s.T().Log("Verify can schedule an upgrade")
+	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Time: time.Now()})
+	s.Require().Nil(err)
+
+	s.VerifyDoUpgrade()
+}
+
+func (s *TestSuite) TestDoHeightUpgrade() {
+	s.T().Log("Verify can schedule an upgrade")
+	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Height: s.ctx.BlockHeight() + 1})
+	s.Require().Nil(err)
+
+	s.VerifyDoUpgrade()
+}
+
+func (s *TestSuite) VerifyDoUpgrade() {
+	s.T().Log("Verify that a panic happens at the upgrade time/height")
+	newCtx := sdk.NewContext(s.cms, abci.Header{Height: s.ctx.BlockHeight() + 1, Time: time.Now()}, false, log.NewNopLogger())
+	req := abci.RequestBeginBlock{Header: newCtx.BlockHeader()}
+	s.Require().Panics(func() {
+		s.keeper.BeginBlocker(newCtx, req)
+	})
+
+	s.T().Log("Verify that the upgrade can be successfully applied with a handler")
+	s.keeper.SetUpgradeHandler("test", func(ctx sdk.Context, plan UpgradePlan) {})
+	s.Require().NotPanics(func() {
+		s.keeper.BeginBlocker(newCtx, req)
+	})
+
+	s.VerifyCleared(newCtx)
+}
+
+func (s *TestSuite) VerifyCleared(newCtx sdk.Context) {
+	s.T().Log("Verify that the upgrade plan has been cleared")
+	var plan UpgradePlan
+	err := s.keeper.GetUpgradeInfo(newCtx, &plan)
+	s.Require().NotNil(err)
+	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
+}
+
+func (s *TestSuite) TestCanClear() {
+	s.T().Log("Verify upgrade is scheduled")
+	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Time: time.Now()})
+	s.Require().Nil(err)
+
+	s.keeper.ClearUpgradePlan(s.ctx)
+
+	s.VerifyCleared(s.ctx)
+}
+
+func (s *TestSuite) TestCantApplySameUpgradeTwice() {
+	s.TestDoTimeUpgrade()
+	s.T().Log("Verify an upgrade named \"test\" can't be scheduled twice")
+	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Time: time.Now()})
+	s.Require().NotNil(err)
+	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
+}
+
+func (s *TestSuite) TestDoShutdowner() {
+	s.T().Log("Set a custom DoShutdowner")
+	shutdownerCalled := false
+	s.keeper.SetDoShutdowner(func(ctx sdk.Context, plan UpgradePlan) {
+		shutdownerCalled = true
+	})
+
+	s.T().Log("Run an upgrade and verify that the custom shutdowner was called and no panic happened")
+	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Time: time.Now()})
+	s.Require().Nil(err)
+
+	header := abci.Header{Height: s.ctx.BlockHeight() + 1, Time: time.Now()}
+	newCtx := sdk.NewContext(s.cms, header, false, log.NewNopLogger())
+	req := abci.RequestBeginBlock{Header: header}
+	s.Require().NotPanics(func() {
+		s.keeper.BeginBlocker(newCtx, req)
+	})
+	s.Require().True(shutdownerCalled)
+}
+
+func (s *TestSuite) TestNoSpuriousUpgrades() {
+	s.T().Log("Verify that no upgrade panic is triggered in the BeginBlocker when we haven't scheduled an upgrade")
+	req := abci.RequestBeginBlock{Header: s.ctx.BlockHeader()}
+	s.Require().NotPanics(func() {
+		s.keeper.BeginBlocker(s.ctx, req)
+	})
+}
+
+func TestTestSuite(t *testing.T) {
+	suite.Run(t, new(TestSuite))
+}

From cb4ab6b35b554010645e5c5adc3712bfe2dbfbc5 Mon Sep 17 00:00:00 2001
From: Aaron Craelius <aaron@regen.network>
Date: Mon, 25 Mar 2019 12:12:01 -0400
Subject: [PATCH 4/9] #13 Eliminate use of keeper as a cache and just check the
 store every time (the store would get checked every time there is no upgrade
 anyway)

---
 x/upgrade/keeper.go      | 58 +++++++++++++++++-----------------------
 x/upgrade/keeper_test.go |  3 +--
 2 files changed, 26 insertions(+), 35 deletions(-)

diff --git a/x/upgrade/keeper.go b/x/upgrade/keeper.go
index 70171cacde..abd6d3fc97 100644
--- a/x/upgrade/keeper.go
+++ b/x/upgrade/keeper.go
@@ -10,8 +10,6 @@ import (
 type Keeper struct {
 	storeKey        sdk.StoreKey
 	cdc             *codec.Codec
-	plan            UpgradePlan
-	haveCachedInfo  bool
 	doShutdowner    func(sdk.Context, UpgradePlan)
 	upgradeHandlers map[string]UpgradeHandler
 }
@@ -24,7 +22,6 @@ func NewKeeper(storeKey sdk.StoreKey, cdc *codec.Codec) Keeper {
 	return Keeper{
 		storeKey:        storeKey,
 		cdc:             cdc,
-		haveCachedInfo:  false,
 		upgradeHandlers: map[string]UpgradeHandler{},
 	}
 }
@@ -72,14 +69,14 @@ func (plan UpgradePlan) ValidateBasic() sdk.Error {
 	return nil
 }
 
-func (keeper Keeper) GetUpgradeInfo(ctx sdk.Context, plan *UpgradePlan) sdk.Error {
+func (keeper Keeper) GetUpgradeInfo(ctx sdk.Context) (plan UpgradePlan, err sdk.Error) {
 	store := ctx.KVStore(keeper.storeKey)
 	bz := store.Get([]byte(planKey))
 	if bz == nil {
-		return sdk.ErrUnknownRequest("Not found")
+		return plan, sdk.ErrUnknownRequest("Not found")
 	}
 	keeper.cdc.MustUnmarshalBinaryBare(bz, &plan)
-	return nil
+	return plan, nil
 }
 
 func (keeper *Keeper) SetDoShutdowner(doShutdowner func(ctx sdk.Context, plan UpgradePlan)) {
@@ -94,36 +91,31 @@ func (keeper *Keeper) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock)
 	blockTime := ctx.BlockHeader().Time
 	blockHeight := ctx.BlockHeight()
 
-	if !keeper.haveCachedInfo {
-		err := keeper.GetUpgradeInfo(ctx, &keeper.plan)
-		if err != nil {
-			return
-		}
-		keeper.haveCachedInfo = true
+	plan, err := keeper.GetUpgradeInfo(ctx)
+	if err != nil {
+		return
 	}
 
-	if keeper.haveCachedInfo {
-		upgradeTime := keeper.plan.Time
-		upgradeHeight := keeper.plan.Height
-		if (!upgradeTime.IsZero() && !blockTime.Before(upgradeTime)) || upgradeHeight <= blockHeight {
-			handler, ok := keeper.upgradeHandlers[keeper.plan.Name]
-			if ok {
-				// We have an upgrade handler for this upgrade name, so apply the upgrade
-				ctx.Logger().Info(fmt.Sprintf("Applying upgrade \"%s\" at height %d", keeper.plan.Name, blockHeight))
-				handler(ctx, keeper.plan)
-				keeper.ClearUpgradePlan(ctx)
-				// Mark this upgrade name as being done so the name can't be reused accidentally
-				store := ctx.KVStore(keeper.storeKey)
-				store.Set(upgradeDoneKey(keeper.plan.Name), []byte("1"))
+	upgradeTime := plan.Time
+	upgradeHeight := plan.Height
+	if (!upgradeTime.IsZero() && !blockTime.Before(upgradeTime)) || upgradeHeight <= blockHeight {
+		handler, ok := keeper.upgradeHandlers[plan.Name]
+		if ok {
+			// We have an upgrade handler for this upgrade name, so apply the upgrade
+			ctx.Logger().Info(fmt.Sprintf("Applying upgrade \"%s\" at height %d", plan.Name, blockHeight))
+			handler(ctx, plan)
+			keeper.ClearUpgradePlan(ctx)
+			// Mark this upgrade name as being done so the name can't be reused accidentally
+			store := ctx.KVStore(keeper.storeKey)
+			store.Set(upgradeDoneKey(plan.Name), []byte("1"))
+		} else {
+			// We don't have an upgrade handler for this upgrade name, meaning this software is out of date so shutdown
+			ctx.Logger().Error(fmt.Sprintf("UPGRADE \"%s\" NEEDED needed at height %d: %s", plan.Name, blockHeight, plan.Memo))
+			doShutdowner := keeper.doShutdowner
+			if doShutdowner != nil {
+				doShutdowner(ctx, plan)
 			} else {
-				// We don't have an upgrade handler for this upgrade name, meaning this software is out of date so shutdown
-				ctx.Logger().Error(fmt.Sprintf("UPGRADE \"%s\" NEEDED needed at height %d: %s", keeper.plan.Name, blockHeight, keeper.plan.Memo))
-				doShutdowner := keeper.doShutdowner
-				if doShutdowner != nil {
-					doShutdowner(ctx, keeper.plan)
-				} else {
-					panic("UPGRADE REQUIRED!")
-				}
+				panic("UPGRADE REQUIRED!")
 			}
 		}
 	}
diff --git a/x/upgrade/keeper_test.go b/x/upgrade/keeper_test.go
index 09b73b8f7b..19ea5e6123 100644
--- a/x/upgrade/keeper_test.go
+++ b/x/upgrade/keeper_test.go
@@ -84,8 +84,7 @@ func (s *TestSuite) VerifyDoUpgrade() {
 
 func (s *TestSuite) VerifyCleared(newCtx sdk.Context) {
 	s.T().Log("Verify that the upgrade plan has been cleared")
-	var plan UpgradePlan
-	err := s.keeper.GetUpgradeInfo(newCtx, &plan)
+	_, err := s.keeper.GetUpgradeInfo(newCtx)
 	s.Require().NotNil(err)
 	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
 }

From 33b84ae9790a5e9396c1fbd62b9e407e96c90ae8 Mon Sep 17 00:00:00 2001
From: Aaron Craelius <aaron@regen.network>
Date: Mon, 25 Mar 2019 13:50:46 -0400
Subject: [PATCH 5/9] #13 Update docs, fix tests

---
 Makefile                      |  2 +-
 app.go                        | 10 ++++-----
 util/godog.go                 |  1 +
 x/consortium/actions.go       |  2 +-
 x/consortium/client/cli/tx.go | 29 +++++++++++++++++++-------
 x/group/types.go              |  2 +-
 x/upgrade/codec.go            |  2 +-
 x/upgrade/keeper.go           | 39 ++++++++++++++++++++++-------------
 x/upgrade/keeper_test.go      | 25 +++++++++++-----------
 x/upgrade/types.go            |  9 ++++----
 10 files changed, 73 insertions(+), 48 deletions(-)

diff --git a/Makefile b/Makefile
index 8ba80d8076..81943f2421 100644
--- a/Makefile
+++ b/Makefile
@@ -5,7 +5,7 @@ install:
 	go install ./cmd/xrncli
 
 test:
-	go test ./... -godog.strict
+	go test ./...
 
 lint:
 	go get -u golang.org/x/lint/golint
diff --git a/app.go b/app.go
index 5a19eddb21..ca4646bf7e 100644
--- a/app.go
+++ b/app.go
@@ -160,7 +160,7 @@ func NewXrnApp(logger log.Logger, db dbm.DB, postgresUrl string) *xrnApp {
 
 	app.upgradeKeeper = upgrade.NewKeeper(app.upgradeStoreKey, cdc)
 	app.upgradeKeeper.SetDoShutdowner(app.shutdownOnUpgrade)
-	app.upgradeKeeper.SetUpgradeHandler("test3", func(ctx sdk.Context, plan upgrade.UpgradePlan) {
+	app.upgradeKeeper.SetUpgradeHandler("test3", func(ctx sdk.Context, plan upgrade.Plan) {
 		ctx.Logger().Info("In upgrade 3 handler!")
 	})
 
@@ -252,12 +252,12 @@ func (app *xrnApp) initChainer(ctx sdk.Context, req abci.RequestInitChain) abci.
 	return abci.ResponseInitChain{}
 }
 
-func (app *xrnApp) shutdownOnUpgrade(ctx sdk.Context, plan upgrade.UpgradePlan) {
-	if len(plan.Memo) != 0 {
+func (app *xrnApp) shutdownOnUpgrade(ctx sdk.Context, plan upgrade.Plan) {
+	if len(plan.Info) != 0 {
 		home := viper.GetString(cli.HomeFlag)
-		_ = ioutil.WriteFile(filepath.Join(home, "data", "upgrade-info"), []byte(plan.Memo), 0644)
+		_ = ioutil.WriteFile(filepath.Join(home, "data", "upgrade-info"), []byte(plan.Info), 0644)
 	}
-	ctx.Logger().Error(fmt.Sprintf("UPGRADE \"%s\" NEEDED needed at height %d: %s", plan.Name, ctx.BlockHeight(), plan.Memo))
+	ctx.Logger().Error(fmt.Sprintf("UPGRADE \"%s\" NEEDED needed at height %d: %s", plan.Name, ctx.BlockHeight(), plan.Info))
 	os.Exit(1)
 }
 
diff --git a/util/godog.go b/util/godog.go
index 506368a738..4113082581 100644
--- a/util/godog.go
+++ b/util/godog.go
@@ -11,6 +11,7 @@ import (
 var opt = godog.Options{
 	Output: colors.Colored(os.Stdout),
 	Format: "progress", // can define default values
+	Strict: true,
 }
 
 func init() {
diff --git a/x/consortium/actions.go b/x/consortium/actions.go
index e979af77ce..356c70d84e 100644
--- a/x/consortium/actions.go
+++ b/x/consortium/actions.go
@@ -8,7 +8,7 @@ import (
 )
 
 type ActionScheduleUpgrade struct {
-	Plan upgrade.UpgradePlan `json:"upgrade_plan"`
+	Plan upgrade.Plan `json:"upgrade_plan"`
 }
 
 type ActionCancelUpgrade struct {
diff --git a/x/consortium/client/cli/tx.go b/x/consortium/client/cli/tx.go
index b49b737fd5..277e7f36a5 100644
--- a/x/consortium/client/cli/tx.go
+++ b/x/consortium/client/cli/tx.go
@@ -1,6 +1,8 @@
 package cli
 
 import (
+	"encoding/json"
+	"fmt"
 	"github.com/regen-network/regen-ledger/x/consortium"
 	"github.com/regen-network/regen-ledger/x/proposal"
 	proposalcli "github.com/regen-network/regen-ledger/x/proposal/client/cli"
@@ -14,7 +16,7 @@ import (
 func GetCmdProposeUpgrade(cdc *codec.Codec) *cobra.Command {
 	var timeStr string
 	var height int64
-	var memo string
+	var commit string
 
 	cmd := proposalcli.GetCmdPropose(cdc, func(cmd *cobra.Command, args []string) (action proposal.ProposalAction, e error) {
 		name := args[0]
@@ -24,25 +26,36 @@ func GetCmdProposeUpgrade(cdc *codec.Codec) *cobra.Command {
 		if len(timeStr) != 0 {
 			t, err = time.Parse(time.RFC3339, timeStr)
 			if err != nil {
-				panic(err)
+				return nil, fmt.Errorf("error parsing time: %+v", err)
+			}
+
+			if height != 0 {
+				return nil, fmt.Errorf("only one of --time or --height should be specified")
 			}
 		}
 
+		info := make(map[string]interface{})
+		if len(commit) != 0 {
+			info["commit"] = commit
+		}
+
+		jsonInfo, err := json.Marshal(info)
+
 		return consortium.ActionScheduleUpgrade{
-			Plan: upgrade.UpgradePlan{
+			Plan: upgrade.Plan{
 				Name:   name,
 				Time:   t,
 				Height: height,
-				Memo:   memo,
+				Info:   string(jsonInfo),
 			},
 		}, nil
 	})
 
 	cmd.Args = cobra.ExactArgs(1)
-	cmd.Use = "propose-upgrade <name> [--upgrade-time <time> | --upgrade-height <height>] [--upgrade-memo <memo>]"
+	cmd.Use = "propose-upgrade <name> [--time <time> | --height <height>] [--commit <commit-hash>]"
 	cmd.Short = "Propose an ESP version"
-	cmd.Flags().StringVar(&timeStr, "upgrade-time", "", "The time after which the upgrade must happen in ISO8601/RFC3339 format (omit if using --upgrade-height)")
-	cmd.Flags().Int64Var(&height, "upgrade-height", 0, "The height at which the upgrade must happen (omit if using --upgrade-time)")
-	cmd.Flags().StringVar(&memo, "upgrade-memo", "", "Any memo to attach to the upgrade plan such as a git commit hash")
+	cmd.Flags().StringVar(&timeStr, "time", "", "The time after which the upgrade must happen in ISO8601/RFC3339 format (omit if using --upgrade-height)")
+	cmd.Flags().Int64Var(&height, "height", 0, "The height at which the upgrade must happen (omit if using --upgrade-time)")
+	cmd.Flags().StringVar(&commit, "commit", "", "The git commit hash of the version of the software to upgrade to")
 	return cmd
 }
diff --git a/x/group/types.go b/x/group/types.go
index 92a6badf78..4dd0b46f18 100644
--- a/x/group/types.go
+++ b/x/group/types.go
@@ -17,7 +17,7 @@ type Group struct {
 	// A big integer is used here to avoid any potential vulnerabilities from overflow errors
 	// where large weight and threshold values are used.
 	DecisionThreshold sdk.Int `json:"decision_threshold"`
-	// TODO maybe make this something more specific to a domain name or a claim on identity? or Memo leave it generic
+	// TODO maybe make this something more specific to a domain name or a claim on identity? or Info leave it generic
 	Memo string `json:"memo,omitempty"`
 }
 
diff --git a/x/upgrade/codec.go b/x/upgrade/codec.go
index 3e95c05bea..9197457787 100644
--- a/x/upgrade/codec.go
+++ b/x/upgrade/codec.go
@@ -6,5 +6,5 @@ import (
 
 // RegisterCodec registers concrete types on the Amino codec
 func RegisterCodec(cdc *codec.Codec) {
-	cdc.RegisterConcrete(UpgradePlan{}, "upgrade/UpgradePlan", nil)
+	cdc.RegisterConcrete(Plan{}, "upgrade/Plan", nil)
 }
diff --git a/x/upgrade/keeper.go b/x/upgrade/keeper.go
index abd6d3fc97..cb9494d964 100644
--- a/x/upgrade/keeper.go
+++ b/x/upgrade/keeper.go
@@ -7,33 +7,36 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 )
 
+// Keeper of the upgrade module
 type Keeper struct {
 	storeKey        sdk.StoreKey
 	cdc             *codec.Codec
-	doShutdowner    func(sdk.Context, UpgradePlan)
-	upgradeHandlers map[string]UpgradeHandler
+	doShutdowner    func(sdk.Context, Plan)
+	upgradeHandlers map[string]Handler
 }
 
 const (
 	planKey = "plan"
 )
 
+// NewKeeper constructs an upgrade keeper
 func NewKeeper(storeKey sdk.StoreKey, cdc *codec.Codec) Keeper {
 	return Keeper{
 		storeKey:        storeKey,
 		cdc:             cdc,
-		upgradeHandlers: map[string]UpgradeHandler{},
+		upgradeHandlers: map[string]Handler{},
 	}
 }
 
-// Sets an upgrade handler for the upgrade specified by name. This handler will be called when the upgrade
+// SetUpgradeHandler sets an UpgradeHandler for the upgrade specified by name. This handler will be called when the upgrade
 // with this name is applied. In order for an upgrade with the given name to proceed, a handler for this upgrade
 // must be set even if it is a no-op function.
-func (keeper Keeper) SetUpgradeHandler(name string, upgradeHandler UpgradeHandler) {
+func (keeper Keeper) SetUpgradeHandler(name string, upgradeHandler Handler) {
 	keeper.upgradeHandlers[name] = upgradeHandler
 }
 
-func (keeper Keeper) ScheduleUpgrade(ctx sdk.Context, plan UpgradePlan) sdk.Error {
+// ScheduleUpgrade schedules an upgrade based on the specified plan
+func (keeper Keeper) ScheduleUpgrade(ctx sdk.Context, plan Plan) sdk.Error {
 	err := plan.ValidateBasic()
 	if err != nil {
 		return err
@@ -56,12 +59,14 @@ func (keeper Keeper) ScheduleUpgrade(ctx sdk.Context, plan UpgradePlan) sdk.Erro
 	return nil
 }
 
+// ClearUpgradePlan clears any schedule upgrade
 func (keeper Keeper) ClearUpgradePlan(ctx sdk.Context) {
 	store := ctx.KVStore(keeper.storeKey)
 	store.Delete([]byte(planKey))
 }
 
-func (plan UpgradePlan) ValidateBasic() sdk.Error {
+// ValidateBasic does basic validation of an Plan
+func (plan Plan) ValidateBasic() sdk.Error {
 	if len(plan.Name) == 0 {
 		return sdk.ErrUnknownRequest("Name cannot be empty")
 
@@ -69,17 +74,22 @@ func (plan UpgradePlan) ValidateBasic() sdk.Error {
 	return nil
 }
 
-func (keeper Keeper) GetUpgradeInfo(ctx sdk.Context) (plan UpgradePlan, err sdk.Error) {
+// GetUpgradePlan returns the currently scheduled Plan if any, setting havePlan to true if there is a scheduled
+// upgrade or false if there is none
+func (keeper Keeper) GetUpgradePlan(ctx sdk.Context) (plan Plan, havePlan bool) {
 	store := ctx.KVStore(keeper.storeKey)
 	bz := store.Get([]byte(planKey))
 	if bz == nil {
-		return plan, sdk.ErrUnknownRequest("Not found")
+		return plan, false
 	}
 	keeper.cdc.MustUnmarshalBinaryBare(bz, &plan)
-	return plan, nil
+	return plan, true
 }
 
-func (keeper *Keeper) SetDoShutdowner(doShutdowner func(ctx sdk.Context, plan UpgradePlan)) {
+// SetDoShutdowner sets a custom shutdown function for the upgrade module. This shutdown
+// function will be called during the BeginBlock method when an upgrade is required
+// instead of panic'ing which is the default behavior
+func (keeper *Keeper) SetDoShutdowner(doShutdowner func(ctx sdk.Context, plan Plan)) {
 	keeper.doShutdowner = doShutdowner
 }
 
@@ -87,12 +97,13 @@ func upgradeDoneKey(name string) []byte {
 	return []byte(fmt.Sprintf("done/%s", name))
 }
 
+// BeginBlocker should be called inside the BeginBlocker method of any app using the upgrade module
 func (keeper *Keeper) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock) {
 	blockTime := ctx.BlockHeader().Time
 	blockHeight := ctx.BlockHeight()
 
-	plan, err := keeper.GetUpgradeInfo(ctx)
-	if err != nil {
+	plan, havePlan := keeper.GetUpgradePlan(ctx)
+	if !havePlan {
 		return
 	}
 
@@ -110,7 +121,7 @@ func (keeper *Keeper) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock)
 			store.Set(upgradeDoneKey(plan.Name), []byte("1"))
 		} else {
 			// We don't have an upgrade handler for this upgrade name, meaning this software is out of date so shutdown
-			ctx.Logger().Error(fmt.Sprintf("UPGRADE \"%s\" NEEDED needed at height %d: %s", plan.Name, blockHeight, plan.Memo))
+			ctx.Logger().Error(fmt.Sprintf("UPGRADE \"%s\" NEEDED needed at height %d: %s", plan.Name, blockHeight, plan.Info))
 			doShutdowner := keeper.doShutdowner
 			if doShutdowner != nil {
 				doShutdowner(ctx, plan)
diff --git a/x/upgrade/keeper_test.go b/x/upgrade/keeper_test.go
index 19ea5e6123..515604fc55 100644
--- a/x/upgrade/keeper_test.go
+++ b/x/upgrade/keeper_test.go
@@ -32,26 +32,26 @@ func (s *TestSuite) SetupTest() {
 }
 
 func (s *TestSuite) TestRequireName() {
-	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{})
+	err := s.keeper.ScheduleUpgrade(s.ctx, Plan{})
 	s.Require().NotNil(err)
 	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
 }
 
 func (s *TestSuite) TestRequireFutureTime() {
-	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Time: s.ctx.BlockHeader().Time})
+	err := s.keeper.ScheduleUpgrade(s.ctx, Plan{Name: "test", Time: s.ctx.BlockHeader().Time})
 	s.Require().NotNil(err)
 	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
 }
 
 func (s *TestSuite) TestRequireFutureBlock() {
-	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Height: s.ctx.BlockHeight()})
+	err := s.keeper.ScheduleUpgrade(s.ctx, Plan{Name: "test", Height: s.ctx.BlockHeight()})
 	s.Require().NotNil(err)
 	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
 }
 
 func (s *TestSuite) TestDoTimeUpgrade() {
 	s.T().Log("Verify can schedule an upgrade")
-	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Time: time.Now()})
+	err := s.keeper.ScheduleUpgrade(s.ctx, Plan{Name: "test", Time: time.Now()})
 	s.Require().Nil(err)
 
 	s.VerifyDoUpgrade()
@@ -59,7 +59,7 @@ func (s *TestSuite) TestDoTimeUpgrade() {
 
 func (s *TestSuite) TestDoHeightUpgrade() {
 	s.T().Log("Verify can schedule an upgrade")
-	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Height: s.ctx.BlockHeight() + 1})
+	err := s.keeper.ScheduleUpgrade(s.ctx, Plan{Name: "test", Height: s.ctx.BlockHeight() + 1})
 	s.Require().Nil(err)
 
 	s.VerifyDoUpgrade()
@@ -74,7 +74,7 @@ func (s *TestSuite) VerifyDoUpgrade() {
 	})
 
 	s.T().Log("Verify that the upgrade can be successfully applied with a handler")
-	s.keeper.SetUpgradeHandler("test", func(ctx sdk.Context, plan UpgradePlan) {})
+	s.keeper.SetUpgradeHandler("test", func(ctx sdk.Context, plan Plan) {})
 	s.Require().NotPanics(func() {
 		s.keeper.BeginBlocker(newCtx, req)
 	})
@@ -84,14 +84,13 @@ func (s *TestSuite) VerifyDoUpgrade() {
 
 func (s *TestSuite) VerifyCleared(newCtx sdk.Context) {
 	s.T().Log("Verify that the upgrade plan has been cleared")
-	_, err := s.keeper.GetUpgradeInfo(newCtx)
-	s.Require().NotNil(err)
-	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
+	_, havePlan := s.keeper.GetUpgradePlan(newCtx)
+	s.Require().False(havePlan)
 }
 
 func (s *TestSuite) TestCanClear() {
 	s.T().Log("Verify upgrade is scheduled")
-	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Time: time.Now()})
+	err := s.keeper.ScheduleUpgrade(s.ctx, Plan{Name: "test", Time: time.Now()})
 	s.Require().Nil(err)
 
 	s.keeper.ClearUpgradePlan(s.ctx)
@@ -102,7 +101,7 @@ func (s *TestSuite) TestCanClear() {
 func (s *TestSuite) TestCantApplySameUpgradeTwice() {
 	s.TestDoTimeUpgrade()
 	s.T().Log("Verify an upgrade named \"test\" can't be scheduled twice")
-	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Time: time.Now()})
+	err := s.keeper.ScheduleUpgrade(s.ctx, Plan{Name: "test", Time: time.Now()})
 	s.Require().NotNil(err)
 	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
 }
@@ -110,12 +109,12 @@ func (s *TestSuite) TestCantApplySameUpgradeTwice() {
 func (s *TestSuite) TestDoShutdowner() {
 	s.T().Log("Set a custom DoShutdowner")
 	shutdownerCalled := false
-	s.keeper.SetDoShutdowner(func(ctx sdk.Context, plan UpgradePlan) {
+	s.keeper.SetDoShutdowner(func(ctx sdk.Context, plan Plan) {
 		shutdownerCalled = true
 	})
 
 	s.T().Log("Run an upgrade and verify that the custom shutdowner was called and no panic happened")
-	err := s.keeper.ScheduleUpgrade(s.ctx, UpgradePlan{Name: "test", Time: time.Now()})
+	err := s.keeper.ScheduleUpgrade(s.ctx, Plan{Name: "test", Time: time.Now()})
 	s.Require().Nil(err)
 
 	header := abci.Header{Height: s.ctx.BlockHeight() + 1, Time: time.Now()}
diff --git a/x/upgrade/types.go b/x/upgrade/types.go
index e51c9df45d..3b1049531f 100644
--- a/x/upgrade/types.go
+++ b/x/upgrade/types.go
@@ -3,7 +3,8 @@ package upgrade
 import "time"
 import sdk "github.com/cosmos/cosmos-sdk/types"
 
-type UpgradePlan struct {
+// Plan specifies information about a planned upgrade and when it should occur
+type Plan struct {
 	// Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any
 	// special "on-upgrade" commands during the first BeginBlock method after the upgrade is applied. It is also used
 	// to detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been
@@ -21,8 +22,8 @@ type UpgradePlan struct {
 
 	// Any application specific upgrade info to be included on-chain
 	// such as a git commit that validators could automatically upgrade to
-	Memo string `json:"memo,omitempty"`
+	Info string `json:"info,omitempty"`
 }
 
-// The type of function that is called when an upgrade is applied
-type UpgradeHandler func(ctx sdk.Context, plan UpgradePlan)
+// UpgradeHandler specifies the type of function that is called when an upgrade is applied
+type Handler func(ctx sdk.Context, plan Plan)

From a87f72256268f0f42f3e42208a3206df25e6c75e Mon Sep 17 00:00:00 2001
From: Aaron Craelius <aaron@regen.network>
Date: Mon, 25 Mar 2019 15:04:15 -0400
Subject: [PATCH 6/9] #13 Added incremental migration support to postgres
 indexer

---
 app.go                    |  2 +-
 index/postgresql/impl.go  | 52 +++++++++++++++++++++++++++++++++------
 index/postgresql/types.go |  2 +-
 index/types.go            |  2 ++
 x/geo/types.go            |  4 +++
 5 files changed, 53 insertions(+), 9 deletions(-)

diff --git a/app.go b/app.go
index ca4646bf7e..9c9e181cd6 100644
--- a/app.go
+++ b/app.go
@@ -123,7 +123,7 @@ func NewXrnApp(logger log.Logger, db dbm.DB, postgresUrl string) *xrnApp {
 	if len(postgresUrl) != 0 {
 		pgIndexer, err := postgresql.NewIndexer(postgresUrl, txDecoder)
 		if err == nil {
-			pgIndexer.AddMigration(geo.PostgresSchema)
+			pgIndexer.AddMigrations("geo", geo.PostgresMigrations)
 			app.pgIndexer = pgIndexer
 			logger.Info("Started PostgreSQL Indexer")
 		} else {
diff --git a/index/postgresql/impl.go b/index/postgresql/impl.go
index dc2aacc30c..094dd9b2db 100644
--- a/index/postgresql/impl.go
+++ b/index/postgresql/impl.go
@@ -13,7 +13,7 @@ import (
 type indexer struct {
 	conn        *sql.DB
 	txDecoder   sdk.TxDecoder
-	migrations  []string
+	migrations  map[string][]string
 	curTx       *sql.Tx
 	blockHeader abci.Header
 }
@@ -26,11 +26,11 @@ func NewIndexer(connString string, txDecoder sdk.TxDecoder) (Indexer, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &indexer{conn: conn, txDecoder: txDecoder, migrations: []string{}}, nil
+	return &indexer{conn: conn, txDecoder: txDecoder, migrations: make(map[string][]string)}, nil
 }
 
-func (indexer *indexer) AddMigration(ddl string) {
-	indexer.migrations = append(indexer.migrations, ddl)
+func (indexer *indexer) AddMigrations(module string, ddlStatements []string) {
+	indexer.migrations[module] = ddlStatements
 }
 
 func (indexer *indexer) Exec(query string, args ...interface{}) {
@@ -45,12 +45,50 @@ func (indexer *indexer) Exec(query string, args ...interface{}) {
 }
 
 func (indexer *indexer) OnInitChain(abci.RequestInitChain, abci.ResponseInitChain) {
-	_, err := indexer.conn.Exec(InitialSchema)
+	indexer.ApplyMigrations()
+}
+
+var baseMigrations = []string{InitialSchema}
+
+func (indexer *indexer) ApplyMigrations() {
+	_, err := indexer.conn.Exec(`CREATE TABLE IF NOT EXISTS __migration_state (
+      module text PRIMARY KEY,
+      version int,
+      other jsonb
+	);`)
 	if err != nil {
 		panic(err)
 	}
-	for _, ddl := range indexer.migrations {
-		_, err := indexer.conn.Exec(ddl)
+	indexer.applyModuleMigrations("", baseMigrations)
+	for key, value := range indexer.migrations {
+		indexer.applyModuleMigrations(key, value)
+	}
+}
+
+func (indexer *indexer) applyModuleMigrations(module string, ddl []string) {
+	row := indexer.conn.QueryRow("SELECT version FROM __migration_state WHERE module = $1", module)
+	version := 0
+	haveRow := false
+	if row != nil {
+		err := row.Scan(&version)
+		if err == nil {
+			haveRow = true
+		}
+	}
+	n := len(ddl)
+	for i := version; i < n; i++ {
+		_, err := indexer.conn.Exec(ddl[i])
+		if err != nil {
+			panic(err)
+		}
+	}
+	if !haveRow {
+		_, err := indexer.conn.Exec("INSERT INTO __migration_state (module, version) VALUES ($1, $2)", module, n)
+		if err != nil {
+			panic(err)
+		}
+	} else {
+		_, err := indexer.conn.Exec("UPDATE __migration_state SET version = $1 WHERE module = $2", n, module)
 		if err != nil {
 			panic(err)
 		}
diff --git a/index/postgresql/types.go b/index/postgresql/types.go
index bbc4bf9a2d..79f03ed5d5 100644
--- a/index/postgresql/types.go
+++ b/index/postgresql/types.go
@@ -12,7 +12,7 @@ type Indexer interface {
 	// AddMigration adds a migration to the list of migrations to be run during
 	// InitChain or an upgrade. Migrations will be run in the order
 	// they are added
-	AddMigration(ddl string)
+	AddMigrations(module string, ddlStatements []string)
 
 	// Exec executes a PostgreSQL statement against the database.
 	// Can be used in keepers for custom indexing
diff --git a/index/types.go b/index/types.go
index 8606f0b9fc..9090c63ef8 100644
--- a/index/types.go
+++ b/index/types.go
@@ -12,6 +12,8 @@ import (
 type Indexer interface {
 	// OnInitChain intercepts the InitChain ABCI method
 	OnInitChain(abci.RequestInitChain, abci.ResponseInitChain)
+	// ApplyMigrations applies any pending migrations
+	ApplyMigrations()
 	// OnBeginBlock intercepts the BeginBlock ABCI method
 	OnBeginBlock(abci.RequestBeginBlock, abci.ResponseBeginBlock)
 	// BeforeDeliverTx should be called on the ABCI DeliverTx method
diff --git a/x/geo/types.go b/x/geo/types.go
index 3d3da32612..9cf154a4b7 100644
--- a/x/geo/types.go
+++ b/x/geo/types.go
@@ -29,6 +29,10 @@ type Geometry struct {
 
 type GeoAddress []byte
 
+var PostgresMigrations = []string{
+	PostgresSchema,
+}
+
 const PostgresSchema = `
 CREATE TABLE geo (
   url text NOT NULL PRIMARY KEY,

From 52beb32ec85b853606cab487cf911f793907c5cc Mon Sep 17 00:00:00 2001
From: Aaron Craelius <aaron@regen.network>
Date: Tue, 26 Mar 2019 11:36:34 -0400
Subject: [PATCH 7/9] #13 Added cli and REST query support, cancel upgrade
 proposal to consortium module

---
 cmd/xrncli/main.go                   |  6 +++++
 x/consortium/client/cli/tx.go        | 25 +++++++++++-------
 x/consortium/client/module_client.go |  1 +
 x/consortium/codec.go                |  3 ++-
 x/proposal/keeper.go                 |  1 +
 x/upgrade/client/cli/query.go        | 36 +++++++++++++++++++++++++
 x/upgrade/client/rest/rest.go        | 39 ++++++++++++++++++++++++++++
 x/upgrade/doc.go                     |  5 ++++
 x/upgrade/keeper.go                  | 11 +++++---
 x/upgrade/types.go                   | 19 +++++++++++++-
 10 files changed, 131 insertions(+), 15 deletions(-)
 create mode 100644 x/upgrade/client/cli/query.go
 create mode 100644 x/upgrade/client/rest/rest.go
 create mode 100644 x/upgrade/doc.go

diff --git a/cmd/xrncli/main.go b/cmd/xrncli/main.go
index 0a95de2148..13e372f94d 100644
--- a/cmd/xrncli/main.go
+++ b/cmd/xrncli/main.go
@@ -30,6 +30,8 @@ import (
 	geoclient "github.com/regen-network/regen-ledger/x/geo/client"
 	agentclient "github.com/regen-network/regen-ledger/x/group/client"
 	proposalclient "github.com/regen-network/regen-ledger/x/proposal/client"
+	upgradecli "github.com/regen-network/regen-ledger/x/upgrade/client/cli"
+	upgraderest "github.com/regen-network/regen-ledger/x/upgrade/client/rest"
 	cmn "github.com/tendermint/tendermint/libs/common"
 )
 
@@ -38,6 +40,7 @@ const (
 	storeData     = "data"
 	storeAgent    = "group"
 	storeProposal = "proposal"
+	storeUpgrade  = "upgrade"
 )
 
 var defaultCLIHome = os.ExpandEnv("$HOME/.xrncli")
@@ -178,6 +181,7 @@ func registerRoutes(rs *lcd.RestServer) {
 	auth.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, storeAcc)
 	bank.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
 	datarest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, storeData)
+	upgraderest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, "upgrade-plan", storeUpgrade)
 }
 
 func queryCmd(cdc *amino.Codec, mc []sdk.ModuleClients) *cobra.Command {
@@ -200,6 +204,8 @@ func queryCmd(cdc *amino.Codec, mc []sdk.ModuleClients) *cobra.Command {
 		queryCmd.AddCommand(m.GetQueryCmd())
 	}
 
+	queryCmd.AddCommand(upgradecli.GetQueryCmd("upgrade-plan", storeUpgrade, cdc))
+
 	addNodeFlags(queryCmd)
 
 	return queryCmd
diff --git a/x/consortium/client/cli/tx.go b/x/consortium/client/cli/tx.go
index 277e7f36a5..5dfc9b7254 100644
--- a/x/consortium/client/cli/tx.go
+++ b/x/consortium/client/cli/tx.go
@@ -28,10 +28,6 @@ func GetCmdProposeUpgrade(cdc *codec.Codec) *cobra.Command {
 			if err != nil {
 				return nil, fmt.Errorf("error parsing time: %+v", err)
 			}
-
-			if height != 0 {
-				return nil, fmt.Errorf("only one of --time or --height should be specified")
-			}
 		}
 
 		info := make(map[string]interface{})
@@ -52,10 +48,21 @@ func GetCmdProposeUpgrade(cdc *codec.Codec) *cobra.Command {
 	})
 
 	cmd.Args = cobra.ExactArgs(1)
-	cmd.Use = "propose-upgrade <name> [--time <time> | --height <height>] [--commit <commit-hash>]"
-	cmd.Short = "Propose an ESP version"
-	cmd.Flags().StringVar(&timeStr, "time", "", "The time after which the upgrade must happen in ISO8601/RFC3339 format (omit if using --upgrade-height)")
-	cmd.Flags().Int64Var(&height, "height", 0, "The height at which the upgrade must happen (omit if using --upgrade-time)")
-	cmd.Flags().StringVar(&commit, "commit", "", "The git commit hash of the version of the software to upgrade to")
+	cmd.Use = "propose-upgrade <name> [--upgrade-time <time> | --upgrade-height <height>] [--upgrade-commit <commit-hash>]"
+	cmd.Short = "Propose a software upgrade"
+	cmd.Flags().StringVar(&timeStr, "upgrade-time", "", "The time after which the upgrade must happen in ISO8601/RFC3339 format (omit if using --upgrade-height)")
+	cmd.Flags().Int64Var(&height, "upgrade-height", 0, "The height at which the upgrade must happen (omit if using --upgrade-time)")
+	cmd.Flags().StringVar(&commit, "upgrade-commit", "", "The git commit hash of the version of the software to upgrade to")
+	return cmd
+}
+
+func GetCmdProposeCancelUpgrade(cdc *codec.Codec) *cobra.Command {
+	cmd := proposalcli.GetCmdPropose(cdc, func(cmd *cobra.Command, args []string) (action proposal.ProposalAction, e error) {
+		return consortium.ActionCancelUpgrade{}, nil
+	})
+
+	cmd.Args = cobra.ExactArgs(0)
+	cmd.Use = "propose-cancel-upgrade <name> [--upgrade-time <time> | --upgrade-height <height>] [--upgrade-commit <commit-hash>]"
+	cmd.Short = "Propose that a pending software upgrade be cancelled"
 	return cmd
 }
diff --git a/x/consortium/client/module_client.go b/x/consortium/client/module_client.go
index 98ed23a343..92ccc963eb 100644
--- a/x/consortium/client/module_client.go
+++ b/x/consortium/client/module_client.go
@@ -35,6 +35,7 @@ func (mc ModuleClient) GetTxCmd() *cobra.Command {
 
 	consortiumTxCmd.AddCommand(client.PostCommands(
 		consortiumcmd.GetCmdProposeUpgrade(mc.cdc),
+		consortiumcmd.GetCmdProposeCancelUpgrade(mc.cdc),
 	)...)
 
 	return consortiumTxCmd
diff --git a/x/consortium/codec.go b/x/consortium/codec.go
index 7377d41f81..9111e1ff8d 100644
--- a/x/consortium/codec.go
+++ b/x/consortium/codec.go
@@ -1,11 +1,12 @@
 package consortium
 
 import (
-"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/codec"
 )
 
 // RegisterCodec registers concrete types on the Amino codec
 func RegisterCodec(cdc *codec.Codec) {
 	cdc.RegisterConcrete(ActionScheduleUpgrade{}, "consortium/ActionScheduleUpgrade", nil)
+	cdc.RegisterConcrete(ActionCancelUpgrade{}, "consortium/ActionCancelUpgrade", nil)
 	cdc.RegisterConcrete(ActionChangeValidatorSet{}, "consortium/ActionChangeValidatorSet", nil)
 }
diff --git a/x/proposal/keeper.go b/x/proposal/keeper.go
index 84a655b34a..9029abbb42 100644
--- a/x/proposal/keeper.go
+++ b/x/proposal/keeper.go
@@ -169,6 +169,7 @@ func (keeper Keeper) TryExecute(ctx sdk.Context, proposalId []byte) sdk.Result {
 	if res.Code == sdk.CodeOK {
 		store := ctx.KVStore(keeper.storeKey)
 		store.Delete(proposalId)
+		res.Tags = res.Tags.AppendTag("action", proposal.Action.Type())
 	}
 
 	return res
diff --git a/x/upgrade/client/cli/query.go b/x/upgrade/client/cli/query.go
new file mode 100644
index 0000000000..b8bcc2159a
--- /dev/null
+++ b/x/upgrade/client/cli/query.go
@@ -0,0 +1,36 @@
+package cli
+
+import (
+	"fmt"
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/regen-network/regen-ledger/x/upgrade"
+	"github.com/spf13/cobra"
+)
+
+func GetQueryCmd(cmdName string, storeName string, cdc *codec.Codec) *cobra.Command {
+	return &cobra.Command{
+		Use:   cmdName,
+		Short: "get upgrade plan (if one exists)",
+		Args:  cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc)
+
+			res, err := cliCtx.QueryStore([]byte(upgrade.PlanKey), storeName)
+			if err != nil {
+				return err
+			}
+
+			if len(res) == 0 {
+				return fmt.Errorf("no upgrade scheduled")
+			}
+
+			var plan upgrade.Plan
+			err = cdc.UnmarshalBinaryBare(res, &plan)
+			if err != nil {
+				return err
+			}
+			return cliCtx.PrintOutput(plan)
+		},
+	}
+}
diff --git a/x/upgrade/client/rest/rest.go b/x/upgrade/client/rest/rest.go
new file mode 100644
index 0000000000..9cfdb8fc64
--- /dev/null
+++ b/x/upgrade/client/rest/rest.go
@@ -0,0 +1,39 @@
+package rest
+
+import (
+	"fmt"
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/types/rest"
+	"github.com/gorilla/mux"
+	"github.com/regen-network/regen-ledger/x/upgrade"
+	"net/http"
+)
+
+func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Codec, routeName string, storeName string) {
+	r.HandleFunc(fmt.Sprintf("/%s", routeName), getUpgradePlanHandler(cdc, cliCtx, storeName)).Methods("GET")
+}
+
+func getUpgradePlanHandler(cdc *codec.Codec, cliCtx context.CLIContext, storeName string) func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, request *http.Request) {
+		res, err := cliCtx.QueryStore([]byte(upgrade.PlanKey), storeName)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		if len(res) == 0 {
+			http.NotFound(w, request)
+			return
+		}
+
+		var plan upgrade.Plan
+		err = cdc.UnmarshalBinaryBare(res, &plan)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		rest.PostProcessResponse(w, cdc, plan, cliCtx.Indent)
+	}
+}
diff --git a/x/upgrade/doc.go b/x/upgrade/doc.go
new file mode 100644
index 0000000000..0171620ac1
--- /dev/null
+++ b/x/upgrade/doc.go
@@ -0,0 +1,5 @@
+package upgrade
+
+/*
+Package upgrade
+*/
diff --git a/x/upgrade/keeper.go b/x/upgrade/keeper.go
index cb9494d964..1f82f93d0c 100644
--- a/x/upgrade/keeper.go
+++ b/x/upgrade/keeper.go
@@ -16,7 +16,7 @@ type Keeper struct {
 }
 
 const (
-	planKey = "plan"
+	PlanKey = "plan"
 )
 
 // NewKeeper constructs an upgrade keeper
@@ -45,6 +45,9 @@ func (keeper Keeper) ScheduleUpgrade(ctx sdk.Context, plan Plan) sdk.Error {
 		if !plan.Time.After(ctx.BlockHeader().Time) {
 			return sdk.ErrUnknownRequest("Upgrade cannot be scheduled in the past")
 		}
+		if plan.Height != 0 {
+			return sdk.ErrUnknownRequest("Only one of Time or Height should be specified")
+		}
 	} else {
 		if plan.Height <= ctx.BlockHeight() {
 			return sdk.ErrUnknownRequest("Upgrade cannot be scheduled in the past")
@@ -55,14 +58,14 @@ func (keeper Keeper) ScheduleUpgrade(ctx sdk.Context, plan Plan) sdk.Error {
 		return sdk.ErrUnknownRequest(fmt.Sprintf("Upgrade with name %s has already been completed", plan.Name))
 	}
 	bz := keeper.cdc.MustMarshalBinaryBare(plan)
-	store.Set([]byte(planKey), bz)
+	store.Set([]byte(PlanKey), bz)
 	return nil
 }
 
 // ClearUpgradePlan clears any schedule upgrade
 func (keeper Keeper) ClearUpgradePlan(ctx sdk.Context) {
 	store := ctx.KVStore(keeper.storeKey)
-	store.Delete([]byte(planKey))
+	store.Delete([]byte(PlanKey))
 }
 
 // ValidateBasic does basic validation of an Plan
@@ -78,7 +81,7 @@ func (plan Plan) ValidateBasic() sdk.Error {
 // upgrade or false if there is none
 func (keeper Keeper) GetUpgradePlan(ctx sdk.Context) (plan Plan, havePlan bool) {
 	store := ctx.KVStore(keeper.storeKey)
-	bz := store.Get([]byte(planKey))
+	bz := store.Get([]byte(PlanKey))
 	if bz == nil {
 		return plan, false
 	}
diff --git a/x/upgrade/types.go b/x/upgrade/types.go
index 3b1049531f..54878dd2f1 100644
--- a/x/upgrade/types.go
+++ b/x/upgrade/types.go
@@ -1,6 +1,9 @@
 package upgrade
 
-import "time"
+import (
+	"fmt"
+	"time"
+)
 import sdk "github.com/cosmos/cosmos-sdk/types"
 
 // Plan specifies information about a planned upgrade and when it should occur
@@ -27,3 +30,17 @@ type Plan struct {
 
 // UpgradeHandler specifies the type of function that is called when an upgrade is applied
 type Handler func(ctx sdk.Context, plan Plan)
+
+func (plan Plan) String() string {
+	if !plan.Time.IsZero() {
+		return fmt.Sprintf(`Upgrade Plan
+  Name: %s
+  Time: %s
+  Info: %s`, plan.Name, plan.Time.Format(time.RFC3339), plan.Info)
+	} else {
+		return fmt.Sprintf(`Upgrade Plan
+  Name: %s
+  Height: %d
+  Info: %s`, plan.Name, plan.Height, plan.Info)
+	}
+}

From 7046d81b3a2772fe5b0c32d89f2f05f6a6af7049 Mon Sep 17 00:00:00 2001
From: Aaron Craelius <aaron@regen.network>
Date: Tue, 26 Mar 2019 11:47:45 -0400
Subject: [PATCH 8/9] #13 fixed lint errors

---
 app.go                        |  3 ---
 x/upgrade/client/cli/query.go |  1 +
 x/upgrade/client/rest/rest.go |  1 +
 x/upgrade/keeper.go           |  1 +
 x/upgrade/types.go            | 17 ++++++++---------
 5 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/app.go b/app.go
index 9c9e181cd6..15a6430774 100644
--- a/app.go
+++ b/app.go
@@ -160,9 +160,6 @@ func NewXrnApp(logger log.Logger, db dbm.DB, postgresUrl string) *xrnApp {
 
 	app.upgradeKeeper = upgrade.NewKeeper(app.upgradeStoreKey, cdc)
 	app.upgradeKeeper.SetDoShutdowner(app.shutdownOnUpgrade)
-	app.upgradeKeeper.SetUpgradeHandler("test3", func(ctx sdk.Context, plan upgrade.Plan) {
-		ctx.Logger().Info("In upgrade 3 handler!")
-	})
 
 	app.consortiumKeeper = consortium.NewKeeper(app.consortiumStoreKey, cdc, app.agentKeeper, app.upgradeKeeper)
 
diff --git a/x/upgrade/client/cli/query.go b/x/upgrade/client/cli/query.go
index b8bcc2159a..20e2d26685 100644
--- a/x/upgrade/client/cli/query.go
+++ b/x/upgrade/client/cli/query.go
@@ -8,6 +8,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
+// GetQueryCmd creates a query sub-command for the upgrade module using cmdName as the name of the sub-command.
 func GetQueryCmd(cmdName string, storeName string, cdc *codec.Codec) *cobra.Command {
 	return &cobra.Command{
 		Use:   cmdName,
diff --git a/x/upgrade/client/rest/rest.go b/x/upgrade/client/rest/rest.go
index 9cfdb8fc64..c5d9841d3e 100644
--- a/x/upgrade/client/rest/rest.go
+++ b/x/upgrade/client/rest/rest.go
@@ -10,6 +10,7 @@ import (
 	"net/http"
 )
 
+// RegisterRoutes registers REST routes for the upgrade module under the path specified by routeName.
 func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Codec, routeName string, storeName string) {
 	r.HandleFunc(fmt.Sprintf("/%s", routeName), getUpgradePlanHandler(cdc, cliCtx, storeName)).Methods("GET")
 }
diff --git a/x/upgrade/keeper.go b/x/upgrade/keeper.go
index 1f82f93d0c..fdb61fd8c7 100644
--- a/x/upgrade/keeper.go
+++ b/x/upgrade/keeper.go
@@ -16,6 +16,7 @@ type Keeper struct {
 }
 
 const (
+	// PlanKey specifies the key under which an upgrade plan is stored in the store
 	PlanKey = "plan"
 )
 
diff --git a/x/upgrade/types.go b/x/upgrade/types.go
index 54878dd2f1..fa9b2a45f3 100644
--- a/x/upgrade/types.go
+++ b/x/upgrade/types.go
@@ -28,19 +28,18 @@ type Plan struct {
 	Info string `json:"info,omitempty"`
 }
 
-// UpgradeHandler specifies the type of function that is called when an upgrade is applied
+// Handler specifies the type of function that is called when an upgrade is applied
 type Handler func(ctx sdk.Context, plan Plan)
 
 func (plan Plan) String() string {
+	var whenStr string
 	if !plan.Time.IsZero() {
-		return fmt.Sprintf(`Upgrade Plan
-  Name: %s
-  Time: %s
-  Info: %s`, plan.Name, plan.Time.Format(time.RFC3339), plan.Info)
+		whenStr = fmt.Sprintf("Time: %s", plan.Time.Format(time.RFC3339))
 	} else {
-		return fmt.Sprintf(`Upgrade Plan
-  Name: %s
-  Height: %d
-  Info: %s`, plan.Name, plan.Height, plan.Info)
+		whenStr = fmt.Sprintf("Height: %d", plan.Height)
 	}
+	return fmt.Sprintf(`Upgrade Plan
+  Name: %s
+  %s
+  Info: %s`, plan.Name, whenStr, plan.Info)
 }

From 6d0ac5497c4b82fcdc4e14c7a67d976c5f484bdc Mon Sep 17 00:00:00 2001
From: Aaron Craelius <aaron@regen.network>
Date: Tue, 26 Mar 2019 12:39:49 -0400
Subject: [PATCH 9/9] #13 improved docs, 100% test coverage on keeper

---
 x/upgrade/doc.go         | 50 +++++++++++++++++++++++++++++++++++++++-
 x/upgrade/keeper.go      |  2 +-
 x/upgrade/keeper_test.go |  6 +++++
 3 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/x/upgrade/doc.go b/x/upgrade/doc.go
index 0171620ac1..2439d149cd 100644
--- a/x/upgrade/doc.go
+++ b/x/upgrade/doc.go
@@ -1,5 +1,53 @@
 package upgrade
 
 /*
-Package upgrade
+Package upgrade provides a Cosmos SDK module that can be used for smoothly upgrading a live Cosmos blockchain to a
+new software version. It accomplishes this by providing a BeginBlocker hook that prevents the blockchain state
+machine from proceeding once a pre-defined upgrade block height or time has been reached. The module does not prescribe
+anything regarding how the decision to perform an upgrade is made by the chain's governance, only the mechanism
+via which the software upgrade will be coordinated precisely and safely. Without software support for upgrades,
+upgrading a live chain is risky because all of the validators need to pause their state machines at exactly the same
+block height. Otherwise, there can be state inconsistencies which are hard to deal with.
+
+Integrating With An App
+
+Setup the upgrade.Keeper as usual:
+	app.upgradeKeeper = upgrade.NewKeeper(app.upgradeStoreKey, cdc)
+
+The app must define a BeginBlocker that calls the upgrade keepr's BeginBlocker method:
+    func (app *myApp) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock) abci.ResponseBeginBlock {
+    	app.upgradeKeeper.BeginBlocker(ctx, req)
+    	return abci.ResponseBeginBlock{}
+    }
+
+The app must then integrate the upgrade keeper with its governance module as appropriate. Once governance has approved
+an upgrade, the keeper's ScheduleUpgrade method must be called with the upgrade Plan that has been approved. Governance
+should also enable a mechanism to cancel a pending upgrade that will call the keeper's ClearUpgradePlan method.
+
+Performing Upgrades
+
+Upgrades can be scheduled at either a predefined block height or time. Once this block height or time is reached, the
+existing software will cease to function and a new version with code that handles the upgrade must be deployed. All
+upgrades are coordinated by a unique upgrade name that cannot be reused on the same blockchain. In order for the upgrade
+module to know that the upgrade has been safely applied, a handler with the name of the upgrade must be installed.
+Here is an example handler for the upgrade named "my-fancy-upgrade":
+	app.upgradeKeeper.SetUpgradeHandler("my-fancy-upgrade", func(ctx sdk.Context, plan upgrade.Plan) {
+		// Perform any migrations of the state store needed for this upgrade
+	})
+
+This upgrade handler performs the dual function of alerting the upgrade module that this named upgrade has been applied
+and thus the state machine can safely proceed, as well as providing the opportunity for the upgraded software to
+perform any migrations of data in the state store before any new transactions are processed.
+
+Default and Custom Shutdown Behavior
+
+Before "crashing" the ABCI state machine in the BeginBlocker when an upgrade is required, the upgrade module
+will log an error that looks like:
+	UPGRADE "<Name>" NEEDED at height <NNNN>: <Info>
+where Name are Info are the values of the respective fields on the upgrade Plan.
+
+The default behavior for "crashing" the state machine is then to panic with an error which will stop the state machine
+but usually not exit the process. This behavior can be overriden using the keeper's SetDoShutdowner method. A custom
+shutdown method could perform some other steps such as alerting some other running process to try to install the
+new software version automatically, as well as crashing the program with os.Exit() instead of panic.
 */
diff --git a/x/upgrade/keeper.go b/x/upgrade/keeper.go
index fdb61fd8c7..f03ca16cd6 100644
--- a/x/upgrade/keeper.go
+++ b/x/upgrade/keeper.go
@@ -125,7 +125,7 @@ func (keeper *Keeper) BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock)
 			store.Set(upgradeDoneKey(plan.Name), []byte("1"))
 		} else {
 			// We don't have an upgrade handler for this upgrade name, meaning this software is out of date so shutdown
-			ctx.Logger().Error(fmt.Sprintf("UPGRADE \"%s\" NEEDED needed at height %d: %s", plan.Name, blockHeight, plan.Info))
+			ctx.Logger().Error(fmt.Sprintf("UPGRADE \"%s\" NEEDED at height %d: %s", plan.Name, blockHeight, plan.Info))
 			doShutdowner := keeper.doShutdowner
 			if doShutdowner != nil {
 				doShutdowner(ctx, plan)
diff --git a/x/upgrade/keeper_test.go b/x/upgrade/keeper_test.go
index 515604fc55..50333d90cc 100644
--- a/x/upgrade/keeper_test.go
+++ b/x/upgrade/keeper_test.go
@@ -49,6 +49,12 @@ func (s *TestSuite) TestRequireFutureBlock() {
 	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
 }
 
+func (s *TestSuite) TestCantSetBothTimeAndHeight() {
+	err := s.keeper.ScheduleUpgrade(s.ctx, Plan{Name: "test", Time: time.Now(), Height: s.ctx.BlockHeight() + 1})
+	s.Require().NotNil(err)
+	s.Require().Equal(sdk.CodeUnknownRequest, err.Code())
+}
+
 func (s *TestSuite) TestDoTimeUpgrade() {
 	s.T().Log("Verify can schedule an upgrade")
 	err := s.keeper.ScheduleUpgrade(s.ctx, Plan{Name: "test", Time: time.Now()})