Merge branch 'develop' into joon/paramstore-refactor-base

2018-10-10 21:20:59 +09:00 · 2018-10-10 21:20:59 +09:00 · 03975407ba
parent 9fc7e80d48 e251088672
commit 03975407ba
56 changed files with 1302 additions and 813 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@ -136,6 +136,24 @@ jobs:
            export PATH="$GOBIN:$PATH"
            make test_sim_gaia_fast

+  test_sim_gaia_multi_seed:
+    <<: *defaults
+    parallelism: 1
+    steps:
+      - attach_workspace:
+          at: /tmp/workspace
+      - checkout
+      - run:
+          name: dependencies
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make get_vendor_deps
+      - run:
+          name: Test multi-seed Gaia simulation
+          command: |
+            export PATH="$GOBIN:$PATH"
+            make test_sim_gaia_multi_seed
+
  test_cover:
    <<: *defaults
    parallelism: 4
@ -240,6 +258,9 @@ workflows:
      - test_sim_gaia_fast:
          requires:
            - setup_dependencies
+      - test_sim_gaia_multi_seed:
+          requires:
+            - setup_dependencies
      - test_cover:
          requires:
            - setup_dependencies
--- a/Gopkg.lock
+++ b/Gopkg.lock
@ -164,13 +164,12 @@
  version = "v1.2.0"

 [[projects]]
-  digest = "1:c0d19ab64b32ce9fe5cf4ddceba78d5bc9807f0016db6b1183599da3dcc24d10"
+  digest = "1:ea40c24cdbacd054a6ae9de03e62c5f252479b96c716375aace5c120d68647c8"
  name = "github.com/hashicorp/hcl"
  packages = [
    ".",
    "hcl/ast",
    "hcl/parser",
-    "hcl/printer",
    "hcl/scanner",
    "hcl/strconv",
    "hcl/token",
@ -447,7 +446,7 @@
  version = "v0.11.0"

 [[projects]]
-  digest = "1:f4fcc1a4dbe079b200556ca26c1ff1dacf23712125b9c265d8f02c0dbc318f39"
+  digest = "1:a69eebd15b05045ffdb10a984e001fadc5666f74383de3d2a9ee5862ee99cfdc"
  name = "github.com/tendermint/tendermint"
  packages = [
    "abci/client",
@ -478,6 +477,7 @@
    "libs/clist",
    "libs/common",
    "libs/db",
+    "libs/errors",
    "libs/events",
    "libs/flowrate",
    "libs/log",
@ -512,8 +512,8 @@
    "version",
  ]
  pruneopts = "UT"
-  revision = "d419fffe18531317c28c29a292ad7d253f6cafdf"
-  version = "v0.24.0"
+  revision = "0c9c3292c918617624f6f3fbcd95eceade18bcd5"
+  version = "v0.25.0"

 [[projects]]
  digest = "1:7886f86064faff6f8d08a3eb0e8c773648ff5a2e27730831e2bfbf07467f6666"
--- a/Gopkg.toml
+++ b/Gopkg.toml
@ -57,7 +57,7 @@

 [[override]]
  name = "github.com/tendermint/tendermint"
-  version = "=0.24.0"
+  version = "=0.25.0"

 [[constraint]]
  name = "github.com/bartekn/go-bip39"
--- a/8
+++ b/8
@ -162,9 +162,9 @@ test_sim_gaia_fast:
 	@echo "Running quick Gaia simulation. This may take several minutes..."
 	@go test ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationEnabled=true -SimulationNumBlocks=400 -SimulationBlockSize=200 -SimulationCommit=true -v -timeout 24h

-test_sim_gaia_full:
-	@echo "Running full multi-seed Gaia simulation. This may take awhile!"
-	@sh scripts/multisim.sh
+test_sim_gaia_multi_seed:
+	@echo "Running multi-seed Gaia simulation. This may take awhile!"
+	@bash scripts/multisim.sh 10

 SIM_NUM_BLOCKS ?= 210
 SIM_BLOCK_SIZE ?= 200
@ -241,4 +241,4 @@ localnet-stop:
 check_tools check_dev_tools get_tools get_dev_tools get_vendor_deps draw_deps test test_cli test_unit \
 test_cover test_lint benchmark devdoc_init devdoc devdoc_save devdoc_update \
 build-linux build-docker-gaiadnode localnet-start localnet-stop \
-format check-ledger test_sim_gaia_nondeterminism test_sim_modules test_sim_gaia_fast test_sim_gaia_slow update_tools update_dev_tools
+format check-ledger test_sim_gaia_nondeterminism test_sim_modules test_sim_gaia_fast test_sim_gaia_multi_seed update_tools update_dev_tools
--- a/PENDING.md
+++ b/PENDING.md
@ -28,6 +28,7 @@ BREAKING CHANGES
    * [x/stake, x/slashing] [#1305](https://github.com/cosmos/cosmos-sdk/issues/1305) - Rename "revoked" to "jailed"
    * [x/stake] [#1676] Revoked and jailed validators put into the unbonding state
    * [x/stake] [#1877] Redelegations/unbonding-delegation from unbonding validator have reduced time
+    * [x/slashing] \#1789 Slashing changes for Tendermint validator set offset (NextValSet)
    * [x/stake] [\#2040](https://github.com/cosmos/cosmos-sdk/issues/2040) Validator
    operator type has now changed to `sdk.ValAddress`
    * [x/stake] [\#2221](https://github.com/cosmos/cosmos-sdk/issues/2221) New
@ -41,6 +42,8 @@ BREAKING CHANGES
    * [x/gov] [#2195] Governance uses BFT Time
    * [x/gov] \#2256 Removed slashing for governance non-voting validators
    * [simulation] \#2162 Added back correct supply invariants
+    * [x/slashing] \#2430 Simulate more slashes, check if validator is jailed before jailing
+    * [x/stake] \#2393 Removed `CompleteUnbonding` and `CompleteRedelegation` Msg types, and instead added unbonding/redelegation queues to endblocker
    
 * SDK
    * [core] \#2219 Update to Tendermint 0.24.0
@ -68,6 +71,16 @@ BREAKING CHANGES
    * [x/stake] \#2394 Split up UpdateValidator into distinct state transitions applied only in EndBlock

 * Tendermint
+  * Update tendermint version from v0.23.0 to v0.25.0, notable changes
+    * Mempool now won't build too large blocks, or too computationally expensive blocks
+    * Maximum tx sizes and gas are now removed, and are implicitly the blocks maximums
+    * ABCI validators no longer send the pubkey. The pubkey is only sent in validator updates
+    * Validator set changes are now delayed by one block 
+    * Block header now includes the next validator sets hash
+    * BFT time is implemented
+    * Secp256k1 signature format has changed
+    * There is now a threshold multisig format
+    * See the [tendermint changelog](https://github.com/tendermint/tendermint/blob/master/CHANGELOG.md) for other changes.

 FEATURES

@ -77,7 +90,7 @@ FEATURES
  * [gaia-lite] [\#966](https://github.com/cosmos/cosmos-sdk/issues/966) Add support for `generate_only=true` query argument to generate offline unsigned transactions
  * [gaia-lite] [\#1953](https://github.com/cosmos/cosmos-sdk/issues/1953) Add /sign endpoint to sign transactions generated with `generate_only=true`.
  * [gaia-lite] [\#1954](https://github.com/cosmos/cosmos-sdk/issues/1954) Add /broadcast endpoint to broadcast transactions signed by the /sign endpoint.
-  * [gaia-lite] [\#2113](https://github.com/cosmos/cosmos-sdk/issues/2113) Rename `/accounts/{address}/send` to `/bank/accounts/{address}/transfers`
+  * [gaia-lite] [\#2113](https://github.com/cosmos/cosmos-sdk/issues/2113) Rename `/accounts/{address}/send` to `/bank/accounts/{address}/transfers`, rename `/accounts/{address}` to `/auth/accounts/{address}`

 * Gaia CLI  (`gaiacli`)
  * [cli] Cmds to query staking pool and params
@ -134,6 +147,7 @@ IMPROVEMENTS
    * [x/stake] Improve speed of GetValidator, which was shown to be a performance bottleneck. [#2046](https://github.com/tendermint/tendermint/pull/2200)
    * [x/stake] \#2435 Improve memory efficiency of getting the various store keys
    * [genesis] \#2229 Ensure that there are no duplicate accounts or validators in the genesis state.
+    * [genesis] \#2450 Validate staking genesis parameters.
    * Add SDK validation to `config.toml` (namely disabling `create_empty_blocks`) \#1571
    * \#1941(https://github.com/cosmos/cosmos-sdk/issues/1941) Version is now inferred via `git describe --tags`.
    * [x/distribution] \#1671 add distribution types and tests
--- a/client/keys/add.go
+++ b/client/keys/add.go
@ -8,7 +8,6 @@ import (

 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/gorilla/mux"
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"

@ -61,7 +60,7 @@ func runAddCmd(cmd *cobra.Command, args []string) error {
 		name = "inmemorykey"
 	} else {
 		if len(args) != 1 || len(args[0]) == 0 {
-			return errors.New("you must provide a name for the key")
+			return errMissingName()
 		}
 		name = args[0]
 		kb, err = GetKeyBase()
@ -144,11 +143,16 @@ func printCreate(info keys.Info, seed string) {
 		if !viper.GetBool(flagNoBackup) {
 			out.Seed = seed
 		}
-		json, err := MarshalJSON(out)
+		var jsonString []byte
+		if viper.GetBool(client.FlagIndentResponse) {
+			jsonString, err = cdc.MarshalJSONIndent(out, "", "  ")
+		} else {
+			jsonString, err = cdc.MarshalJSON(out)
+		}
 		if err != nil {
 			panic(err) // really shouldn't happen...
 		}
-		fmt.Println(string(json))
+		fmt.Println(string(jsonString))
 	default:
 		panic(fmt.Sprintf("I can't speak: %s", output))
 	}
@ -165,75 +169,77 @@ type NewKeyBody struct {
 }

 // add new key REST handler
-func AddNewKeyRequestHandler(w http.ResponseWriter, r *http.Request) {
-	var kb keys.Keybase
-	var m NewKeyBody
+func AddNewKeyRequestHandler(indent bool) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var kb keys.Keybase
+		var m NewKeyBody

-	kb, err := GetKeyBase()
-	if err != nil {
-		w.WriteHeader(500)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	body, err := ioutil.ReadAll(r.Body)
-	err = json.Unmarshal(body, &m)
-
-	if err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		w.Write([]byte(err.Error()))
-		return
-	}
-	if m.Name == "" {
-		w.WriteHeader(http.StatusBadRequest)
-		w.Write([]byte("You have to specify a name for the locally stored account."))
-		return
-	}
-	if m.Password == "" {
-		w.WriteHeader(http.StatusBadRequest)
-		w.Write([]byte("You have to specify a password for the locally stored account."))
-		return
-	}
-
-	// check if already exists
-	infos, err := kb.List()
-	for _, i := range infos {
-		if i.GetName() == m.Name {
-			w.WriteHeader(http.StatusConflict)
-			w.Write([]byte(fmt.Sprintf("Account with name %s already exists.", m.Name)))
+		kb, err := GetKeyBase()
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
 			return
 		}
-	}

-	// create account
-	seed := m.Seed
-	if seed == "" {
-		seed = getSeed(keys.Secp256k1)
-	}
-	info, err := kb.CreateKey(m.Name, seed, m.Password)
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		w.Write([]byte(err.Error()))
-		return
-	}
+		body, err := ioutil.ReadAll(r.Body)
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		err = json.Unmarshal(body, &m)
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		if m.Name == "" {
+			w.WriteHeader(http.StatusBadRequest)
+			err = errMissingName()
+			w.Write([]byte(err.Error()))
+			return
+		}
+		if m.Password == "" {
+			w.WriteHeader(http.StatusBadRequest)
+			err = errMissingPassword()
+			w.Write([]byte(err.Error()))
+			return
+		}

-	keyOutput, err := Bech32KeyOutput(info)
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		w.Write([]byte(err.Error()))
-		return
+		// check if already exists
+		infos, err := kb.List()
+		for _, info := range infos {
+			if info.GetName() == m.Name {
+				w.WriteHeader(http.StatusConflict)
+				err = errKeyNameConflict(m.Name)
+				w.Write([]byte(err.Error()))
+				return
+			}
+		}
+
+		// create account
+		seed := m.Seed
+		if seed == "" {
+			seed = getSeed(keys.Secp256k1)
+		}
+		info, err := kb.CreateKey(m.Name, seed, m.Password)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		keyOutput, err := Bech32KeyOutput(info)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		keyOutput.Seed = seed
+
+		PostProcessResponse(w, cdc, keyOutput, indent)
 	}
-
-	keyOutput.Seed = seed
-
-	bz, err := json.Marshal(keyOutput)
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	w.Write(bz)
 }

 // function to just a new seed to display in the UI before actually persisting it in the keybase
@ -258,3 +264,82 @@ func SeedRequestHandler(w http.ResponseWriter, r *http.Request) {
 	seed := getSeed(algo)
 	w.Write([]byte(seed))
 }
+
+// RecoverKeyBody is recover key request REST body
+type RecoverKeyBody struct {
+	Password string `json:"password"`
+	Seed     string `json:"seed"`
+}
+
+// RecoverRequestHandler performs key recover request
+func RecoverRequestHandler(indent bool) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		name := vars["name"]
+		var m RecoverKeyBody
+		body, err := ioutil.ReadAll(r.Body)
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		err = cdc.UnmarshalJSON(body, &m)
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		if name == "" {
+			w.WriteHeader(http.StatusBadRequest)
+			err = errMissingName()
+			w.Write([]byte(err.Error()))
+			return
+		}
+		if m.Password == "" {
+			w.WriteHeader(http.StatusBadRequest)
+			err = errMissingPassword()
+			w.Write([]byte(err.Error()))
+			return
+		}
+		if m.Seed == "" {
+			w.WriteHeader(http.StatusBadRequest)
+			err = errMissingSeed()
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		kb, err := GetKeyBase()
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		// check if already exists
+		infos, err := kb.List()
+		for _, info := range infos {
+			if info.GetName() == name {
+				w.WriteHeader(http.StatusConflict)
+				err = errKeyNameConflict(name)
+				w.Write([]byte(err.Error()))
+				return
+			}
+		}
+
+		info, err := kb.CreateKey(name, m.Seed, m.Password)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		keyOutput, err := Bech32KeyOutput(info)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		PostProcessResponse(w, cdc, keyOutput, indent)
+	}
+}
--- a/client/keys/delete.go
+++ b/client/keys/delete.go
@ -68,14 +68,14 @@ func DeleteKeyRequestHandler(w http.ResponseWriter, r *http.Request) {
 	decoder := json.NewDecoder(r.Body)
 	err := decoder.Decode(&m)
 	if err != nil {
-		w.WriteHeader(400)
+		w.WriteHeader(http.StatusBadRequest)
 		w.Write([]byte(err.Error()))
 		return
 	}

 	kb, err = GetKeyBase()
 	if err != nil {
-		w.WriteHeader(500)
+		w.WriteHeader(http.StatusInternalServerError)
 		w.Write([]byte(err.Error()))
 		return
 	}
@ -83,10 +83,10 @@ func DeleteKeyRequestHandler(w http.ResponseWriter, r *http.Request) {
 	// TODO handle error if key is not available or pass is wrong
 	err = kb.Delete(name, m.Password)
 	if err != nil {
-		w.WriteHeader(500)
+		w.WriteHeader(http.StatusInternalServerError)
 		w.Write([]byte(err.Error()))
 		return
 	}

-	w.WriteHeader(200)
+	w.WriteHeader(http.StatusOK)
 }
--- a/client/keys/errors.go
+++ b/client/keys/errors.go
@ -0,0 +1,19 @@
+package keys
+
+import "fmt"
+
+func errKeyNameConflict(name string) error {
+	return fmt.Errorf("acount with name %s already exists", name)
+}
+
+func errMissingName() error {
+	return fmt.Errorf("you have to specify a name for the locally stored account")
+}
+
+func errMissingPassword() error {
+	return fmt.Errorf("you have to specify a password for the locally stored account")
+}
+
+func errMissingSeed() error {
+	return fmt.Errorf("you have to specify seed for key recover")
+}
--- a/client/keys/list.go
+++ b/client/keys/list.go
@ -1,7 +1,6 @@
 package keys

 import (
-	"encoding/json"
 	"net/http"

 	"github.com/spf13/cobra"
@ -35,35 +34,31 @@ func runListCmd(cmd *cobra.Command, args []string) error {
 // REST

 // query key list REST handler
-func QueryKeysRequestHandler(w http.ResponseWriter, r *http.Request) {
-	kb, err := GetKeyBase()
-	if err != nil {
-		w.WriteHeader(500)
-		w.Write([]byte(err.Error()))
-		return
+func QueryKeysRequestHandler(indent bool) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		kb, err := GetKeyBase()
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		infos, err := kb.List()
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		// an empty list will be JSONized as null, but we want to keep the empty list
+		if len(infos) == 0 {
+			PostProcessResponse(w, cdc, "[]", indent)
+			return
+		}
+		keysOutput, err := Bech32KeysOutput(infos)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		PostProcessResponse(w, cdc, keysOutput, indent)
 	}
-	infos, err := kb.List()
-	if err != nil {
-		w.WriteHeader(500)
-		w.Write([]byte(err.Error()))
-		return
-	}
-	// an empty list will be JSONized as null, but we want to keep the empty list
-	if len(infos) == 0 {
-		w.Write([]byte("[]"))
-		return
-	}
-	keysOutput, err := Bech32KeysOutput(infos)
-	if err != nil {
-		w.WriteHeader(500)
-		w.Write([]byte(err.Error()))
-		return
-	}
-	output, err := json.MarshalIndent(keysOutput, "", "  ")
-	if err != nil {
-		w.WriteHeader(500)
-		w.Write([]byte(err.Error()))
-		return
-	}
-	w.Write(output)
 }
--- a/client/keys/root.go
+++ b/client/keys/root.go
@ -30,11 +30,12 @@ func Commands() *cobra.Command {
 }

 // resgister REST routes
-func RegisterRoutes(r *mux.Router) {
-	r.HandleFunc("/keys", QueryKeysRequestHandler).Methods("GET")
-	r.HandleFunc("/keys", AddNewKeyRequestHandler).Methods("POST")
+func RegisterRoutes(r *mux.Router, indent bool) {
+	r.HandleFunc("/keys", QueryKeysRequestHandler(indent)).Methods("GET")
+	r.HandleFunc("/keys", AddNewKeyRequestHandler(indent)).Methods("POST")
 	r.HandleFunc("/keys/seed", SeedRequestHandler).Methods("GET")
-	r.HandleFunc("/keys/{name}", GetKeyRequestHandler).Methods("GET")
+	r.HandleFunc("/keys/{name}/recover", RecoverRequestHandler(indent)).Methods("POST")
+	r.HandleFunc("/keys/{name}", GetKeyRequestHandler(indent)).Methods("GET")
 	r.HandleFunc("/keys/{name}", UpdateKeyRequestHandler).Methods("PUT")
 	r.HandleFunc("/keys/{name}", DeleteKeyRequestHandler).Methods("DELETE")
 }
--- a/client/keys/show.go
+++ b/client/keys/show.go
@ -1,7 +1,6 @@
 package keys

 import (
-	"encoding/json"
 	"fmt"
 	"net/http"

@ -91,44 +90,39 @@ func getBechKeyOut(bechPrefix string) (bechKeyOutFn, error) {
 // REST

 // get key REST handler
-func GetKeyRequestHandler(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	name := vars["name"]
-	bechPrefix := r.URL.Query().Get(FlagBechPrefix)
+func GetKeyRequestHandler(indent bool) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		name := vars["name"]
+		bechPrefix := r.URL.Query().Get(FlagBechPrefix)

-	if bechPrefix == "" {
-		bechPrefix = "acc"
+		if bechPrefix == "" {
+			bechPrefix = "acc"
+		}
+
+		bechKeyOut, err := getBechKeyOut(bechPrefix)
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		info, err := GetKeyInfo(name)
+		// TODO: check for the error if key actually does not exist, instead of
+		// assuming this as the reason
+		if err != nil {
+			w.WriteHeader(http.StatusNotFound)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		keyOutput, err := bechKeyOut(info)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		PostProcessResponse(w, cdc, keyOutput, indent)
 	}
-
-	bechKeyOut, err := getBechKeyOut(bechPrefix)
-	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	info, err := GetKeyInfo(name)
-	// TODO: check for the error if key actually does not exist, instead of
-	// assuming this as the reason
-	if err != nil {
-		w.WriteHeader(404)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	keyOutput, err := bechKeyOut(info)
-	if err != nil {
-		w.WriteHeader(500)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	output, err := json.MarshalIndent(keyOutput, "", "  ")
-	if err != nil {
-		w.WriteHeader(500)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	w.Write(output)
 }
--- a/client/keys/update.go
+++ b/client/keys/update.go
@ -69,14 +69,14 @@ func UpdateKeyRequestHandler(w http.ResponseWriter, r *http.Request) {
 	decoder := json.NewDecoder(r.Body)
 	err := decoder.Decode(&m)
 	if err != nil {
-		w.WriteHeader(400)
+		w.WriteHeader(http.StatusBadRequest)
 		w.Write([]byte(err.Error()))
 		return
 	}

 	kb, err = GetKeyBase()
 	if err != nil {
-		w.WriteHeader(500)
+		w.WriteHeader(http.StatusInternalServerError)
 		w.Write([]byte(err.Error()))
 		return
 	}
@ -86,10 +86,10 @@ func UpdateKeyRequestHandler(w http.ResponseWriter, r *http.Request) {
 	// TODO check if account exists and if password is correct
 	err = kb.Update(name, m.OldPassword, getNewpass)
 	if err != nil {
-		w.WriteHeader(401)
+		w.WriteHeader(http.StatusUnauthorized)
 		w.Write([]byte(err.Error()))
 		return
 	}

-	w.WriteHeader(200)
+	w.WriteHeader(http.StatusOK)
 }
--- a/client/keys/utils.go
+++ b/client/keys/utils.go
@ -12,7 +12,9 @@ import (

 	"github.com/cosmos/cosmos-sdk/client"

+	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"net/http"
 )

 // KeyDBName is the directory under root where we store the keys
@ -231,3 +233,26 @@ func printPubKey(info keys.Info, bechKeyOut bechKeyOutFn) {

 	fmt.Println(ko.PubKey)
 }
+
+// PostProcessResponse performs post process for rest response
+func PostProcessResponse(w http.ResponseWriter, cdc *codec.Codec, response interface{}, indent bool) {
+	var output []byte
+	switch response.(type) {
+	default:
+		var err error
+		if indent {
+			output, err = cdc.MarshalJSONIndent(response, "", "  ")
+		} else {
+			output, err = cdc.MarshalJSON(response)
+		}
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+	case []byte:
+		output = response.([]byte)
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(output)
+}
--- a/client/lcd/lcd_test.go
+++ b/client/lcd/lcd_test.go
@ -54,9 +54,13 @@ func TestKeys(t *testing.T) {
 	match := reg.MatchString(seed)
 	require.True(t, match, "Returned seed has wrong format", seed)

+	// recover key
+	recoverName := "test_recovername"
+	recoverPassword := "1234567890"
+	doRecoverKey(t, port, recoverName, recoverPassword, seed)
+
 	newName := "test_newname"
 	newPassword := "0987654321"
-
 	// add key
 	jsonStr := []byte(fmt.Sprintf(`{"name":"%s", "password":"%s", "seed":"%s"}`, newName, newPassword, seed))
 	res, body = Request(t, port, "POST", "/keys", jsonStr)
@ -78,7 +82,7 @@ func TestKeys(t *testing.T) {
 	// existing keys
 	res, body = Request(t, port, "GET", "/keys", nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
-	var m [2]keys.KeyOutput
+	var m [3]keys.KeyOutput
 	err = cdc.UnmarshalJSON([]byte(body), &m)
 	require.Nil(t, err)

@ -243,7 +247,7 @@ func TestCoinSend(t *testing.T) {
 	someFakeAddr := sdk.AccAddress(bz)

 	// query empty
-	res, body := Request(t, port, "GET", fmt.Sprintf("/accounts/%s", someFakeAddr), nil)
+	res, body := Request(t, port, "GET", fmt.Sprintf("/auth/accounts/%s", someFakeAddr), nil)
 	require.Equal(t, http.StatusNoContent, res.StatusCode, body)

 	acc := getAccount(t, port, addr)
@ -518,9 +522,12 @@ func TestBonding(t *testing.T) {
 	name, password, denom := "test", "1234567890", "steak"
 	addr, seed := CreateAddr(t, name, password, GetKeyBase(t))

-	cleanup, _, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 2, []sdk.AccAddress{addr})
 	defer cleanup()

+	require.Equal(t, 2, len(valPubKeys))
+	require.Equal(t, 2, len(operAddrs))
+
 	amt := sdk.NewDec(60)
 	validator := getValidator(t, port, operAddrs[0])

@ -802,7 +809,7 @@ func TestProposalsQuery(t *testing.T) {
 //_____________________________________________________________________________
 // get the account to get the sequence
 func getAccount(t *testing.T, port string, addr sdk.AccAddress) auth.Account {
-	res, body := Request(t, port, "GET", fmt.Sprintf("/accounts/%s", addr), nil)
+	res, body := Request(t, port, "GET", fmt.Sprintf("/auth/accounts/%s", addr), nil)
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
 	var acc auth.Account
 	err := cdc.UnmarshalJSON([]byte(body), &acc)
@ -856,6 +863,20 @@ func doSendWithGas(t *testing.T, port, seed, name, password string, addr sdk.Acc
 	return
 }

+func doRecoverKey(t *testing.T, port, recoverName, recoverPassword, seed string) {
+	jsonStr := []byte(fmt.Sprintf(`{"password":"%s", "seed":"%s"}`, recoverPassword, seed))
+	res, body := Request(t, port, "POST", fmt.Sprintf("/keys/%s/recover", recoverName), jsonStr)
+
+	require.Equal(t, http.StatusOK, res.StatusCode, body)
+	var resp keys.KeyOutput
+	err := codec.Cdc.UnmarshalJSON([]byte(body), &resp)
+	require.Nil(t, err, body)
+
+	addr1Bech32 := resp.Address
+	_, err = sdk.AccAddressFromBech32(addr1Bech32)
+	require.NoError(t, err, "Failed to return a correct bech32 address")
+}
+
 func doSend(t *testing.T, port, seed, name, password string, addr sdk.AccAddress) (receiveAddr sdk.AccAddress, resultTx ctypes.ResultBroadcastTxCommit) {
 	res, body, receiveAddr := doSendWithGas(t, port, seed, name, password, addr, "", 0, "")
 	require.Equal(t, http.StatusOK, res.StatusCode, body)
--- a/client/lcd/root.go
+++ b/client/lcd/root.go
@ -145,7 +145,7 @@ func createHandler(cdc *codec.Codec) *mux.Router {
 	r.HandleFunc("/version", CLIVersionRequestHandler).Methods("GET")
 	r.HandleFunc("/node_version", NodeVersionRequestHandler(cliCtx)).Methods("GET")

-	keys.RegisterRoutes(r)
+	keys.RegisterRoutes(r, cliCtx.Indent)
 	rpc.RegisterRoutes(cliCtx, r)
 	tx.RegisterRoutes(cliCtx, r, cdc)
 	auth.RegisterRoutes(cliCtx, r, cdc, "acc")
--- a/client/lcd/swagger-ui/swagger.yaml
+++ b/client/lcd/swagger-ui/swagger.yaml
@ -346,6 +346,184 @@ paths:
            $ref: "#/definitions/BroadcastTxCommitResult"
        400:
          description: The Tx was malformated
+  /keys:
+    get:
+      summary: List of accounts stored locally
+      tags:
+      - ICS1
+      produces:
+      - application/json
+      responses:
+        200:
+          description: Array of accounts
+          schema:
+            type: array
+            items:
+              $ref: '#/definitions/Account'
+    post:
+      summary: Create a new account locally
+      tags:
+      - ICS1
+      consumes:
+      - application/json
+      produces:
+      - application/json
+      parameters:
+      - in: body
+        name: account
+        description: The account to create
+        schema:
+          type: object
+          required:
+          - name
+          - password
+          - seed
+          properties:
+            name:
+              type: string
+            password:
+              type: string
+            seed:
+              type: string
+      responses:
+        200:
+          description: Returns account information of the created key
+          schema:
+            $ref: "#/definitions/Account"
+  /keys/seed:
+    get:
+      summary: Create a new seed to create a new account with
+      tags:
+      - ICS1
+      responses:
+        200:
+          description: 16 word Seed
+          schema:
+            type: string
+  /keys/{name}/recover:
+    post:
+      summary: Recover a account from a seed
+      tags:
+      - ICS1
+      consumes:
+      - application/json
+      produces:
+      - application/json
+      parameters:
+      - in: path
+        name: name
+        description: Account name
+        required: true
+        type: string
+      - in: body
+        name: pwdAndSeed
+        description: Provide password and seed to recover a key
+        schema:
+          type: object
+          required:
+          - password
+          - seed
+          properties:
+            password:
+              type: string
+            seed:
+              type: string
+      responses:
+        200:
+          description: Returns account information of the recovered key
+          schema:
+            $ref: "#/definitions/Account"
+  /keys/{name}:
+    parameters:
+    - in: path
+      name: name
+      description: Account name
+      required: true
+      type: string
+    get:
+      summary: Get a certain locally stored account
+      tags:
+      - ICS1
+      produces:
+      - application/json
+      responses:
+        200:
+          description: Locally stored account
+          schema:
+            $ref: "#/definitions/Account"
+        404:
+          description: Account is not available
+    put:
+      summary: Update the password for this account in the KMS
+      tags:
+      - ICS1
+      consumes:
+      - application/json
+      parameters:
+      - in: body
+        name: account
+        description: The new and old password
+        schema:
+          type: object
+          required:
+          - new_password
+          - old_password
+          properties:
+            new_password:
+              type: string
+            old_password:
+              type: string
+      responses:
+        200:
+          description: Updated password
+        401:
+          description: Password is wrong
+        404:
+          description: Account is not available
+    delete:
+      summary: Remove an account
+      tags:
+      - ICS1
+      consumes:
+      - application/json
+      parameters:
+      - in: body
+        name: account
+        description: The password of the account to remove from the KMS
+        schema:
+          type: object
+          required:
+          - password
+          properties:
+            password:
+              type: string
+      responses:
+        200:
+          description: Removed account
+        401:
+          description: Password is wrong
+        404:
+          description: Account is not available
+  /auth/accounts/{address}:
+    get:
+      summary: Get the account information on blockchain
+      tags:
+      - ICS1
+      produces:
+      - application/json
+      parameters:
+      - in: path
+        name: address
+        description: Account address
+        required: true
+        type: string
+      responses:
+        200:
+          description: Account information on the blockchain
+          schema:
+            $ref: "#/definitions/AccountQueryResponse"
+        404:
+          description: Account is not available

 definitions:
  CheckTxResult:
@ -561,7 +739,35 @@ definitions:
      address:
        $ref: "#/definitions/Address"
      pub_key:
-        $ref: "#/definitions/PubKey"
+        type: string
+        example: "cosmospub1addwnpepqfgv3pakxazq2fgs8tmmhmzsrs94fptl7kyztyxprjpf0mkus3h7cxqe70s"
+      type:
+        type: string
+        example: local
+      seed:
+        type: string
+  AccountInfo:
+    type: object
+    properties:
+      account_number:
+        type: string
+      address:
+        type: string
+      coins:
+        type: array
+        items:
+          $ref: "#/definitions/Coin"
+      public_key:
+        type: string
+      sequence:
+        type: string
+  AccountQueryResponse:
+    type: object
+    properties:
+      type:
+        type: string
+      value:
+        $ref: "#/definitions/AccountInfo"
  BlockID:
    type: object
    properties:
--- a/client/lcd/test_helpers.go
+++ b/client/lcd/test_helpers.go
@ -146,7 +146,7 @@ func InitializeTestLCD(
 	// append initial (proposing) validator
 	genDoc.Validators[0] = tmtypes.GenesisValidator{
 		PubKey: privVal.GetPubKey(),
-		Power:  999999, // create enough power to enable 2/3 voting power
+		Power:  100, // create enough power to enable 2/3 voting power
 		Name:   "validator-1",
 	}

@ -176,7 +176,7 @@ func InitializeTestLCD(
 		appGenTxs = append(appGenTxs, appGenTx)
 	}

-	genesisState, err := gapp.GaiaAppGenState(cdc, appGenTxs[:])
+	genesisState, err := gapp.NewTestGaiaAppGenState(cdc, appGenTxs[:], genDoc.Validators, valOperAddrs)
 	require.NoError(t, err)

 	// add some tokens to init accounts
--- a/client/rpc/validators.go
+++ b/client/rpc/validators.go
@ -11,10 +11,10 @@ import (

 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/client/utils"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/spf13/viper"
 	tmtypes "github.com/tendermint/tendermint/types"
-	"github.com/cosmos/cosmos-sdk/client/utils"
 )

 // TODO these next two functions feel kinda hacky based on their placement
--- a/cmd/gaia/app/genesis.go
+++ b/cmd/gaia/app/genesis.go
@ -14,7 +14,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/slashing"
 	"github.com/cosmos/cosmos-sdk/x/stake"
-	stakeTypes "github.com/cosmos/cosmos-sdk/x/stake/types"

 	"github.com/spf13/pflag"

@ -163,7 +162,6 @@ func GaiaAppGenTxNF(cdc *codec.Codec, pk crypto.PubKey, addr sdk.AccAddress, nam
 // Create the core parameters for genesis initialization for gaia
 // note that the pubkey input is this machines pubkey
 func GaiaAppGenState(cdc *codec.Codec, appGenTxs []json.RawMessage) (genesisState GenesisState, err error) {
-
 	if len(appGenTxs) == 0 {
 		err = errors.New("must provide at least genesis transaction")
 		return
@ -201,6 +199,7 @@ func GaiaAppGenState(cdc *codec.Codec, appGenTxs []json.RawMessage) (genesisStat
 		GovData:      gov.DefaultGenesisState(),
 		SlashingData: slashingData,
 	}
+
 	return
 }

@ -247,29 +246,13 @@ func GaiaValidateGenesisState(genesisState GenesisState) (err error) {
 	if err != nil {
 		return
 	}
-	err = validateGenesisStateValidators(genesisState.StakeData.Validators)
+	err = stake.ValidateGenesis(genesisState.StakeData)
 	if err != nil {
 		return
 	}
 	return
 }

-func validateGenesisStateValidators(validators []stakeTypes.Validator) (err error) {
-	addrMap := make(map[string]bool, len(validators))
-	for i := 0; i < len(validators); i++ {
-		val := validators[i]
-		strKey := string(val.ConsPubKey.Bytes())
-		if _, ok := addrMap[strKey]; ok {
-			return fmt.Errorf("Duplicate validator in genesis state: moniker %v, Address %v", val.Description.Moniker, val.ConsAddress())
-		}
-		if val.Jailed && val.Status == sdk.Bonded {
-			return fmt.Errorf("Validator is bonded and jailed in genesis state: moniker %v, Address %v", val.Description.Moniker, val.ConsAddress())
-		}
-		addrMap[strKey] = true
-	}
-	return
-}
-
 // Ensures that there are no duplicate accounts in the genesis state,
 func validateGenesisStateAccounts(accs []GenesisAccount) (err error) {
 	addrMap := make(map[string]bool, len(accs))
--- a/cmd/gaia/app/sim_test.go
+++ b/cmd/gaia/app/sim_test.go
@ -101,9 +101,7 @@ func testAndRunTxs(app *GaiaApp) []simulation.WeightedOperation {
 		{5, stakesim.SimulateMsgEditValidator(app.stakeKeeper)},
 		{100, stakesim.SimulateMsgDelegate(app.accountMapper, app.stakeKeeper)},
 		{100, stakesim.SimulateMsgBeginUnbonding(app.accountMapper, app.stakeKeeper)},
-		{100, stakesim.SimulateMsgCompleteUnbonding(app.stakeKeeper)},
 		{100, stakesim.SimulateMsgBeginRedelegate(app.accountMapper, app.stakeKeeper)},
-		{100, stakesim.SimulateMsgCompleteRedelegate(app.stakeKeeper)},
 		{100, slashingsim.SimulateMsgUnjail(app.slashingKeeper)},
 	}
 }
--- a/cmd/gaia/app/test_utils.go
+++ b/cmd/gaia/app/test_utils.go
@ -0,0 +1,76 @@
+package app
+
+import (
+	"encoding/json"
+	"errors"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/gov"
+	"github.com/cosmos/cosmos-sdk/x/stake"
+	tmtypes "github.com/tendermint/tendermint/types"
+)
+
+// NewTestGaiaAppGenState creates the core parameters for a test genesis
+// initialization given a set of genesis txs, TM validators and their respective
+// operating addresses.
+func NewTestGaiaAppGenState(
+	cdc *codec.Codec, appGenTxs []json.RawMessage, tmVals []tmtypes.GenesisValidator, valOperAddrs []sdk.ValAddress,
+) (GenesisState, error) {
+
+	switch {
+	case len(appGenTxs) == 0:
+		return GenesisState{}, errors.New("must provide at least genesis transaction")
+	case len(tmVals) != len(valOperAddrs):
+		return GenesisState{}, errors.New("number of TM validators does not match number of operator addresses")
+	}
+
+	// start with the default staking genesis state
+	stakeData := stake.DefaultGenesisState()
+
+	// get genesis account information
+	genAccs := make([]GenesisAccount, len(appGenTxs))
+	for i, appGenTx := range appGenTxs {
+
+		var genTx GaiaGenTx
+		if err := cdc.UnmarshalJSON(appGenTx, &genTx); err != nil {
+			return GenesisState{}, err
+		}
+
+		stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.Add(sdk.NewDecFromInt(freeFermionsAcc))
+
+		// create the genesis account for the given genesis tx
+		genAccs[i] = genesisAccountFromGenTx(genTx)
+	}
+
+	for i, tmVal := range tmVals {
+		var issuedDelShares sdk.Dec
+
+		// increase total supply by validator's power
+		power := sdk.NewInt(tmVal.Power)
+		stakeData.Pool.LooseTokens = stakeData.Pool.LooseTokens.Add(sdk.NewDecFromInt(power))
+
+		// add the validator
+		desc := stake.NewDescription(tmVal.Name, "", "", "")
+		validator := stake.NewValidator(valOperAddrs[i], tmVal.PubKey, desc)
+
+		validator, stakeData.Pool, issuedDelShares = validator.AddTokensFromDel(stakeData.Pool, power)
+		stakeData.Validators = append(stakeData.Validators, validator)
+
+		// create the self-delegation from the issuedDelShares
+		selfDel := stake.Delegation{
+			DelegatorAddr: sdk.AccAddress(validator.OperatorAddr),
+			ValidatorAddr: validator.OperatorAddr,
+			Shares:        issuedDelShares,
+			Height:        0,
+		}
+
+		stakeData.Bonds = append(stakeData.Bonds, selfDel)
+	}
+
+	return GenesisState{
+		Accounts:  genAccs,
+		StakeData: stakeData,
+		GovData:   gov.DefaultGenesisState(),
+	}, nil
+}
--- a/cmd/gaia/cmd/gaiadebug/main.go
+++ b/cmd/gaia/cmd/gaiadebug/main.go
@ -138,11 +138,17 @@ func runPubKeyCmd(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
+
+	consenusPub, err := sdk.Bech32ifyConsPub(pubKey)
+	if err != nil {
+		return err
+	}
 	fmt.Println("Address:", pubKey.Address())
 	fmt.Printf("Hex: %X\n", pubkeyBytes)
 	fmt.Println("JSON (base64):", string(pubKeyJSONBytes))
 	fmt.Println("Bech32 Acc:", accPub)
-	fmt.Println("Bech32 Val:", valPub)
+	fmt.Println("Bech32 Validator Operator:", valPub)
+	fmt.Println("Bech32 Validator Consensus:", consenusPub)
 	return nil
 }

--- a/docs/spec/staking/end_block.md
+++ b/docs/spec/staking/end_block.md
@ -16,3 +16,34 @@ EndBlock() ValidatorSetChanges
    ClearTendermintUpdates()
    return vsc
 ```
+
+## CompleteUnbonding
+
+Complete the unbonding and transfer the coins to the delegate. Realize any
+slashing that occurred during the unbonding period.
+
+```golang
+unbondingQueue(currTime time.Time):
+    // unbondings are in ordered queue from oldest to newest
+    for all unbondings whose CompleteTime < currTime:
+        validator = GetValidator(unbonding.ValidatorAddr)
+        AddCoins(unbonding.DelegatorAddr, unbonding.Balance)
+        removeUnbondingDelegation(unbonding)
+    return
+```
+
+## CompleteRedelegation
+
+Note that unlike CompleteUnbonding slashing of redelegating shares does not
+take place during completion. Slashing on redelegated shares takes place
+actively as a slashing occurs. The redelegation completion queue serves simply to
+clean up state, as redelegations older than an unbonding period need not be kept,
+as that is the max time that their old validator's evidence can be used to slash them.
+
+```golang
+redelegationQueue(currTime time.Time):
+    // redelegations are in ordered queue from oldest to newest
+    for all redelegations whose CompleteTime < currTime:
+        removeRedelegation(redelegation)
+    return
+```
--- a/docs/spec/staking/transactions.md
+++ b/docs/spec/staking/transactions.md
@ -7,9 +7,7 @@ corresponding updates to the state. Transactions:
 * TxEditValidator
 * TxDelegation
 * TxStartUnbonding
-* TxCompleteUnbonding
 * TxRedelegate
-* TxCompleteRedelegation

 Other important state changes:

@ -188,27 +186,6 @@ startUnbonding(tx TxStartUnbonding):
    return
 ```

-### TxCompleteUnbonding
-
-Complete the unbonding and transfer the coins to the delegate. Perform any
-slashing that occurred during the unbonding period.
-
-```golang
-type TxUnbondingComplete struct {
-    DelegatorAddr sdk.Address
-    ValidatorAddr sdk.Address
-}
-
-redelegationComplete(tx TxRedelegate):
-    unbonding = getUnbondingDelegation(tx.DelegatorAddr, tx.Validator)
-    if unbonding.CompleteTime >= CurrentBlockTime && unbonding.CompleteHeight >= CurrentBlockHeight
-        validator = GetValidator(tx.ValidatorAddr)
-        returnTokens = ExpectedTokens * tx.startSlashRatio/validator.SlashRatio
-	    AddCoins(unbonding.DelegatorAddr, returnTokens)
-        removeUnbondingDelegation(unbonding)
-    return
-```
-
 ### TxRedelegation

 The redelegation command allows delegators to instantly switch validators. Once
@ -243,26 +220,6 @@ redelegate(tx TxRedelegate):
    return
 ```

-### TxCompleteRedelegation
-
-Note that unlike TxCompleteUnbonding slashing of redelegating shares does not
-take place during completion. Slashing on redelegated shares takes place
-actively as a slashing occurs.
-
-```golang
-type TxRedelegationComplete struct {
-    DelegatorAddr Address
-    ValidatorFrom Validator
-    ValidatorTo   Validator
-}
-
-redelegationComplete(tx TxRedelegate):
-    redelegation = getRedelegation(tx.DelegatorAddr, tx.validatorFrom, tx.validatorTo)
-    if redelegation.CompleteTime >= CurrentBlockTime && redelegation.CompleteHeight >= CurrentBlockHeight
-        removeRedelegation(redelegation)
-    return
-```
-
 ### Update Validators

 Within many transactions the validator set must be updated based on changes in
--- a/scripts/multisim.sh
+++ b/scripts/multisim.sh
@ -1,12 +1,14 @@
 #!/bin/bash

-seeds=(1 2 4 7 9 20 32 123 4728 37827 981928 87821 891823782 989182 89182391)
+seeds=(1 2 4 7 9 20 32 123 124 582 1893 2989 3012 4728 37827 981928 87821 891823782 989182 89182391)
+blocks=$1

-echo "Running multi-seed simulation with seeds: ${seeds[@]}"
+echo "Running multi-seed simulation with seeds ${seeds[@]}"
+echo "Running $blocks blocks per seed"
 echo "Edit scripts/multisim.sh to add new seeds. Keeping parameters in the file makes failures easy to reproduce."
-echo "This script will kill all sub-simulations on SIGINT/SIGTERM/EXIT (i.e. Ctrl-C)."
+echo "This script will kill all sub-simulations on SIGINT/SIGTERM (i.e. Ctrl-C)."

-trap 'kill $(jobs -pr)' SIGINT SIGTERM EXIT
+trap 'kill $(jobs -pr)' SIGINT SIGTERM

 tmpdir=$(mktemp -d)
 echo "Using temporary log directory: $tmpdir"
@ -16,7 +18,7 @@ sim() {
 	echo "Running full Gaia simulation with seed $seed. This may take awhile!"
  file="$tmpdir/gaia-simulation-seed-$seed-date-$(date -Iseconds -u).stdout"
  echo "Writing stdout to $file..."
-	go test ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationEnabled=true -SimulationNumBlocks=1000 \
+	go test ./cmd/gaia/app -run TestFullGaiaSimulation -SimulationEnabled=true -SimulationNumBlocks=$blocks \
    -SimulationVerbose=true -SimulationCommit=true -SimulationSeed=$seed -v -timeout 24h > $file
 }

@ -26,7 +28,7 @@ for seed in ${seeds[@]}; do
  sim $seed &
  pids[${i}]=$!
  i=$(($i+1))
-  sleep 0.1 # start in order, nicer logs
+  sleep 10 # start in order, nicer logs
 done

 echo "Simulation processes spawned, waiting for completion..."
@ -37,10 +39,13 @@ i=0
 for pid in ${pids[*]}; do
  wait $pid
  last=$?
-  if [ $last -ne 0 ]; then
-    seed=${seeds[${i}]}
+  seed=${seeds[${i}]}
+  if [ $last -ne 0 ]
+  then
    echo "Simulation with seed $seed failed!"
    code=1
+  else
+    echo "Simulation with seed $seed OK"
  fi
  i=$(($i+1))
 done
--- a/types/context.go
+++ b/types/context.go
@ -4,6 +4,7 @@ package types
 import (
 	"context"
 	"sync"
+	"time"

 	"github.com/golang/protobuf/proto"

@ -180,6 +181,12 @@ func (c Context) WithBlockHeader(header abci.Header) Context {
 	return c.withValue(contextKeyBlockHeader, header)
 }

+func (c Context) WithBlockTime(newTime time.Time) Context {
+	newHeader := c.BlockHeader()
+	newHeader.Time = newTime
+	return c.WithBlockHeader(newHeader)
+}
+
 func (c Context) WithBlockHeight(height int64) Context {
 	return c.withValue(contextKeyBlockHeight, height)
 }
@ -189,7 +196,7 @@ func (c Context) WithConsensusParams(params *abci.ConsensusParams) Context {
 		return c
 	}
 	return c.withValue(contextKeyConsensusParams, params).
-		WithGasMeter(NewGasMeter(params.TxSize.MaxGas))
+		WithGasMeter(NewGasMeter(params.BlockSize.MaxGas))
 }

 func (c Context) WithChainID(chainID string) Context { return c.withValue(contextKeyChainID, chainID) }
--- a/types/store.go
+++ b/types/store.go
@ -306,6 +306,13 @@ func PrefixEndBytes(prefix []byte) []byte {
 	return end
 }

+// InclusiveEndBytes returns the []byte that would end a
+// range query such that the input would be included
+func InclusiveEndBytes(inclusiveBytes []byte) (exclusiveBytes []byte) {
+	exclusiveBytes = append(inclusiveBytes, byte(0x00))
+	return exclusiveBytes
+}
+
 // TransientStoreKey is used for indexing transient stores in a MultiStore
 type TransientStoreKey struct {
 	name string
--- a/x/auth/client/rest/query.go
+++ b/x/auth/client/rest/query.go
@ -17,7 +17,7 @@ import (
 // register REST routes
 func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Codec, storeName string) {
 	r.HandleFunc(
-		"/accounts/{address}",
+		"/auth/accounts/{address}",
 		QueryAccountRequestHandlerFn(storeName, cdc, authcmd.GetAccountDecoder(cdc), cliCtx),
 	).Methods("GET")
 	r.HandleFunc(
@ -36,7 +36,6 @@ func QueryAccountRequestHandlerFn(
 	decoder auth.AccountDecoder, cliCtx context.CLIContext,
 ) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
 		vars := mux.Vars(r)
 		bech32addr := vars["address"]

--- a/x/distribution/types/validator_info.go
+++ b/x/distribution/types/validator_info.go
@ -19,9 +19,9 @@ func NewValidatorDistInfo(operatorAddr sdk.ValAddress, currentHeight int64) Vali
 	return ValidatorDistInfo{
 		OperatorAddr:            operatorAddr,
 		FeePoolWithdrawalHeight: currentHeight,
-		Pool:           DecCoins{},
-		PoolCommission: DecCoins{},
-		DelAccum:       NewTotalAccum(currentHeight),
+		Pool:                    DecCoins{},
+		PoolCommission:          DecCoins{},
+		DelAccum:                NewTotalAccum(currentHeight),
 	}
 }

--- a/x/mock/simulation/constants.go
+++ b/x/mock/simulation/constants.go
@ -14,7 +14,7 @@ const (
 	numKeys int = 250

 	// Chance that double-signing evidence is found on a given block
-	evidenceFraction float64 = 0.01
+	evidenceFraction float64 = 0.5

 	// TODO Remove in favor of binary search for invariant violation
 	onOperation bool = false
--- a/x/mock/simulation/random_simulate_blocks.go
+++ b/x/mock/simulation/random_simulate_blocks.go
@ -77,6 +77,9 @@ func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 	}

 	validators := initChain(r, accs, setups, app, appStateFn)
+	// Second variable to keep pending validator set (delayed one block since TM 0.24)
+	// Initially this is the same as the initial validator set
+	nextValidators := validators

 	header := abci.Header{Height: 0, Time: timestamp}
 	opCount := 0
@ -160,8 +163,9 @@ func SimulateFromSeed(tb testing.TB, app *baseapp.BaseApp,
 		// Generate a random RequestBeginBlock with the current validator set for the next block
 		request = RandomRequestBeginBlock(r, validators, livenessTransitionMatrix, evidenceFraction, pastTimes, pastVoteInfos, event, header)

-		// Update the validator set
-		validators = updateValidators(tb, r, validators, res.ValidatorUpdates, event)
+		// Update the validator set, which will be reflected in the application on the next block
+		validators = nextValidators
+		nextValidators = updateValidators(tb, r, validators, res.ValidatorUpdates, event)
 	}
 	if stopEarly {
 		DisplayEvents(events)
--- a/x/slashing/handler_test.go
+++ b/x/slashing/handler_test.go
@ -70,9 +70,8 @@ func TestJailedValidatorDelegations(t *testing.T) {
 	got = stake.NewHandler(stakeKeeper)(ctx, msgBeginUnbonding)
 	require.True(t, got.IsOK(), "expected begin unbonding validator msg to be ok, got: %v", got)

-	msgCompleteUnbonding := stake.NewMsgCompleteUnbonding(sdk.AccAddress(valAddr), valAddr)
-	got = stake.NewHandler(stakeKeeper)(ctx, msgCompleteUnbonding)
-	require.True(t, got.IsOK(), "expected complete unbonding validator msg to be ok, got: %v", got)
+	err := stakeKeeper.CompleteUnbonding(ctx, sdk.AccAddress(valAddr), valAddr)
+	require.Nil(t, err, "expected complete unbonding validator to be ok, got: %v", err)

 	// verify validator still exists and is jailed
 	validator, found := stakeKeeper.GetValidator(ctx, valAddr)
--- a/x/slashing/keeper.go
+++ b/x/slashing/keeper.go
@ -9,6 +9,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/params"
+	stake "github.com/cosmos/cosmos-sdk/x/stake/types"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto"
 )
@ -57,19 +58,28 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, addr crypto.Address, infractio
 	// Double sign confirmed
 	logger.Info(fmt.Sprintf("Confirmed double sign from %s at height %d, age of %d less than max age of %d", pubkey.Address(), infractionHeight, age, maxEvidenceAge))

+	// We need to retrieve the stake distribution which signed the block, so we subtract ValidatorUpdateDelay from the evidence height.
+	// Note that this *can* result in a negative "distributionHeight", up to -ValidatorUpdateDelay,
+	// i.e. at the end of the pre-genesis block (none) = at the beginning of the genesis block.
+	// That's fine since this is just used to filter unbonding delegations & redelegations.
+	distributionHeight := infractionHeight - stake.ValidatorUpdateDelay
+
 	// Cap the amount slashed to the penalty for the worst infraction
 	// within the slashing period when this infraction was committed
 	fraction := k.SlashFractionDoubleSign(ctx)
-	revisedFraction := k.capBySlashingPeriod(ctx, consAddr, fraction, infractionHeight)
+	revisedFraction := k.capBySlashingPeriod(ctx, consAddr, fraction, distributionHeight)
 	logger.Info(fmt.Sprintf("Fraction slashed capped by slashing period from %v to %v", fraction, revisedFraction))

 	// Slash validator
-	k.validatorSet.Slash(ctx, consAddr, infractionHeight, power, revisedFraction)
+	k.validatorSet.Slash(ctx, consAddr, distributionHeight, power, revisedFraction)

-	// Jail validator
-	k.validatorSet.Jail(ctx, consAddr)
+	// Jail validator if not already jailed
+	validator := k.validatorSet.ValidatorByConsAddr(ctx, consAddr)
+	if !validator.GetJailed() {
+		k.validatorSet.Jail(ctx, consAddr)
+	}

-	// Set validator jail duration
+	// Set or updated validator jail duration
 	signInfo, found := k.getValidatorSigningInfo(ctx, consAddr)
 	if !found {
 		panic(fmt.Sprintf("Expected signing info for validator %s but not found", consAddr))
@ -124,7 +134,13 @@ func (k Keeper) handleValidatorSignature(ctx sdk.Context, addr crypto.Address, p
 			// Downtime confirmed: slash and jail the validator
 			logger.Info(fmt.Sprintf("Validator %s past min height of %d and below signed blocks threshold of %d",
 				pubkey.Address(), minHeight, k.MinSignedPerWindow(ctx)))
-			k.validatorSet.Slash(ctx, consAddr, height, power, k.SlashFractionDowntime(ctx))
+			// We need to retrieve the stake distribution which signed the block, so we subtract ValidatorUpdateDelay from the evidence height,
+			// and subtract an additional 1 since this is the LastCommit.
+			// Note that this *can* result in a negative "distributionHeight" up to -ValidatorUpdateDelay-1,
+			// i.e. at the end of the pre-genesis block (none) = at the beginning of the genesis block.
+			// That's fine since this is just used to filter unbonding delegations & redelegations.
+			distributionHeight := height - stake.ValidatorUpdateDelay - 1
+			k.validatorSet.Slash(ctx, consAddr, distributionHeight, power, k.SlashFractionDowntime(ctx))
 			k.validatorSet.Jail(ctx, consAddr)
 			signInfo.JailedUntil = ctx.BlockHeader().Time.Add(k.DowntimeUnbondDuration(ctx))
 		} else {
--- a/x/slashing/keeper_test.go
+++ b/x/slashing/keeper_test.go
@ -24,20 +24,21 @@ func keeperTestParams() Params {

 // Test that a validator is slashed correctly
 // when we discover evidence of infraction
-// TODO fix this test to not be using the same pubkey/address for signing and operating, it's confusing
 func TestHandleDoubleSign(t *testing.T) {

 	// initial setup
 	ctx, ck, sk, _, keeper := createTestInput(t, keeperTestParams())
+	// validator added pre-genesis
+	ctx = ctx.WithBlockHeight(-1)
 	sk = sk.WithHooks(keeper.Hooks())
 	amtInt := int64(100)
-	addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
-	got := stake.NewHandler(sk)(ctx, newTestMsgCreateValidator(addr, val, amt))
+	operatorAddr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
+	got := stake.NewHandler(sk)(ctx, newTestMsgCreateValidator(operatorAddr, val, amt))
 	require.True(t, got.IsOK())
 	validatorUpdates := stake.EndBlocker(ctx, sk)
 	keeper.AddValidators(ctx, validatorUpdates)
-	require.Equal(t, ck.GetCoins(ctx, sdk.AccAddress(addr)), sdk.Coins{{sk.GetParams(ctx).BondDenom, initCoins.Sub(amt)}})
-	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, addr).GetPower()))
+	require.Equal(t, ck.GetCoins(ctx, sdk.AccAddress(operatorAddr)), sdk.Coins{{sk.GetParams(ctx).BondDenom, initCoins.Sub(amt)}})
+	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, operatorAddr).GetPower()))

 	// handle a signature to set signing info
 	keeper.handleValidatorSignature(ctx, val.Address(), amtInt, true)
@ -46,13 +47,13 @@ func TestHandleDoubleSign(t *testing.T) {
 	keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), amtInt)

 	// should be jailed
-	require.True(t, sk.Validator(ctx, addr).GetJailed())
+	require.True(t, sk.Validator(ctx, operatorAddr).GetJailed())
 	// unjail to measure power
-	sk.Unjail(ctx, sdk.ConsAddress(addr)) // TODO distinguish cons address
+	sk.Unjail(ctx, sdk.ConsAddress(val.Address()))
 	// power should be reduced
 	require.Equal(
 		t, sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20))),
-		sk.Validator(ctx, addr).GetPower(),
+		sk.Validator(ctx, operatorAddr).GetPower(),
 	)
 	ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(1, 0).Add(keeper.MaxEvidenceAge(ctx))})

@ -60,74 +61,74 @@ func TestHandleDoubleSign(t *testing.T) {
 	keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), amtInt)
 	require.Equal(
 		t, sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20))),
-		sk.Validator(ctx, addr).GetPower(),
+		sk.Validator(ctx, operatorAddr).GetPower(),
 	)
 }

 // Test that the amount a validator is slashed for multiple double signs
 // is correctly capped by the slashing period in which they were committed
-// TODO properly distinguish between consensus and operator address is variable names
 func TestSlashingPeriodCap(t *testing.T) {

 	// initial setup
 	ctx, ck, sk, _, keeper := createTestInput(t, DefaultParams())
 	sk = sk.WithHooks(keeper.Hooks())
 	amtInt := int64(100)
-	addr, amt := addrs[0], sdk.NewInt(amtInt)
-	valConsPubKey, valConsAddr := pks[0], sdk.ConsAddress(pks[0].Address())
-	got := stake.NewHandler(sk)(ctx, newTestMsgCreateValidator(addr, valConsPubKey, amt))
+	operatorAddr, amt := addrs[0], sdk.NewInt(amtInt)
+	valConsPubKey, valConsAddr := pks[0], pks[0].Address()
+	got := stake.NewHandler(sk)(ctx, newTestMsgCreateValidator(operatorAddr, valConsPubKey, amt))
 	require.True(t, got.IsOK())
 	validatorUpdates := stake.EndBlocker(ctx, sk)
+	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1)
 	keeper.AddValidators(ctx, validatorUpdates)
-	require.Equal(t, ck.GetCoins(ctx, sdk.AccAddress(addr)), sdk.Coins{{sk.GetParams(ctx).BondDenom, initCoins.Sub(amt)}})
-	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, addr).GetPower()))
+	require.Equal(t, ck.GetCoins(ctx, sdk.AccAddress(operatorAddr)), sdk.Coins{{sk.GetParams(ctx).BondDenom, initCoins.Sub(amt)}})
+	require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, operatorAddr).GetPower()))

 	// handle a signature to set signing info
-	keeper.handleValidatorSignature(ctx, valConsPubKey.Address(), amtInt, true)
+	keeper.handleValidatorSignature(ctx, valConsAddr, amtInt, true)

 	// double sign less than max age
-	keeper.handleDoubleSign(ctx, valConsPubKey.Address(), 0, time.Unix(0, 0), amtInt)
+	keeper.handleDoubleSign(ctx, valConsAddr, 1, time.Unix(0, 0), amtInt)
 	// should be jailed
-	require.True(t, sk.Validator(ctx, addr).GetJailed())
-	// end block
-	stake.EndBlocker(ctx, sk)
-	// update block height
-	ctx = ctx.WithBlockHeight(int64(1))
-	// unjail to measure power
-	sk.Unjail(ctx, valConsAddr)
-	// end block
-	stake.EndBlocker(ctx, sk)
-	// power should be reduced
-	expectedPower := sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20)))
-	require.Equal(t, expectedPower, sk.Validator(ctx, addr).GetPower())
-
-	// double sign again, same slashing period
-	keeper.handleDoubleSign(ctx, valConsPubKey.Address(), 0, time.Unix(0, 0), amtInt)
-	// should be jailed
-	require.True(t, sk.Validator(ctx, addr).GetJailed())
+	require.True(t, sk.Validator(ctx, operatorAddr).GetJailed())
 	// end block
 	stake.EndBlocker(ctx, sk)
 	// update block height
 	ctx = ctx.WithBlockHeight(int64(2))
 	// unjail to measure power
-	sk.Unjail(ctx, valConsAddr)
+	sk.Unjail(ctx, sdk.ConsAddress(valConsAddr))
+	// end block
+	stake.EndBlocker(ctx, sk)
+	// power should be reduced
+	expectedPower := sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20)))
+	require.Equal(t, expectedPower, sk.Validator(ctx, operatorAddr).GetPower())
+
+	// double sign again, same slashing period
+	keeper.handleDoubleSign(ctx, valConsAddr, 1, time.Unix(0, 0), amtInt)
+	// should be jailed
+	require.True(t, sk.Validator(ctx, operatorAddr).GetJailed())
+	// end block
+	stake.EndBlocker(ctx, sk)
+	// update block height
+	ctx = ctx.WithBlockHeight(int64(3))
+	// unjail to measure power
+	sk.Unjail(ctx, sdk.ConsAddress(valConsAddr))
 	// end block
 	stake.EndBlocker(ctx, sk)
 	// power should be equal, no more should have been slashed
 	expectedPower = sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20)))
-	require.Equal(t, expectedPower, sk.Validator(ctx, addr).GetPower())
+	require.Equal(t, expectedPower, sk.Validator(ctx, operatorAddr).GetPower())

 	// double sign again, new slashing period
-	keeper.handleDoubleSign(ctx, valConsPubKey.Address(), 2, time.Unix(0, 0), amtInt)
+	keeper.handleDoubleSign(ctx, valConsAddr, 3, time.Unix(0, 0), amtInt)
 	// should be jailed
-	require.True(t, sk.Validator(ctx, addr).GetJailed())
+	require.True(t, sk.Validator(ctx, operatorAddr).GetJailed())
 	// unjail to measure power
-	sk.Unjail(ctx, valConsAddr)
+	sk.Unjail(ctx, sdk.ConsAddress(valConsAddr))
 	// end block
 	stake.EndBlocker(ctx, sk)
 	// power should be reduced
 	expectedPower = sdk.NewDecFromInt(amt).Mul(sdk.NewDec(18).Quo(sdk.NewDec(20)))
-	require.Equal(t, expectedPower, sk.Validator(ctx, addr).GetPower())
+	require.Equal(t, expectedPower, sk.Validator(ctx, operatorAddr).GetPower())
 }

 // Test a validator through uptime, downtime, revocation,
@ -198,6 +199,35 @@ func TestHandleAbsentValidator(t *testing.T) {
 	validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
 	require.Equal(t, sdk.Unbonding, validator.GetStatus())

+	slashAmt := sdk.NewDec(amtInt).Mul(keeper.SlashFractionDowntime(ctx)).RoundInt64()
+
+	// validator should have been slashed
+	require.Equal(t, amtInt-slashAmt, validator.GetTokens().RoundInt64())
+
+	// 502nd block *also* missed (since the LastCommit would have still included the just-unbonded validator)
+	height++
+	ctx = ctx.WithBlockHeight(height)
+	keeper.handleValidatorSignature(ctx, val.Address(), amtInt, false)
+	info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
+	require.True(t, found)
+	require.Equal(t, int64(0), info.StartHeight)
+	require.Equal(t, keeper.SignedBlocksWindow(ctx)-keeper.MinSignedPerWindow(ctx)-2, info.SignedBlocksCounter)
+
+	// end block
+	stake.EndBlocker(ctx, sk)
+
+	// validator should not have been slashed any more, since it was already jailed
+	validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
+	require.Equal(t, amtInt-slashAmt, validator.GetTokens().RoundInt64())
+
+	// 502nd block *double signed* (oh no!)
+	keeper.handleDoubleSign(ctx, val.Address(), height, ctx.BlockHeader().Time, amtInt)
+
+	// validator should have been slashed
+	validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
+	secondSlashAmt := sdk.NewDec(amtInt).Mul(keeper.SlashFractionDoubleSign(ctx)).RoundInt64()
+	require.Equal(t, amtInt-slashAmt-secondSlashAmt, validator.GetTokens().RoundInt64())
+
 	// unrevocation should fail prior to jail expiration
 	got = slh(ctx, NewMsgUnjail(addr))
 	require.False(t, got.IsOK())
@ -216,14 +246,14 @@ func TestHandleAbsentValidator(t *testing.T) {

 	// validator should have been slashed
 	pool = sk.GetPool(ctx)
-	slashAmt := sdk.NewDec(amtInt).Mul(keeper.SlashFractionDowntime(ctx)).RoundInt64()
-	require.Equal(t, amtInt-slashAmt, pool.BondedTokens.RoundInt64())
+	require.Equal(t, amtInt-slashAmt-secondSlashAmt, pool.BondedTokens.RoundInt64())

 	// validator start height should have been changed
 	info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
 	require.True(t, found)
 	require.Equal(t, height, info.StartHeight)
-	require.Equal(t, keeper.SignedBlocksWindow(ctx)-keeper.MinSignedPerWindow(ctx)-1, info.SignedBlocksCounter)
+	// we've missed 2 blocks more than the maximum
+	require.Equal(t, keeper.SignedBlocksWindow(ctx)-keeper.MinSignedPerWindow(ctx)-2, info.SignedBlocksCounter)

 	// validator should not be immediately jailed again
 	height++
--- a/x/slashing/keys.go
+++ b/x/slashing/keys.go
@ -4,6 +4,7 @@ import (
 	"encoding/binary"

 	sdk "github.com/cosmos/cosmos-sdk/types"
+	stake "github.com/cosmos/cosmos-sdk/x/stake/types"
 )

 // key prefix bytes
@ -34,7 +35,8 @@ func GetValidatorSlashingPeriodPrefix(v sdk.ConsAddress) []byte {
 // stored by *Tendermint* address (not operator address) followed by start height
 func GetValidatorSlashingPeriodKey(v sdk.ConsAddress, startHeight int64) []byte {
 	b := make([]byte, 8)
-	binary.LittleEndian.PutUint64(b, uint64(startHeight))
+	// this needs to be height + ValidatorUpdateDelay because the slashing period for genesis validators starts at height -ValidatorUpdateDelay
+	binary.BigEndian.PutUint64(b, uint64(startHeight+stake.ValidatorUpdateDelay))
 	return append(GetValidatorSlashingPeriodPrefix(v), b...)
 }

--- a/x/slashing/slashing_period.go
+++ b/x/slashing/slashing_period.go
@ -5,6 +5,7 @@ import (
 	"fmt"

 	sdk "github.com/cosmos/cosmos-sdk/types"
+	stake "github.com/cosmos/cosmos-sdk/x/stake/types"
 )

 // Cap an infraction's slash amount by the slashing period in which it was committed
@ -15,7 +16,7 @@ func (k Keeper) capBySlashingPeriod(ctx sdk.Context, address sdk.ConsAddress, fr

 	// Sanity check
 	if slashingPeriod.EndHeight > 0 && slashingPeriod.EndHeight < infractionHeight {
-		panic(fmt.Sprintf("slashing period ended before infraction: infraction height %d, slashing period ended at %d", infractionHeight, slashingPeriod.EndHeight))
+		panic(fmt.Sprintf("slashing period ended before infraction: validator %s, infraction height %d, slashing period ended at %d", address, infractionHeight, slashingPeriod.EndHeight))
 	}

 	// Calculate the updated total slash amount
@ -43,7 +44,7 @@ func (k Keeper) getValidatorSlashingPeriodForHeight(ctx sdk.Context, address sdk
 	end := sdk.PrefixEndBytes(GetValidatorSlashingPeriodKey(address, height))
 	iterator := store.ReverseIterator(start, end)
 	if !iterator.Valid() {
-		panic("expected to find slashing period, but none was found")
+		panic(fmt.Sprintf("expected to find slashing period for validator %s before height %d, but none was found", address, height))
 	}
 	slashingPeriod = k.unmarshalSlashingPeriodKeyValue(iterator.Key(), iterator.Value())
 	return
@ -68,7 +69,7 @@ func (k Keeper) unmarshalSlashingPeriodKeyValue(key []byte, value []byte) Valida
 	var slashingPeriodValue ValidatorSlashingPeriodValue
 	k.cdc.MustUnmarshalBinary(value, &slashingPeriodValue)
 	address := sdk.ConsAddress(key[1 : 1+sdk.AddrLen])
-	startHeight := int64(binary.LittleEndian.Uint64(key[1+sdk.AddrLen : 1+sdk.AddrLen+8]))
+	startHeight := int64(binary.BigEndian.Uint64(key[1+sdk.AddrLen:1+sdk.AddrLen+8]) - uint64(stake.ValidatorUpdateDelay))
 	return ValidatorSlashingPeriod{
 		ValidatorAddr: address,
 		StartHeight:   startHeight,
--- a/x/stake/client/cli/tx.go
+++ b/x/stake/client/cli/tx.go
@ -209,7 +209,6 @@ func GetCmdRedelegate(storeName string, cdc *codec.Codec) *cobra.Command {
 	cmd.AddCommand(
 		client.PostCommands(
 			GetCmdBeginRedelegate(storeName, cdc),
-			GetCmdCompleteRedelegate(cdc),
 		)...)

 	return cmd
@ -270,47 +269,6 @@ func GetCmdBeginRedelegate(storeName string, cdc *codec.Codec) *cobra.Command {
 	return cmd
 }

-// GetCmdCompleteRedelegate implements the complete redelegation command.
-func GetCmdCompleteRedelegate(cdc *codec.Codec) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "complete",
-		Short: "complete redelegation",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			txBldr := authtxb.NewTxBuilderFromCLI().WithCodec(cdc)
-			cliCtx := context.NewCLIContext().
-				WithCodec(cdc).
-				WithAccountDecoder(authcmd.GetAccountDecoder(cdc))
-
-			delAddr, err := cliCtx.GetFromAddress()
-			if err != nil {
-				return err
-			}
-
-			valSrcAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidatorSrc))
-			if err != nil {
-				return err
-			}
-
-			valDstAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidatorDst))
-			if err != nil {
-				return err
-			}
-
-			msg := stake.NewMsgCompleteRedelegate(delAddr, valSrcAddr, valDstAddr)
-
-			if cliCtx.GenerateOnly {
-				return utils.PrintUnsignedStdTx(txBldr, cliCtx, []sdk.Msg{msg})
-			}
-			// build and sign the transaction, then broadcast to Tendermint
-			return utils.CompleteAndBroadcastTxCli(txBldr, cliCtx, []sdk.Msg{msg})
-		},
-	}
-
-	cmd.Flags().AddFlagSet(fsRedelegation)
-
-	return cmd
-}
-
 // GetCmdUnbond implements the unbond validator command.
 func GetCmdUnbond(storeName string, cdc *codec.Codec) *cobra.Command {
 	cmd := &cobra.Command{
@ -321,7 +279,6 @@ func GetCmdUnbond(storeName string, cdc *codec.Codec) *cobra.Command {
 	cmd.AddCommand(
 		client.PostCommands(
 			GetCmdBeginUnbonding(storeName, cdc),
-			GetCmdCompleteUnbonding(cdc),
 		)...)

 	return cmd
@ -374,39 +331,3 @@ func GetCmdBeginUnbonding(storeName string, cdc *codec.Codec) *cobra.Command {

 	return cmd
 }
-
-// GetCmdCompleteUnbonding implements the complete unbonding validator command.
-func GetCmdCompleteUnbonding(cdc *codec.Codec) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "complete",
-		Short: "complete unbonding",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			txBldr := authtxb.NewTxBuilderFromCLI().WithCodec(cdc)
-			cliCtx := context.NewCLIContext().
-				WithCodec(cdc).
-				WithAccountDecoder(authcmd.GetAccountDecoder(cdc))
-
-			delAddr, err := cliCtx.GetFromAddress()
-			if err != nil {
-				return err
-			}
-
-			valAddr, err := sdk.ValAddressFromBech32(viper.GetString(FlagAddressValidator))
-			if err != nil {
-				return err
-			}
-
-			msg := stake.NewMsgCompleteUnbonding(delAddr, valAddr)
-
-			if cliCtx.GenerateOnly {
-				return utils.PrintUnsignedStdTx(txBldr, cliCtx, []sdk.Msg{msg})
-			}
-			// build and sign the transaction, then broadcast to Tendermint
-			return utils.CompleteAndBroadcastTxCli(txBldr, cliCtx, []sdk.Msg{msg})
-		},
-	}
-
-	cmd.Flags().AddFlagSet(fsValidator)
-
-	return cmd
-}
--- a/x/stake/client/rest/tx.go
+++ b/x/stake/client/rest/tx.go
@ -41,31 +41,18 @@ type (
 		SharesAmount     string `json:"shares"`
 	}

-	msgCompleteRedelegateInput struct {
-		DelegatorAddr    string `json:"delegator_addr"`     // in bech32
-		ValidatorSrcAddr string `json:"validator_src_addr"` // in bech32
-		ValidatorDstAddr string `json:"validator_dst_addr"` // in bech32
-	}
-
 	msgBeginUnbondingInput struct {
 		DelegatorAddr string `json:"delegator_addr"` // in bech32
 		ValidatorAddr string `json:"validator_addr"` // in bech32
 		SharesAmount  string `json:"shares"`
 	}

-	msgCompleteUnbondingInput struct {
-		DelegatorAddr string `json:"delegator_addr"` // in bech32
-		ValidatorAddr string `json:"validator_addr"` // in bech32
-	}
-
 	// the request body for edit delegations
 	EditDelegationsReq struct {
-		BaseReq             utils.BaseReq                `json:"base_req"`
-		Delegations         []msgDelegationsInput        `json:"delegations"`
-		BeginUnbondings     []msgBeginUnbondingInput     `json:"begin_unbondings"`
-		CompleteUnbondings  []msgCompleteUnbondingInput  `json:"complete_unbondings"`
-		BeginRedelegates    []msgBeginRedelegateInput    `json:"begin_redelegates"`
-		CompleteRedelegates []msgCompleteRedelegateInput `json:"complete_redelegates"`
+		BaseReq          utils.BaseReq             `json:"base_req"`
+		Delegations      []msgDelegationsInput     `json:"delegations"`
+		BeginUnbondings  []msgBeginUnbondingInput  `json:"begin_unbondings"`
+		BeginRedelegates []msgBeginRedelegateInput `json:"begin_redelegates"`
 	}
 )

@ -106,9 +93,7 @@ func delegationsRequestHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx conte
 		// build messages
 		messages := make([]sdk.Msg, len(req.Delegations)+
 			len(req.BeginRedelegates)+
-			len(req.CompleteRedelegates)+
-			len(req.BeginUnbondings)+
-			len(req.CompleteUnbondings))
+			len(req.BeginUnbondings))

 		i := 0
 		for _, msg := range req.Delegations {
@ -177,39 +162,6 @@ func delegationsRequestHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx conte
 			i++
 		}

-		for _, msg := range req.CompleteRedelegates {
-			delAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
-			if err != nil {
-				utils.WriteErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error()))
-				return
-			}
-
-			valSrcAddr, err := sdk.ValAddressFromBech32(msg.ValidatorSrcAddr)
-			if err != nil {
-				utils.WriteErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))
-				return
-			}
-
-			valDstAddr, err := sdk.ValAddressFromBech32(msg.ValidatorDstAddr)
-			if err != nil {
-				utils.WriteErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))
-				return
-			}
-
-			if !bytes.Equal(info.GetPubKey().Address(), delAddr) {
-				utils.WriteErrorResponse(w, http.StatusUnauthorized, "Must use own delegator address")
-				return
-			}
-
-			messages[i] = stake.MsgCompleteRedelegate{
-				DelegatorAddr:    delAddr,
-				ValidatorSrcAddr: valSrcAddr,
-				ValidatorDstAddr: valDstAddr,
-			}
-
-			i++
-		}
-
 		for _, msg := range req.BeginUnbondings {
 			delAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
 			if err != nil {
@ -243,32 +195,6 @@ func delegationsRequestHandlerFn(cdc *codec.Codec, kb keys.Keybase, cliCtx conte
 			i++
 		}

-		for _, msg := range req.CompleteUnbondings {
-			delAddr, err := sdk.AccAddressFromBech32(msg.DelegatorAddr)
-			if err != nil {
-				utils.WriteErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Couldn't decode delegator. Error: %s", err.Error()))
-				return
-			}
-
-			valAddr, err := sdk.ValAddressFromBech32(msg.ValidatorAddr)
-			if err != nil {
-				utils.WriteErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error()))
-				return
-			}
-
-			if !bytes.Equal(info.GetPubKey().Address(), delAddr) {
-				utils.WriteErrorResponse(w, http.StatusUnauthorized, "Must use own delegator address")
-				return
-			}
-
-			messages[i] = stake.MsgCompleteUnbonding{
-				DelegatorAddr: delAddr,
-				ValidatorAddr: valAddr,
-			}
-
-			i++
-		}
-
 		simulateGas, gas, err := client.ReadGasFlag(baseReq.Gas)
 		if err != nil {
 			utils.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
--- a/x/stake/genesis.go
+++ b/x/stake/genesis.go
@ -1,6 +1,8 @@
 package stake

 import (
+	"fmt"
+
 	abci "github.com/tendermint/tendermint/abci/types"
 	tmtypes "github.com/tendermint/tendermint/types"

@ -16,6 +18,12 @@ import (
 // the bonded validators.
 // Returns final validator set after applying all declaration and delegations
 func InitGenesis(ctx sdk.Context, keeper Keeper, data types.GenesisState) (res []abci.ValidatorUpdate, err error) {
+
+	// We need to pretend to be "n blocks before genesis", where "n" is the validator update delay,
+	// so that e.g. slashing periods are correctly initialized for the validator set
+	// e.g. with a one-block offset - the first TM block is at height 0, so state updates applied from genesis.json are in block -1.
+	ctx = ctx.WithBlockHeight(-types.ValidatorUpdateDelay)
+
 	keeper.SetPool(ctx, data.Pool)
 	keeper.SetParams(ctx, data.Params)
 	keeper.InitIntraTxCounter(ctx)
@ -75,3 +83,58 @@ func WriteValidators(ctx sdk.Context, keeper Keeper) (vals []tmtypes.GenesisVali

 	return
 }
+
+// ValidateGenesis validates the provided staking genesis state to ensure the
+// expected invariants holds. (i.e. params in correct bounds, no duplicate validators)
+func ValidateGenesis(data types.GenesisState) error {
+	err := validateGenesisStateValidators(data.Validators)
+	if err != nil {
+		return err
+	}
+	err = validateParams(data.Params)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func validateParams(params types.Params) error {
+	if params.GoalBonded.LTE(sdk.ZeroDec()) {
+		bondedPercent := params.GoalBonded.MulInt(sdk.NewInt(100)).String()
+		return fmt.Errorf("staking parameter GoalBonded should be positive, instead got %s percent", bondedPercent)
+	}
+	if params.GoalBonded.GT(sdk.OneDec()) {
+		bondedPercent := params.GoalBonded.MulInt(sdk.NewInt(100)).String()
+		return fmt.Errorf("staking parameter GoalBonded should be less than 100 percent, instead got %s percent", bondedPercent)
+	}
+	if params.BondDenom == "" {
+		return fmt.Errorf("staking parameter BondDenom can't be an empty string")
+	}
+	if params.InflationMax.LT(params.InflationMin) {
+		return fmt.Errorf("staking parameter Max inflation must be greater than or equal to min inflation")
+	}
+	return nil
+}
+
+func validateGenesisStateValidators(validators []types.Validator) (err error) {
+	addrMap := make(map[string]bool, len(validators))
+	for i := 0; i < len(validators); i++ {
+		val := validators[i]
+		strKey := string(val.ConsPubKey.Bytes())
+		if _, ok := addrMap[strKey]; ok {
+			return fmt.Errorf("duplicate validator in genesis state: moniker %v, Address %v", val.Description.Moniker, val.ConsAddress())
+		}
+		if val.Jailed && val.Status == sdk.Bonded {
+			return fmt.Errorf("validator is bonded and jailed in genesis state: moniker %v, Address %v", val.Description.Moniker, val.ConsAddress())
+		}
+		if val.Tokens.IsZero() {
+			return fmt.Errorf("genesis validator cannot have zero pool shares, validator: %v", val)
+		}
+		if val.DelegatorShares.IsZero() {
+			return fmt.Errorf("genesis validator cannot have zero delegator shares, validator: %v", val)
+		}
+		addrMap[strKey] = true
+	}
+	return
+}
--- a/x/stake/genesis_test.go
+++ b/x/stake/genesis_test.go
@ -4,13 +4,15 @@ import (
 	"fmt"
 	"testing"

-	"github.com/stretchr/testify/require"
+	"github.com/tendermint/tendermint/crypto/ed25519"

-	abci "github.com/tendermint/tendermint/abci/types"
+	"github.com/stretchr/testify/assert"

 	sdk "github.com/cosmos/cosmos-sdk/types"
 	keep "github.com/cosmos/cosmos-sdk/x/stake/keeper"
 	"github.com/cosmos/cosmos-sdk/x/stake/types"
+	"github.com/stretchr/testify/require"
+	abci "github.com/tendermint/tendermint/abci/types"
 )

 func TestInitGenesis(t *testing.T) {
@ -105,3 +107,59 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {

 	require.Equal(t, abcivals, vals)
 }
+
+func TestValidateGenesis(t *testing.T) {
+	genValidators1 := make([]types.Validator, 1, 5)
+	pk := ed25519.GenPrivKey().PubKey()
+	genValidators1[0] = types.NewValidator(sdk.ValAddress(pk.Address()), pk, types.NewDescription("", "", "", ""))
+	genValidators1[0].Tokens = sdk.OneDec()
+	genValidators1[0].DelegatorShares = sdk.OneDec()
+
+	tests := []struct {
+		name    string
+		mutate  func(*types.GenesisState)
+		wantErr bool
+	}{
+		{"default", func(*types.GenesisState) {}, false},
+		// validate params
+		{"200% goalbonded", func(data *types.GenesisState) { (*data).Params.GoalBonded = sdk.OneDec().Add(sdk.OneDec()) }, true},
+		{"-67% goalbonded", func(data *types.GenesisState) { (*data).Params.GoalBonded = sdk.OneDec().Neg() }, true},
+		{"no bond denom", func(data *types.GenesisState) { (*data).Params.BondDenom = "" }, true},
+		{"min inflation > max inflation", func(data *types.GenesisState) {
+			(*data).Params.InflationMin = (*data).Params.InflationMax.Add(sdk.OneDec())
+		}, true},
+		{"min inflation = max inflation", func(data *types.GenesisState) {
+			(*data).Params.InflationMax = (*data).Params.InflationMin
+		}, false},
+		// validate genesis validators
+		{"duplicate validator", func(data *types.GenesisState) {
+			(*data).Validators = genValidators1
+			(*data).Validators = append((*data).Validators, genValidators1[0])
+		}, true},
+		{"no pool shares", func(data *types.GenesisState) {
+			(*data).Validators = genValidators1
+			(*data).Validators[0].Tokens = sdk.ZeroDec()
+		}, true},
+		{"no delegator shares", func(data *types.GenesisState) {
+			(*data).Validators = genValidators1
+			(*data).Validators[0].DelegatorShares = sdk.ZeroDec()
+		}, true},
+		{"jailed and bonded validator", func(data *types.GenesisState) {
+			(*data).Validators = genValidators1
+			(*data).Validators[0].Jailed = true
+			(*data).Validators[0].Status = sdk.Bonded
+		}, true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			genesisState := types.DefaultGenesisState()
+			tt.mutate(&genesisState)
+			if tt.wantErr {
+				assert.Error(t, ValidateGenesis(genesisState))
+			} else {
+				assert.NoError(t, ValidateGenesis(genesisState))
+			}
+		})
+	}
+}
--- a/x/stake/handler.go
+++ b/x/stake/handler.go
@ -23,12 +23,8 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
 			return handleMsgDelegate(ctx, msg, k)
 		case types.MsgBeginRedelegate:
 			return handleMsgBeginRedelegate(ctx, msg, k)
-		case types.MsgCompleteRedelegate:
-			return handleMsgCompleteRedelegate(ctx, msg, k)
 		case types.MsgBeginUnbonding:
 			return handleMsgBeginUnbonding(ctx, msg, k)
-		case types.MsgCompleteUnbonding:
-			return handleMsgCompleteUnbonding(ctx, msg, k)
 		default:
 			return sdk.ErrTxDecode("invalid message parse in staking module").Result()
 		}
@ -37,6 +33,35 @@ func NewHandler(k keeper.Keeper) sdk.Handler {

 // Called every block, process inflation, update validator set
 func EndBlocker(ctx sdk.Context, k keeper.Keeper) (ValidatorUpdates []abci.ValidatorUpdate) {
+	endBlockerTags := sdk.EmptyTags()
+
+	matureUnbonds := k.DequeueAllMatureUnbondingQueue(ctx, ctx.BlockHeader().Time)
+	for _, dvPair := range matureUnbonds {
+		err := k.CompleteUnbonding(ctx, dvPair.DelegatorAddr, dvPair.ValidatorAddr)
+		if err != nil {
+			continue
+		}
+		endBlockerTags.AppendTags(sdk.NewTags(
+			tags.Action, ActionCompleteUnbonding,
+			tags.Delegator, []byte(dvPair.DelegatorAddr.String()),
+			tags.SrcValidator, []byte(dvPair.ValidatorAddr.String()),
+		))
+	}
+
+	matureRedelegations := k.DequeueAllMatureRedelegationQueue(ctx, ctx.BlockHeader().Time)
+	for _, dvvTriplet := range matureRedelegations {
+		err := k.CompleteRedelegation(ctx, dvvTriplet.DelegatorAddr, dvvTriplet.ValidatorSrcAddr, dvvTriplet.ValidatorDstAddr)
+		if err != nil {
+			continue
+		}
+		endBlockerTags.AppendTags(sdk.NewTags(
+			tags.Action, tags.ActionCompleteRedelegation,
+			tags.Delegator, []byte(dvvTriplet.DelegatorAddr.String()),
+			tags.SrcValidator, []byte(dvvTriplet.ValidatorSrcAddr.String()),
+			tags.DstValidator, []byte(dvvTriplet.ValidatorDstAddr.String()),
+		))
+	}
+
 	pool := k.GetPool(ctx)

 	// Process provision inflation
@ -185,62 +210,37 @@ func handleMsgDelegate(ctx sdk.Context, msg types.MsgDelegate, k keeper.Keeper)
 }

 func handleMsgBeginUnbonding(ctx sdk.Context, msg types.MsgBeginUnbonding, k keeper.Keeper) sdk.Result {
-	err := k.BeginUnbonding(ctx, msg.DelegatorAddr, msg.ValidatorAddr, msg.SharesAmount)
+	ubd, err := k.BeginUnbonding(ctx, msg.DelegatorAddr, msg.ValidatorAddr, msg.SharesAmount)
 	if err != nil {
 		return err.Result()
 	}

+	finishTime := types.MsgCdc.MustMarshalBinary(ubd.MinTime)
+
 	tags := sdk.NewTags(
 		tags.Action, tags.ActionBeginUnbonding,
 		tags.Delegator, []byte(msg.DelegatorAddr.String()),
 		tags.SrcValidator, []byte(msg.ValidatorAddr.String()),
+		tags.EndTime, finishTime,
 	)
-	return sdk.Result{Tags: tags}
-}
-
-func handleMsgCompleteUnbonding(ctx sdk.Context, msg types.MsgCompleteUnbonding, k keeper.Keeper) sdk.Result {
-
-	err := k.CompleteUnbonding(ctx, msg.DelegatorAddr, msg.ValidatorAddr)
-	if err != nil {
-		return err.Result()
-	}
-
-	tags := sdk.NewTags(
-		tags.Action, ActionCompleteUnbonding,
-		tags.Delegator, []byte(msg.DelegatorAddr.String()),
-		tags.SrcValidator, []byte(msg.ValidatorAddr.String()),
-	)
-
-	return sdk.Result{Tags: tags}
+	return sdk.Result{Data: finishTime, Tags: tags}
 }

 func handleMsgBeginRedelegate(ctx sdk.Context, msg types.MsgBeginRedelegate, k keeper.Keeper) sdk.Result {
-	err := k.BeginRedelegation(ctx, msg.DelegatorAddr, msg.ValidatorSrcAddr,
+	red, err := k.BeginRedelegation(ctx, msg.DelegatorAddr, msg.ValidatorSrcAddr,
 		msg.ValidatorDstAddr, msg.SharesAmount)
 	if err != nil {
 		return err.Result()
 	}

+	finishTime := types.MsgCdc.MustMarshalBinary(red.MinTime)
+
 	tags := sdk.NewTags(
 		tags.Action, tags.ActionBeginRedelegation,
 		tags.Delegator, []byte(msg.DelegatorAddr.String()),
 		tags.SrcValidator, []byte(msg.ValidatorSrcAddr.String()),
 		tags.DstValidator, []byte(msg.ValidatorDstAddr.String()),
+		tags.EndTime, finishTime,
 	)
-	return sdk.Result{Tags: tags}
-}
-
-func handleMsgCompleteRedelegate(ctx sdk.Context, msg types.MsgCompleteRedelegate, k keeper.Keeper) sdk.Result {
-	err := k.CompleteRedelegation(ctx, msg.DelegatorAddr, msg.ValidatorSrcAddr, msg.ValidatorDstAddr)
-	if err != nil {
-		return err.Result()
-	}
-
-	tags := sdk.NewTags(
-		tags.Action, tags.ActionCompleteRedelegation,
-		tags.Delegator, []byte(msg.DelegatorAddr.String()),
-		tags.SrcValidator, []byte(msg.ValidatorSrcAddr.String()),
-		tags.DstValidator, []byte(msg.ValidatorDstAddr.String()),
-	)
-	return sdk.Result{Tags: tags}
+	return sdk.Result{Data: finishTime, Tags: tags}
 }
--- a/x/stake/handler_test.go
+++ b/x/stake/handler_test.go
@ -125,11 +125,12 @@ func TestValidatorByPowerIndex(t *testing.T) {

 	// unbond self-delegation
 	msgBeginUnbonding := NewMsgBeginUnbonding(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(1000000))
-	msgCompleteUnbonding := NewMsgCompleteUnbonding(sdk.AccAddress(validatorAddr), validatorAddr)
 	got = handleMsgBeginUnbonding(ctx, msgBeginUnbonding, keeper)
 	require.True(t, got.IsOK(), "expected msg to be ok, got %v", got)
-	got = handleMsgCompleteUnbonding(ctx, msgCompleteUnbonding, keeper)
-	require.True(t, got.IsOK(), "expected msg to be ok, got %v", got)
+	var finishTime time.Time
+	types.MsgCdc.MustUnmarshalBinary(got.Data, &finishTime)
+	ctx = ctx.WithBlockTime(finishTime)
+	EndBlocker(ctx, keeper)

 	EndBlocker(ctx, keeper)

@ -260,13 +261,14 @@ func TestLegacyValidatorDelegations(t *testing.T) {
 	// unbond validator total self-delegations (which should jail the validator)
 	unbondShares := sdk.NewDec(10)
 	msgBeginUnbonding := NewMsgBeginUnbonding(sdk.AccAddress(valAddr), valAddr, unbondShares)
-	msgCompleteUnbonding := NewMsgCompleteUnbonding(sdk.AccAddress(valAddr), valAddr)

 	got = handleMsgBeginUnbonding(ctx, msgBeginUnbonding, keeper)
 	require.True(t, got.IsOK(), "expected begin unbonding validator msg to be ok, got %v", got)

-	got = handleMsgCompleteUnbonding(ctx, msgCompleteUnbonding, keeper)
-	require.True(t, got.IsOK(), "expected complete unbonding validator msg to be ok, got %v", got)
+	var finishTime time.Time
+	types.MsgCdc.MustUnmarshalBinary(got.Data, &finishTime)
+	ctx = ctx.WithBlockTime(finishTime)
+	EndBlocker(ctx, keeper)

 	// verify the validator record still exists, is jailed, and has correct tokens
 	validator, found = keeper.GetValidator(ctx, valAddr)
@ -427,13 +429,14 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 	// TODO use decimals here
 	unbondShares := sdk.NewDec(10)
 	msgBeginUnbonding := NewMsgBeginUnbonding(delegatorAddr, validatorAddr, unbondShares)
-	msgCompleteUnbonding := NewMsgCompleteUnbonding(delegatorAddr, validatorAddr)
 	numUnbonds := 5
 	for i := 0; i < numUnbonds; i++ {
 		got := handleMsgBeginUnbonding(ctx, msgBeginUnbonding, keeper)
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
-		got = handleMsgCompleteUnbonding(ctx, msgCompleteUnbonding, keeper)
-		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
+		var finishTime time.Time
+		types.MsgCdc.MustUnmarshalBinary(got.Data, &finishTime)
+		ctx = ctx.WithBlockTime(finishTime)
+		EndBlocker(ctx, keeper)

 		//Check that the accounts and the bond account have the appropriate values
 		validator, found = keeper.GetValidator(ctx, validatorAddr)
@ -522,11 +525,12 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
 		_, found := keeper.GetValidator(ctx, validatorAddr)
 		require.True(t, found)
 		msgBeginUnbonding := NewMsgBeginUnbonding(delegatorAddrs[i], validatorAddr, sdk.NewDec(10)) // remove delegation
-		msgCompleteUnbonding := NewMsgCompleteUnbonding(delegatorAddrs[i], validatorAddr)
 		got := handleMsgBeginUnbonding(ctx, msgBeginUnbonding, keeper)
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
-		got = handleMsgCompleteUnbonding(ctx, msgCompleteUnbonding, keeper)
-		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
+		var finishTime time.Time
+		types.MsgCdc.MustUnmarshalBinary(got.Data, &finishTime)
+		ctx = ctx.WithBlockTime(finishTime)
+		EndBlocker(ctx, keeper)

 		//Check that the account is unbonded
 		validators := keeper.GetValidators(ctx, 100)
@ -569,6 +573,10 @@ func TestMultipleMsgDelegate(t *testing.T) {
 		msgBeginUnbonding := NewMsgBeginUnbonding(delegatorAddr, validatorAddr, sdk.NewDec(10))
 		got := handleMsgBeginUnbonding(ctx, msgBeginUnbonding, keeper)
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
+		var finishTime time.Time
+		types.MsgCdc.MustUnmarshalBinary(got.Data, &finishTime)
+		ctx = ctx.WithBlockTime(finishTime)
+		EndBlocker(ctx, keeper)

 		//Check that the account is unbonded
 		_, found := keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
@ -591,12 +599,14 @@ func TestJailValidator(t *testing.T) {
 	got = handleMsgDelegate(ctx, msgDelegate, keeper)
 	require.True(t, got.IsOK(), "expected ok, got %v", got)

-	validator, _ := keeper.GetValidator(ctx, validatorAddr)
-
 	// unbond the validators bond portion
 	msgBeginUnbondingValidator := NewMsgBeginUnbonding(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(10))
 	got = handleMsgBeginUnbonding(ctx, msgBeginUnbondingValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error: %v", got)
+	var finishTime time.Time
+	types.MsgCdc.MustUnmarshalBinary(got.Data, &finishTime)
+	ctx = ctx.WithBlockTime(finishTime)
+	EndBlocker(ctx, keeper)

 	validator, found := keeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
@ -608,11 +618,11 @@ func TestJailValidator(t *testing.T) {

 	// test that the delegator can still withdraw their bonds
 	msgBeginUnbondingDelegator := NewMsgBeginUnbonding(delegatorAddr, validatorAddr, sdk.NewDec(10))
-	msgCompleteUnbondingDelegator := NewMsgCompleteUnbonding(delegatorAddr, validatorAddr)
 	got = handleMsgBeginUnbonding(ctx, msgBeginUnbondingDelegator, keeper)
 	require.True(t, got.IsOK(), "expected no error")
-	got = handleMsgCompleteUnbonding(ctx, msgCompleteUnbondingDelegator, keeper)
-	require.True(t, got.IsOK(), "expected no error")
+	types.MsgCdc.MustUnmarshalBinary(got.Data, &finishTime)
+	ctx = ctx.WithBlockTime(finishTime)
+	EndBlocker(ctx, keeper)

 	// verify that the pubkey can now be reused
 	got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
@ -633,30 +643,74 @@ func TestUnbondingPeriod(t *testing.T) {
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")

+	EndBlocker(ctx, keeper)
+
 	// begin unbonding
 	msgBeginUnbonding := NewMsgBeginUnbonding(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(10))
 	got = handleMsgBeginUnbonding(ctx, msgBeginUnbonding, keeper)
 	require.True(t, got.IsOK(), "expected no error")
+	origHeader := ctx.BlockHeader()
+
+	_, found := keeper.GetUnbondingDelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr)
+	require.True(t, found, "should not have unbonded")

 	// cannot complete unbonding at same time
-	msgCompleteUnbonding := NewMsgCompleteUnbonding(sdk.AccAddress(validatorAddr), validatorAddr)
-	got = handleMsgCompleteUnbonding(ctx, msgCompleteUnbonding, keeper)
-	require.True(t, !got.IsOK(), "expected an error")
+	EndBlocker(ctx, keeper)
+	_, found = keeper.GetUnbondingDelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr)
+	require.True(t, found, "should not have unbonded")

 	// cannot complete unbonding at time 6 seconds later
-	origHeader := ctx.BlockHeader()
-	headerTime6 := origHeader
-	headerTime6.Time = headerTime6.Time.Add(time.Second * 6)
-	ctx = ctx.WithBlockHeader(headerTime6)
-	got = handleMsgCompleteUnbonding(ctx, msgCompleteUnbonding, keeper)
-	require.True(t, !got.IsOK(), "expected an error")
+	ctx = ctx.WithBlockTime(origHeader.Time.Add(time.Second * 6))
+	EndBlocker(ctx, keeper)
+	_, found = keeper.GetUnbondingDelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr)
+	require.True(t, found, "should not have unbonded")

 	// can complete unbonding at time 7 seconds later
-	headerTime7 := origHeader
-	headerTime7.Time = headerTime7.Time.Add(time.Second * 7)
-	ctx = ctx.WithBlockHeader(headerTime7)
-	got = handleMsgCompleteUnbonding(ctx, msgCompleteUnbonding, keeper)
+	ctx = ctx.WithBlockTime(origHeader.Time.Add(time.Second * 7))
+	EndBlocker(ctx, keeper)
+	_, found = keeper.GetUnbondingDelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr)
+	require.False(t, found, "should have unbonded")
+}
+
+func TestUnbondingFromUnbondingValidator(t *testing.T) {
+	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
+	validatorAddr, delegatorAddr := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1]
+
+	// create the validator
+	msgCreateValidator := newTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
+	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
+	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
+
+	// bond a delegator
+	msgDelegate := newTestMsgDelegate(delegatorAddr, validatorAddr, 10)
+	got = handleMsgDelegate(ctx, msgDelegate, keeper)
+	require.True(t, got.IsOK(), "expected ok, got %v", got)
+
+	// unbond the validators bond portion
+	msgBeginUnbondingValidator := NewMsgBeginUnbonding(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(10))
+	got = handleMsgBeginUnbonding(ctx, msgBeginUnbondingValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error")
+
+	// change the ctx to Block Time one second before the validator would have unbonded
+	var finishTime time.Time
+	types.MsgCdc.MustUnmarshalBinary(got.Data, &finishTime)
+	ctx = ctx.WithBlockTime(finishTime.Add(time.Second * -1))
+
+	// unbond the delegator from the validator
+	msgBeginUnbondingDelegator := NewMsgBeginUnbonding(delegatorAddr, validatorAddr, sdk.NewDec(10))
+	got = handleMsgBeginUnbonding(ctx, msgBeginUnbondingDelegator, keeper)
+	require.True(t, got.IsOK(), "expected no error")
+
+	// move the Block time forward by one second
+	ctx = ctx.WithBlockTime(ctx.BlockHeader().Time.Add(time.Second * 1))
+
+	// Run the EndBlocker
+	EndBlocker(ctx, keeper)
+
+	// Check to make sure that the unbonding delegation is no longer in state
+	// (meaning it was deleted in the above EndBlocker)
+	_, found := keeper.GetUnbondingDelegation(ctx, delegatorAddr, validatorAddr)
+	require.False(t, found, "should be removed from state")
 }

 func TestRedelegationPeriod(t *testing.T) {
@ -697,25 +751,24 @@ func TestRedelegationPeriod(t *testing.T) {
 	bal2 := AccMapper.GetAccount(ctx, sdk.AccAddress(validatorAddr)).GetCoins()
 	require.Equal(t, bal1, bal2)

+	origHeader := ctx.BlockHeader()
+
 	// cannot complete redelegation at same time
-	msgCompleteRedelegate := NewMsgCompleteRedelegate(sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2)
-	got = handleMsgCompleteRedelegate(ctx, msgCompleteRedelegate, keeper)
-	require.True(t, !got.IsOK(), "expected an error")
+	EndBlocker(ctx, keeper)
+	_, found := keeper.GetRedelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2)
+	require.True(t, found, "should not have unbonded")

 	// cannot complete redelegation at time 6 seconds later
-	origHeader := ctx.BlockHeader()
-	headerTime6 := origHeader
-	headerTime6.Time = headerTime6.Time.Add(time.Second * 6)
-	ctx = ctx.WithBlockHeader(headerTime6)
-	got = handleMsgCompleteRedelegate(ctx, msgCompleteRedelegate, keeper)
-	require.True(t, !got.IsOK(), "expected an error")
+	ctx = ctx.WithBlockTime(origHeader.Time.Add(time.Second * 6))
+	EndBlocker(ctx, keeper)
+	_, found = keeper.GetRedelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2)
+	require.True(t, found, "should not have unbonded")

 	// can complete redelegation at time 7 seconds later
-	headerTime7 := origHeader
-	headerTime7.Time = headerTime7.Time.Add(time.Second * 7)
-	ctx = ctx.WithBlockHeader(headerTime7)
-	got = handleMsgCompleteRedelegate(ctx, msgCompleteRedelegate, keeper)
-	require.True(t, got.IsOK(), "expected no error")
+	ctx = ctx.WithBlockTime(origHeader.Time.Add(time.Second * 7))
+	EndBlocker(ctx, keeper)
+	_, found = keeper.GetRedelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2)
+	require.False(t, found, "should have unbonded")
 }

 func TestTransitiveRedelegation(t *testing.T) {
@ -753,9 +806,7 @@ func TestTransitiveRedelegation(t *testing.T) {
 	require.True(t, !got.IsOK(), "expected an error, msg: %v", msgBeginRedelegate)

 	// complete first redelegation
-	msgCompleteRedelegate := NewMsgCompleteRedelegate(sdk.AccAddress(validatorAddr), validatorAddr, validatorAddr2)
-	got = handleMsgCompleteRedelegate(ctx, msgCompleteRedelegate, keeper)
-	require.True(t, got.IsOK(), "expected no error")
+	EndBlocker(ctx, keeper)

 	// now should be able to redelegate from the second validator to the third
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
--- a/x/stake/keeper/delegation.go
+++ b/x/stake/keeper/delegation.go
@ -155,6 +155,57 @@ func (k Keeper) RemoveUnbondingDelegation(ctx sdk.Context, ubd types.UnbondingDe
 	store.Delete(GetUBDByValIndexKey(ubd.DelegatorAddr, ubd.ValidatorAddr))
 }

+// gets a specific unbonding queue timeslice. A timeslice is a slice of DVPairs corresponding to unbonding delegations
+// that expire at a certain time.
+func (k Keeper) GetUnbondingQueueTimeSlice(ctx sdk.Context, timestamp time.Time) (dvPairs []types.DVPair) {
+	store := ctx.KVStore(k.storeKey)
+	bz := store.Get(GetUnbondingDelegationTimeKey(timestamp))
+	if bz == nil {
+		return []types.DVPair{}
+	}
+	k.cdc.MustUnmarshalBinary(bz, &dvPairs)
+	return dvPairs
+}
+
+// Sets a specific unbonding queue timeslice.
+func (k Keeper) SetUnbondingQueueTimeSlice(ctx sdk.Context, timestamp time.Time, keys []types.DVPair) {
+	store := ctx.KVStore(k.storeKey)
+	bz := k.cdc.MustMarshalBinary(keys)
+	store.Set(GetUnbondingDelegationTimeKey(timestamp), bz)
+}
+
+// Insert an unbonding delegation to the appropriate timeslice in the unbonding queue
+func (k Keeper) InsertUnbondingQueue(ctx sdk.Context, ubd types.UnbondingDelegation) {
+	timeSlice := k.GetUnbondingQueueTimeSlice(ctx, ubd.MinTime)
+	dvPair := types.DVPair{ubd.DelegatorAddr, ubd.ValidatorAddr}
+	if len(timeSlice) == 0 {
+		k.SetUnbondingQueueTimeSlice(ctx, ubd.MinTime, []types.DVPair{dvPair})
+	} else {
+		timeSlice = append(timeSlice, dvPair)
+		k.SetUnbondingQueueTimeSlice(ctx, ubd.MinTime, timeSlice)
+	}
+}
+
+// Returns all the unbonding queue timeslices from time 0 until endTime
+func (k Keeper) UnbondingQueueIterator(ctx sdk.Context, endTime time.Time) sdk.Iterator {
+	store := ctx.KVStore(k.storeKey)
+	return store.Iterator(UnbondingQueueKey, sdk.InclusiveEndBytes(GetUnbondingDelegationTimeKey(endTime)))
+}
+
+// Returns a concatenated list of all the timeslices before currTime, and deletes the timeslices from the queue
+func (k Keeper) DequeueAllMatureUnbondingQueue(ctx sdk.Context, currTime time.Time) (matureUnbonds []types.DVPair) {
+	store := ctx.KVStore(k.storeKey)
+	// gets an iterator for all timeslices from time 0 until the current Blockheader time
+	unbondingTimesliceIterator := k.UnbondingQueueIterator(ctx, ctx.BlockHeader().Time)
+	for ; unbondingTimesliceIterator.Valid(); unbondingTimesliceIterator.Next() {
+		timeslice := []types.DVPair{}
+		k.cdc.MustUnmarshalBinary(unbondingTimesliceIterator.Value(), &timeslice)
+		matureUnbonds = append(matureUnbonds, timeslice...)
+		store.Delete(unbondingTimesliceIterator.Key())
+	}
+	return matureUnbonds
+}
+
 //_____________________________________________________________________________________

 // return a given amount of all the delegator redelegations
@ -241,6 +292,57 @@ func (k Keeper) RemoveRedelegation(ctx sdk.Context, red types.Redelegation) {
 	store.Delete(GetREDByValDstIndexKey(red.DelegatorAddr, red.ValidatorSrcAddr, red.ValidatorDstAddr))
 }

+// Gets a specific redelegation queue timeslice. A timeslice is a slice of DVVTriplets corresponding to redelegations
+// that expire at a certain time.
+func (k Keeper) GetRedelegationQueueTimeSlice(ctx sdk.Context, timestamp time.Time) (dvvTriplets []types.DVVTriplet) {
+	store := ctx.KVStore(k.storeKey)
+	bz := store.Get(GetRedelegationTimeKey(timestamp))
+	if bz == nil {
+		return []types.DVVTriplet{}
+	}
+	k.cdc.MustUnmarshalBinary(bz, &dvvTriplets)
+	return dvvTriplets
+}
+
+// Sets a specific redelegation queue timeslice.
+func (k Keeper) SetRedelegationQueueTimeSlice(ctx sdk.Context, timestamp time.Time, keys []types.DVVTriplet) {
+	store := ctx.KVStore(k.storeKey)
+	bz := k.cdc.MustMarshalBinary(keys)
+	store.Set(GetRedelegationTimeKey(timestamp), bz)
+}
+
+// Insert an redelegation delegation to the appropriate timeslice in the redelegation queue
+func (k Keeper) InsertRedelegationQueue(ctx sdk.Context, red types.Redelegation) {
+	timeSlice := k.GetRedelegationQueueTimeSlice(ctx, red.MinTime)
+	dvvTriplet := types.DVVTriplet{red.DelegatorAddr, red.ValidatorSrcAddr, red.ValidatorDstAddr}
+	if len(timeSlice) == 0 {
+		k.SetRedelegationQueueTimeSlice(ctx, red.MinTime, []types.DVVTriplet{dvvTriplet})
+	} else {
+		timeSlice = append(timeSlice, dvvTriplet)
+		k.SetRedelegationQueueTimeSlice(ctx, red.MinTime, timeSlice)
+	}
+}
+
+// Returns all the redelegation queue timeslices from time 0 until endTime
+func (k Keeper) RedelegationQueueIterator(ctx sdk.Context, endTime time.Time) sdk.Iterator {
+	store := ctx.KVStore(k.storeKey)
+	return store.Iterator(RedelegationQueueKey, sdk.InclusiveEndBytes(GetRedelegationTimeKey(endTime)))
+}
+
+// Returns a concatenated list of all the timeslices before currTime, and deletes the timeslices from the queue
+func (k Keeper) DequeueAllMatureRedelegationQueue(ctx sdk.Context, currTime time.Time) (matureRedelegations []types.DVVTriplet) {
+	store := ctx.KVStore(k.storeKey)
+	// gets an iterator for all timeslices from time 0 until the current Blockheader time
+	redelegationTimesliceIterator := k.RedelegationQueueIterator(ctx, ctx.BlockHeader().Time)
+	for ; redelegationTimesliceIterator.Valid(); redelegationTimesliceIterator.Next() {
+		timeslice := []types.DVVTriplet{}
+		k.cdc.MustUnmarshalBinary(redelegationTimesliceIterator.Value(), &timeslice)
+		matureRedelegations = append(matureRedelegations, timeslice...)
+		store.Delete(redelegationTimesliceIterator.Key())
+	}
+	return matureRedelegations
+}
+
 //_____________________________________________________________________________________

 // Perform a delegation, set/update everything necessary within the store.
@ -339,6 +441,7 @@ func (k Keeper) getBeginInfo(ctx sdk.Context, valSrcAddr sdk.ValAddress) (
 	minTime time.Time, height int64, completeNow bool) {

 	validator, found := k.GetValidator(ctx, valSrcAddr)
+
 	switch {
 	case !found || validator.Status == sdk.Bonded:

@ -362,30 +465,31 @@ func (k Keeper) getBeginInfo(ctx sdk.Context, valSrcAddr sdk.ValAddress) (

 // begin unbonding an unbonding record
 func (k Keeper) BeginUnbonding(ctx sdk.Context,
-	delAddr sdk.AccAddress, valAddr sdk.ValAddress, sharesAmount sdk.Dec) sdk.Error {
+	delAddr sdk.AccAddress, valAddr sdk.ValAddress, sharesAmount sdk.Dec) (types.UnbondingDelegation, sdk.Error) {

 	// TODO quick fix, instead we should use an index, see https://github.com/cosmos/cosmos-sdk/issues/1402
 	_, found := k.GetUnbondingDelegation(ctx, delAddr, valAddr)
 	if found {
-		return types.ErrExistingUnbondingDelegation(k.Codespace())
-	}
-
-	returnAmount, err := k.unbond(ctx, delAddr, valAddr, sharesAmount)
-	if err != nil {
-		return err
+		return types.UnbondingDelegation{}, types.ErrExistingUnbondingDelegation(k.Codespace())
 	}

 	// create the unbonding delegation
 	minTime, height, completeNow := k.getBeginInfo(ctx, valAddr)
-	balance := sdk.Coin{k.BondDenom(ctx), returnAmount.RoundInt()}
+
+	returnAmount, err := k.unbond(ctx, delAddr, valAddr, sharesAmount)
+	if err != nil {
+		return types.UnbondingDelegation{}, err
+	}
+
+	balance := sdk.NewCoin(k.BondDenom(ctx), returnAmount.RoundInt())

 	// no need to create the ubd object just complete now
 	if completeNow {
 		_, _, err := k.bankKeeper.AddCoins(ctx, delAddr, sdk.Coins{balance})
 		if err != nil {
-			return err
+			return types.UnbondingDelegation{}, err
 		}
-		return nil
+		return types.UnbondingDelegation{MinTime: minTime}, nil
 	}

 	ubd := types.UnbondingDelegation{
@ -397,10 +501,12 @@ func (k Keeper) BeginUnbonding(ctx sdk.Context,
 		InitialBalance: balance,
 	}
 	k.SetUnbondingDelegation(ctx, ubd)
-	return nil
+	k.InsertUnbondingQueue(ctx, ubd)
+	return ubd, nil
 }

 // complete unbonding an unbonding record
+// CONTRACT: Expects unbonding passed in has finished the unbonding period
 func (k Keeper) CompleteUnbonding(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) sdk.Error {

 	ubd, found := k.GetUnbondingDelegation(ctx, delAddr, valAddr)
@ -408,12 +514,6 @@ func (k Keeper) CompleteUnbonding(ctx sdk.Context, delAddr sdk.AccAddress, valAd
 		return types.ErrNoUnbondingDelegation(k.Codespace())
 	}

-	// ensure that enough time has passed
-	ctxTime := ctx.BlockHeader().Time
-	if ubd.MinTime.After(ctxTime) {
-		return types.ErrNotMature(k.Codespace(), "unbonding", "unit-time", ubd.MinTime, ctxTime)
-	}
-
 	_, _, err := k.bankKeeper.AddCoins(ctx, ubd.DelegatorAddr, sdk.Coins{ubd.Balance})
 	if err != nil {
 		return err
@ -424,33 +524,33 @@ func (k Keeper) CompleteUnbonding(ctx sdk.Context, delAddr sdk.AccAddress, valAd

 // complete unbonding an unbonding record
 func (k Keeper) BeginRedelegation(ctx sdk.Context, delAddr sdk.AccAddress,
-	valSrcAddr, valDstAddr sdk.ValAddress, sharesAmount sdk.Dec) sdk.Error {
+	valSrcAddr, valDstAddr sdk.ValAddress, sharesAmount sdk.Dec) (types.Redelegation, sdk.Error) {

 	// check if this is a transitive redelegation
 	if k.HasReceivingRedelegation(ctx, delAddr, valSrcAddr) {
-		return types.ErrTransitiveRedelegation(k.Codespace())
+		return types.Redelegation{}, types.ErrTransitiveRedelegation(k.Codespace())
 	}

 	returnAmount, err := k.unbond(ctx, delAddr, valSrcAddr, sharesAmount)
 	if err != nil {
-		return err
+		return types.Redelegation{}, err
 	}

 	returnCoin := sdk.Coin{k.BondDenom(ctx), returnAmount.RoundInt()}
 	dstValidator, found := k.GetValidator(ctx, valDstAddr)
 	if !found {
-		return types.ErrBadRedelegationDst(k.Codespace())
+		return types.Redelegation{}, types.ErrBadRedelegationDst(k.Codespace())
 	}
 	sharesCreated, err := k.Delegate(ctx, delAddr, returnCoin, dstValidator, false)
 	if err != nil {
-		return err
+		return types.Redelegation{}, err
 	}

 	// create the unbonding delegation
 	minTime, height, completeNow := k.getBeginInfo(ctx, valSrcAddr)

 	if completeNow { // no need to create the redelegation object
-		return nil
+		return types.Redelegation{MinTime: minTime}, nil
 	}

 	red := types.Redelegation{
@ -465,7 +565,8 @@ func (k Keeper) BeginRedelegation(ctx sdk.Context, delAddr sdk.AccAddress,
 		InitialBalance:   returnCoin,
 	}
 	k.SetRedelegation(ctx, red)
-	return nil
+	k.InsertRedelegationQueue(ctx, red)
+	return red, nil
 }

 // complete unbonding an ongoing redelegation
--- a/x/stake/keeper/delegation_test.go
+++ b/x/stake/keeper/delegation_test.go
@ -250,7 +250,7 @@ func TestUndelegateSelfDelegation(t *testing.T) {
 	keeper.SetDelegation(ctx, delegation)

 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	err := keeper.BeginUnbonding(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
+	_, err := keeper.BeginUnbonding(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
 	require.NoError(t, err)

 	// end block
@ -306,7 +306,7 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) {

 	// unbond the all self-delegation to put validator in unbonding state
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	err := keeper.BeginUnbonding(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
+	_, err := keeper.BeginUnbonding(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
 	require.NoError(t, err)

 	// end block
@ -328,7 +328,7 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) {
 	ctx = ctx.WithBlockHeader(header)

 	// unbond some of the other delegation's shares
-	err = keeper.BeginUnbonding(ctx, addrDels[0], addrVals[0], sdk.NewDec(6))
+	_, err = keeper.BeginUnbonding(ctx, addrDels[0], addrVals[0], sdk.NewDec(6))
 	require.NoError(t, err)

 	// retrieve the unbonding delegation
@ -382,7 +382,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
 	ctx = ctx.WithBlockHeader(header)

 	// unbond the all self-delegation to put validator in unbonding state
-	err := keeper.BeginUnbonding(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
+	_, err := keeper.BeginUnbonding(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
 	require.NoError(t, err)

 	// end block
@ -404,7 +404,7 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
 	ctx = ctx.WithBlockHeader(header)

 	// unbond some of the other delegation's shares
-	err = keeper.BeginUnbonding(ctx, addrDels[0], addrVals[0], sdk.NewDec(6))
+	_, err = keeper.BeginUnbonding(ctx, addrDels[0], addrVals[0], sdk.NewDec(6))
 	require.NoError(t, err)

 	// no ubd should have been found, coins should have been returned direcly to account
@ -553,7 +553,7 @@ func TestRedelegateSelfDelegation(t *testing.T) {
 	}
 	keeper.SetDelegation(ctx, delegation)

-	err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], sdk.NewDec(10))
+	_, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], sdk.NewDec(10))
 	require.NoError(t, err)

 	// end block
@ -618,7 +618,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 	ctx = ctx.WithBlockHeader(header)

 	// unbond the all self-delegation to put validator in unbonding state
-	err := keeper.BeginUnbonding(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
+	_, err := keeper.BeginUnbonding(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
 	require.NoError(t, err)

 	// end block
@ -640,7 +640,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 	ctx = ctx.WithBlockHeader(header)

 	// unbond some of the other delegation's shares
-	err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], sdk.NewDec(6))
+	_, err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], sdk.NewDec(6))
 	require.NoError(t, err)

 	// retrieve the unbonding delegation
@ -704,7 +704,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 	ctx = ctx.WithBlockHeader(header)

 	// unbond the all self-delegation to put validator in unbonding state
-	err := keeper.BeginUnbonding(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
+	_, err := keeper.BeginUnbonding(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
 	require.NoError(t, err)

 	// end block
@ -726,7 +726,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 	ctx = ctx.WithBlockHeader(header)

 	// unbond some of the other delegation's shares
-	err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], sdk.NewDec(6))
+	_, err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], sdk.NewDec(6))
 	require.NoError(t, err)

 	// no ubd should have been found, coins should have been returned direcly to account
--- a/x/stake/keeper/key.go
+++ b/x/stake/keeper/key.go
@ -2,6 +2,7 @@ package keeper

 import (
 	"encoding/binary"
+	"time"

 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/stake/types"
@ -26,6 +27,8 @@ var (
 	RedelegationKey                  = []byte{0x0A} // key for a redelegation
 	RedelegationByValSrcIndexKey     = []byte{0x0B} // prefix for each key for an redelegation, by source validator operator
 	RedelegationByValDstIndexKey     = []byte{0x0C} // prefix for each key for an redelegation, by destination validator operator
+	UnbondingQueueKey                = []byte{0x0D} // prefix for the timestamps in unbonding queue
+	RedelegationQueueKey             = []byte{0x0E} // prefix for the timestamps in redelegations queue
 )

 const maxDigitsForAccount = 12 // ~220,000,000 atoms created at launch
@ -135,6 +138,12 @@ func GetUBDsByValIndexKey(valAddr sdk.ValAddress) []byte {
 	return append(UnbondingDelegationByValIndexKey, valAddr.Bytes()...)
 }

+// gets the prefix for all unbonding delegations from a delegator
+func GetUnbondingDelegationTimeKey(timestamp time.Time) []byte {
+	bz := types.MsgCdc.MustMarshalBinary(timestamp)
+	return append(UnbondingQueueKey, bz...)
+}
+
 //________________________________________________________________________________

 // gets the key for a redelegation
@ -203,6 +212,12 @@ func GetREDKeyFromValDstIndexKey(indexKey []byte) []byte {
 	return GetREDKey(delAddr, valSrcAddr, valDstAddr)
 }

+// gets the prefix for all unbonding delegations from a delegator
+func GetRedelegationTimeKey(timestamp time.Time) []byte {
+	bz, _ := timestamp.MarshalBinary()
+	return append(RedelegationQueueKey, bz...)
+}
+
 //______________

 // gets the prefix keyspace for redelegations from a delegator
--- a/x/stake/keeper/slash_test.go
+++ b/x/stake/keeper/slash_test.go
@ -191,6 +191,34 @@ func TestSlashAtFutureHeight(t *testing.T) {
 	require.Panics(t, func() { keeper.Slash(ctx, consAddr, 1, 10, fraction) })
 }

+// test slash at a negative height
+// this just represents pre-genesis and should have the same effect as slashing at height 0
+func TestSlashAtNegativeHeight(t *testing.T) {
+	ctx, keeper, _ := setupHelper(t, 10)
+	consAddr := sdk.ConsAddress(PKs[0].Address())
+	fraction := sdk.NewDecWithPrec(5, 1)
+
+	oldPool := keeper.GetPool(ctx)
+	validator, found := keeper.GetValidatorByConsAddr(ctx, consAddr)
+	require.True(t, found)
+	keeper.Slash(ctx, consAddr, -2, 10, fraction)
+
+	// read updated state
+	validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
+	require.True(t, found)
+	newPool := keeper.GetPool(ctx)
+
+	// end block
+	updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
+	require.Equal(t, 1, len(updates), "cons addr: %v, updates: %v", []byte(consAddr), updates)
+
+	validator = keeper.mustGetValidator(ctx, validator.OperatorAddr)
+	// power decreased
+	require.Equal(t, sdk.NewDec(5), validator.GetPower())
+	// pool bonded shares decreased
+	require.Equal(t, sdk.NewDec(5).RoundInt64(), oldPool.BondedTokens.Sub(newPool.BondedTokens).RoundInt64())
+}
+
 // tests Slash at the current height
 func TestSlashValidatorAtCurrentHeight(t *testing.T) {
 	ctx, keeper, _ := setupHelper(t, 10)
--- a/x/stake/keeper/test_common.go
+++ b/x/stake/keeper/test_common.go
@ -63,9 +63,7 @@ func MakeTestCodec() *codec.Codec {
 	cdc.RegisterConcrete(types.MsgCreateValidator{}, "test/stake/CreateValidator", nil)
 	cdc.RegisterConcrete(types.MsgEditValidator{}, "test/stake/EditValidator", nil)
 	cdc.RegisterConcrete(types.MsgBeginUnbonding{}, "test/stake/BeginUnbonding", nil)
-	cdc.RegisterConcrete(types.MsgCompleteUnbonding{}, "test/stake/CompleteUnbonding", nil)
 	cdc.RegisterConcrete(types.MsgBeginRedelegate{}, "test/stake/BeginRedelegate", nil)
-	cdc.RegisterConcrete(types.MsgCompleteRedelegate{}, "test/stake/CompleteRedelegate", nil)

 	// Register AppAccount
 	cdc.RegisterInterface((*auth.Account)(nil), nil)
--- a/x/stake/simulation/msgs.go
+++ b/x/stake/simulation/msgs.go
@ -178,33 +178,6 @@ func SimulateMsgBeginUnbonding(m auth.AccountMapper, k stake.Keeper) simulation.
 	}
 }

-// SimulateMsgCompleteUnbonding
-func SimulateMsgCompleteUnbonding(k stake.Keeper) simulation.Operation {
-	handler := stake.NewHandler(k)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
-
-		validatorAcc := simulation.RandomAcc(r, accs)
-		validatorAddress := sdk.ValAddress(validatorAcc.Address)
-		delegatorAcc := simulation.RandomAcc(r, accs)
-		delegatorAddress := delegatorAcc.Address
-		msg := stake.MsgCompleteUnbonding{
-			DelegatorAddr: delegatorAddress,
-			ValidatorAddr: validatorAddress,
-		}
-		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
-		}
-		ctx, write := ctx.CacheContext()
-		result := handler(ctx, msg)
-		if result.IsOK() {
-			write()
-		}
-		event(fmt.Sprintf("stake/MsgCompleteUnbonding/%v", result.IsOK()))
-		action = fmt.Sprintf("TestMsgCompleteUnbonding: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
-	}
-}
-
 // SimulateMsgBeginRedelegate
 func SimulateMsgBeginRedelegate(m auth.AccountMapper, k stake.Keeper) simulation.Operation {
 	handler := stake.NewHandler(k)
@ -245,36 +218,6 @@ func SimulateMsgBeginRedelegate(m auth.AccountMapper, k stake.Keeper) simulation
 	}
 }

-// SimulateMsgCompleteRedelegate
-func SimulateMsgCompleteRedelegate(k stake.Keeper) simulation.Operation {
-	handler := stake.NewHandler(k)
-	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, event func(string)) (action string, fOp []simulation.FutureOperation, err error) {
-
-		validatorSrcAcc := simulation.RandomAcc(r, accs)
-		validatorSrcAddress := sdk.ValAddress(validatorSrcAcc.Address)
-		validatorDstAcc := simulation.RandomAcc(r, accs)
-		validatorDstAddress := sdk.ValAddress(validatorDstAcc.Address)
-		delegatorAcc := simulation.RandomAcc(r, accs)
-		delegatorAddress := delegatorAcc.Address
-		msg := stake.MsgCompleteRedelegate{
-			DelegatorAddr:    delegatorAddress,
-			ValidatorSrcAddr: validatorSrcAddress,
-			ValidatorDstAddr: validatorDstAddress,
-		}
-		if msg.ValidateBasic() != nil {
-			return "", nil, fmt.Errorf("expected msg to pass ValidateBasic: %s", msg.GetSignBytes())
-		}
-		ctx, write := ctx.CacheContext()
-		result := handler(ctx, msg)
-		if result.IsOK() {
-			write()
-		}
-		event(fmt.Sprintf("stake/MsgCompleteRedelegate/%v", result.IsOK()))
-		action = fmt.Sprintf("TestMsgCompleteRedelegate: ok %v, msg %s", result.IsOK(), msg.GetSignBytes())
-		return action, nil, nil
-	}
-}
-
 // Setup
 // nolint: errcheck
 func Setup(mapp *mock.App, k stake.Keeper) simulation.RandSetup {
--- a/x/stake/simulation/sim_test.go
+++ b/x/stake/simulation/sim_test.go
@ -54,9 +54,7 @@ func TestStakeWithRandomMessages(t *testing.T) {
 			{5, SimulateMsgEditValidator(stakeKeeper)},
 			{15, SimulateMsgDelegate(mapper, stakeKeeper)},
 			{10, SimulateMsgBeginUnbonding(mapper, stakeKeeper)},
-			{3, SimulateMsgCompleteUnbonding(stakeKeeper)},
 			{10, SimulateMsgBeginRedelegate(mapper, stakeKeeper)},
-			{3, SimulateMsgCompleteRedelegate(stakeKeeper)},
 		}, []simulation.RandSetup{
 			Setup(mapp, stakeKeeper),
 		}, []simulation.Invariant{
--- a/x/stake/stake.go
+++ b/x/stake/stake.go
@ -11,27 +11,25 @@ import (
 )

 type (
-	Keeper                = keeper.Keeper
-	Validator             = types.Validator
-	Description           = types.Description
-	Commission            = types.Commission
-	Delegation            = types.Delegation
-	DelegationSummary     = types.DelegationSummary
-	UnbondingDelegation   = types.UnbondingDelegation
-	Redelegation          = types.Redelegation
-	Params                = types.Params
-	Pool                  = types.Pool
-	MsgCreateValidator    = types.MsgCreateValidator
-	MsgEditValidator      = types.MsgEditValidator
-	MsgDelegate           = types.MsgDelegate
-	MsgBeginUnbonding     = types.MsgBeginUnbonding
-	MsgCompleteUnbonding  = types.MsgCompleteUnbonding
-	MsgBeginRedelegate    = types.MsgBeginRedelegate
-	MsgCompleteRedelegate = types.MsgCompleteRedelegate
-	GenesisState          = types.GenesisState
-	QueryDelegatorParams  = querier.QueryDelegatorParams
-	QueryValidatorParams  = querier.QueryValidatorParams
-	QueryBondsParams      = querier.QueryBondsParams
+	Keeper               = keeper.Keeper
+	Validator            = types.Validator
+	Description          = types.Description
+	Commission           = types.Commission
+	Delegation           = types.Delegation
+	DelegationSummary    = types.DelegationSummary
+	UnbondingDelegation  = types.UnbondingDelegation
+	Redelegation         = types.Redelegation
+	Params               = types.Params
+	Pool                 = types.Pool
+	MsgCreateValidator   = types.MsgCreateValidator
+	MsgEditValidator     = types.MsgEditValidator
+	MsgDelegate          = types.MsgDelegate
+	MsgBeginUnbonding    = types.MsgBeginUnbonding
+	MsgBeginRedelegate   = types.MsgBeginRedelegate
+	GenesisState         = types.GenesisState
+	QueryDelegatorParams = querier.QueryDelegatorParams
+	QueryValidatorParams = querier.QueryValidatorParams
+	QueryBondsParams     = querier.QueryBondsParams
 )

 var (
@ -85,9 +83,7 @@ var (
 	NewMsgEditValidator             = types.NewMsgEditValidator
 	NewMsgDelegate                  = types.NewMsgDelegate
 	NewMsgBeginUnbonding            = types.NewMsgBeginUnbonding
-	NewMsgCompleteUnbonding         = types.NewMsgCompleteUnbonding
 	NewMsgBeginRedelegate           = types.NewMsgBeginRedelegate
-	NewMsgCompleteRedelegate        = types.NewMsgCompleteRedelegate

 	NewQuerier = querier.NewQuerier
 )
--- a/x/stake/tags/tags.go
+++ b/x/stake/tags/tags.go
@ -20,4 +20,5 @@ var (
 	Delegator    = sdk.TagDelegator
 	Moniker      = "moniker"
 	Identity     = "identity"
+	EndTime      = "end-time"
 )
--- a/x/stake/types/codec.go
+++ b/x/stake/types/codec.go
@ -10,9 +10,7 @@ func RegisterCodec(cdc *codec.Codec) {
 	cdc.RegisterConcrete(MsgEditValidator{}, "cosmos-sdk/MsgEditValidator", nil)
 	cdc.RegisterConcrete(MsgDelegate{}, "cosmos-sdk/MsgDelegate", nil)
 	cdc.RegisterConcrete(MsgBeginUnbonding{}, "cosmos-sdk/BeginUnbonding", nil)
-	cdc.RegisterConcrete(MsgCompleteUnbonding{}, "cosmos-sdk/CompleteUnbonding", nil)
 	cdc.RegisterConcrete(MsgBeginRedelegate{}, "cosmos-sdk/BeginRedelegate", nil)
-	cdc.RegisterConcrete(MsgCompleteRedelegate{}, "cosmos-sdk/CompleteRedelegate", nil)
 }

 // generic sealed codec to be used throughout sdk
--- a/x/stake/types/delegation.go
+++ b/x/stake/types/delegation.go
@ -9,6 +9,23 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )

+// DVPair is struct that just has a delegator-validator pair with no other data.
+// It is intended to be used as a marshalable pointer. For example, a DVPair can be used to construct the
+// key to getting an UnbondingDelegation from state.
+type DVPair struct {
+	DelegatorAddr sdk.AccAddress
+	ValidatorAddr sdk.ValAddress
+}
+
+// DVVTriplet is struct that just has a delegator-validator-validator triplet with no other data.
+// It is intended to be used as a marshalable pointer. For example, a DVVTriplet can be used to construct the
+// key to getting a Redelegation from state.
+type DVVTriplet struct {
+	DelegatorAddr    sdk.AccAddress
+	ValidatorSrcAddr sdk.ValAddress
+	ValidatorDstAddr sdk.ValAddress
+}
+
 // Delegation represents the bond with tokens held by an account.  It is
 // owned by one delegator, and is associated with the voting power of one
 // pubKey.
--- a/x/stake/types/msg.go
+++ b/x/stake/types/msg.go
@ -12,12 +12,10 @@ const MsgType = "stake"

 // Verify interface at compile time
 var _, _, _ sdk.Msg = &MsgCreateValidator{}, &MsgEditValidator{}, &MsgDelegate{}
-var _, _ sdk.Msg = &MsgBeginUnbonding{}, &MsgCompleteUnbonding{}
-var _, _ sdk.Msg = &MsgBeginRedelegate{}, &MsgCompleteRedelegate{}

 //______________________________________________________________________

-// MsgCreateValidator - struct for unbonding transactions
+// MsgCreateValidator - struct for bonding transactions
 type MsgCreateValidator struct {
 	Description
 	Commission    CommissionMsg
@ -276,51 +274,6 @@ func (msg MsgBeginRedelegate) ValidateBasic() sdk.Error {
 	return nil
 }

-// MsgDelegate - struct for bonding transactions
-type MsgCompleteRedelegate struct {
-	DelegatorAddr    sdk.AccAddress `json:"delegator_addr"`
-	ValidatorSrcAddr sdk.ValAddress `json:"validator_source_addr"`
-	ValidatorDstAddr sdk.ValAddress `json:"validator_destination_addr"`
-}
-
-func NewMsgCompleteRedelegate(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress) MsgCompleteRedelegate {
-	return MsgCompleteRedelegate{
-		DelegatorAddr:    delAddr,
-		ValidatorSrcAddr: valSrcAddr,
-		ValidatorDstAddr: valDstAddr,
-	}
-}
-
-//nolint
-func (msg MsgCompleteRedelegate) Type() string { return MsgType }
-func (msg MsgCompleteRedelegate) Name() string { return "complete_redelegate" }
-func (msg MsgCompleteRedelegate) GetSigners() []sdk.AccAddress {
-	return []sdk.AccAddress{msg.DelegatorAddr}
-}
-
-// get the bytes for the message signer to sign on
-func (msg MsgCompleteRedelegate) GetSignBytes() []byte {
-	b, err := MsgCdc.MarshalJSON(msg)
-	if err != nil {
-		panic(err)
-	}
-	return sdk.MustSortJSON(b)
-}
-
-// quick validity check
-func (msg MsgCompleteRedelegate) ValidateBasic() sdk.Error {
-	if msg.DelegatorAddr == nil {
-		return ErrNilDelegatorAddr(DefaultCodespace)
-	}
-	if msg.ValidatorSrcAddr == nil {
-		return ErrNilValidatorAddr(DefaultCodespace)
-	}
-	if msg.ValidatorDstAddr == nil {
-		return ErrNilValidatorAddr(DefaultCodespace)
-	}
-	return nil
-}
-
 //______________________________________________________________________

 // MsgBeginUnbonding - struct for unbonding transactions
@ -373,43 +326,3 @@ func (msg MsgBeginUnbonding) ValidateBasic() sdk.Error {
 	}
 	return nil
 }
-
-// MsgCompleteUnbonding - struct for unbonding transactions
-type MsgCompleteUnbonding struct {
-	DelegatorAddr sdk.AccAddress `json:"delegator_addr"`
-	ValidatorAddr sdk.ValAddress `json:"validator_addr"`
-}
-
-func NewMsgCompleteUnbonding(delAddr sdk.AccAddress, valAddr sdk.ValAddress) MsgCompleteUnbonding {
-	return MsgCompleteUnbonding{
-		DelegatorAddr: delAddr,
-		ValidatorAddr: valAddr,
-	}
-}
-
-//nolint
-func (msg MsgCompleteUnbonding) Type() string { return MsgType }
-func (msg MsgCompleteUnbonding) Name() string { return "complete_unbonding" }
-func (msg MsgCompleteUnbonding) GetSigners() []sdk.AccAddress {
-	return []sdk.AccAddress{msg.DelegatorAddr}
-}
-
-// get the bytes for the message signer to sign on
-func (msg MsgCompleteUnbonding) GetSignBytes() []byte {
-	b, err := MsgCdc.MarshalJSON(msg)
-	if err != nil {
-		panic(err)
-	}
-	return sdk.MustSortJSON(b)
-}
-
-// quick validity check
-func (msg MsgCompleteUnbonding) ValidateBasic() sdk.Error {
-	if msg.DelegatorAddr == nil {
-		return ErrNilDelegatorAddr(DefaultCodespace)
-	}
-	if msg.ValidatorAddr == nil {
-		return ErrNilValidatorAddr(DefaultCodespace)
-	}
-	return nil
-}
--- a/x/stake/types/msg_test.go
+++ b/x/stake/types/msg_test.go
@ -177,31 +177,6 @@ func TestMsgBeginRedelegate(t *testing.T) {
 	}
 }

-// test ValidateBasic for MsgUnbond
-func TestMsgCompleteRedelegate(t *testing.T) {
-	tests := []struct {
-		name             string
-		delegatorAddr    sdk.AccAddress
-		validatorSrcAddr sdk.ValAddress
-		validatorDstAddr sdk.ValAddress
-		expectPass       bool
-	}{
-		{"regular", sdk.AccAddress(addr1), addr2, addr3, true},
-		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, addr3, false},
-		{"empty source validator", sdk.AccAddress(addr1), emptyAddr, addr3, false},
-		{"empty destination validator", sdk.AccAddress(addr1), addr2, emptyAddr, false},
-	}
-
-	for _, tc := range tests {
-		msg := NewMsgCompleteRedelegate(tc.delegatorAddr, tc.validatorSrcAddr, tc.validatorDstAddr)
-		if tc.expectPass {
-			require.Nil(t, msg.ValidateBasic(), "test: %v", tc.name)
-		} else {
-			require.NotNil(t, msg.ValidateBasic(), "test: %v", tc.name)
-		}
-	}
-}
-
 // test ValidateBasic for MsgUnbond
 func TestMsgBeginUnbonding(t *testing.T) {
 	tests := []struct {
@ -227,26 +202,3 @@ func TestMsgBeginUnbonding(t *testing.T) {
 		}
 	}
 }
-
-// test ValidateBasic for MsgUnbond
-func TestMsgCompleteUnbonding(t *testing.T) {
-	tests := []struct {
-		name          string
-		delegatorAddr sdk.AccAddress
-		validatorAddr sdk.ValAddress
-		expectPass    bool
-	}{
-		{"regular", sdk.AccAddress(addr1), addr2, true},
-		{"empty delegator", sdk.AccAddress(emptyAddr), addr1, false},
-		{"empty validator", sdk.AccAddress(addr1), emptyAddr, false},
-	}
-
-	for _, tc := range tests {
-		msg := NewMsgCompleteUnbonding(tc.delegatorAddr, tc.validatorAddr)
-		if tc.expectPass {
-			require.Nil(t, msg.ValidateBasic(), "test: %v", tc.name)
-		} else {
-			require.NotNil(t, msg.ValidateBasic(), "test: %v", tc.name)
-		}
-	}
-}
--- a/x/stake/types/params.go
+++ b/x/stake/types/params.go
@ -10,9 +10,17 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/params"
 )

-// defaultUnbondingTime reflects three weeks in seconds as the default
-// unbonding time.
-const defaultUnbondingTime time.Duration = 60 * 60 * 24 * 3 * time.Second
+const (
+	// defaultUnbondingTime reflects three weeks in seconds as the default
+	// unbonding time.
+	defaultUnbondingTime time.Duration = 60 * 60 * 24 * 3 * time.Second
+
+	// Delay, in blocks, between when validator updates are returned to Tendermint and when they are applied
+	// For example, if this is 0, the validator set at the end of a block will sign the next block, or
+	// if this is 1, the validator set at the end of a block will sign the block after the next.
+	// Constant as this should not change without a hard fork.
+	ValidatorUpdateDelay int64 = 1
+)

 // nolint - Keys for parameter access
 var (