Merge branch 'develop' of https://github.com/cosmos/cosmos-sdk into bianjie/lcd-lite-swagger-ui

2018-10-09 07:20:21 +08:00 · 2018-10-09 07:20:21 +08:00 · 1aebe103ba
parent 3bcbcd08b9 cd21427a7b
commit 1aebe103ba
48 changed files with 1582 additions and 595 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@ -206,6 +206,12 @@ jobs:
        - run:
            name: run localnet and exit on failure
            command: |
+              pushd /tmp
+              wget https://dl.google.com/go/go1.11.linux-amd64.tar.gz
+              sudo tar -xvf go1.11.linux-amd64.tar.gz
+              sudo rm -rf /usr/local/go
+              sudo mv go /usr/local
+              popd
              set -x
              make get_tools
              make get_vendor_deps
--- 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/PENDING.md
+++ b/PENDING.md
@ -41,6 +41,7 @@ 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/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 +69,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

@ -111,6 +122,7 @@ FEATURES
  * [x/auth] \#2376 Remove FeePayer() from StdTx
  * [x/stake] [\#1672](https://github.com/cosmos/cosmos-sdk/issues/1672) Implement
  basis for the validator commission model.
+  * [x/auth] Support account removal in the account mapper.

 * Tendermint

@ -133,8 +145,10 @@ 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

 * SDK
    * [tools] Make get_vendor_deps deletes `.vendor-new` directories, in case scratch files are present.
--- a/client/lcd/lcd_test.go
+++ b/client/lcd/lcd_test.go
@ -860,7 +860,7 @@ func doSendWithGas(t *testing.T, port, seed, name, password string, addr sdk.Acc
 	return
 }

-func doRecoverKey(t *testing.T, port, recoverName, recoverPassword, seed string)  {
+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)

--- a/cmd/gaia/app/genesis.go
+++ b/cmd/gaia/app/genesis.go
@ -13,7 +13,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/stake"
-	stakeTypes "github.com/cosmos/cosmos-sdk/x/stake/types"

 	"github.com/spf13/pflag"

@ -242,29 +241,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
@ -97,9 +97,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/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/types/context.go
+++ b/types/context.go
@ -4,6 +4,7 @@ package types
 import (
 	"context"
 	"sync"
+	"time"

 	"github.com/golang/protobuf/proto"

@ -181,6 +182,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)
 }
@ -190,7 +197,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/mapper.go
+++ b/x/auth/mapper.go
@ -83,6 +83,13 @@ func (am AccountMapper) SetAccount(ctx sdk.Context, acc Account) {
 	store.Set(AddressStoreKey(addr), bz)
 }

+// RemoveAccount removes an account for the account mapper store.
+func (am AccountMapper) RemoveAccount(ctx sdk.Context, acc Account) {
+	addr := acc.GetAddress()
+	store := ctx.KVStore(am.key)
+	store.Delete(AddressStoreKey(addr))
+}
+
 // Implements sdk.AccountMapper.
 func (am AccountMapper) IterateAccounts(ctx sdk.Context, process func(Account) (stop bool)) {
 	store := ctx.KVStore(am.key)
--- a/x/auth/mapper_test.go
+++ b/x/auth/mapper_test.go
@ -61,6 +61,44 @@ func TestAccountMapperGetSet(t *testing.T) {
 	require.Equal(t, newSequence, acc.GetSequence())
 }

+func TestAccountMapperRemoveAccount(t *testing.T) {
+	ms, capKey, _ := setupMultiStore()
+	cdc := codec.New()
+	RegisterBaseAccount(cdc)
+
+	// make context and mapper
+	ctx := sdk.NewContext(ms, abci.Header{}, false, log.NewNopLogger())
+	mapper := NewAccountMapper(cdc, capKey, ProtoBaseAccount)
+
+	addr1 := sdk.AccAddress([]byte("addr1"))
+	addr2 := sdk.AccAddress([]byte("addr2"))
+
+	// create accounts
+	acc1 := mapper.NewAccountWithAddress(ctx, addr1)
+	acc2 := mapper.NewAccountWithAddress(ctx, addr2)
+
+	accSeq1 := int64(20)
+	accSeq2 := int64(40)
+
+	acc1.SetSequence(accSeq1)
+	acc2.SetSequence(accSeq2)
+	mapper.SetAccount(ctx, acc1)
+	mapper.SetAccount(ctx, acc2)
+
+	acc1 = mapper.GetAccount(ctx, addr1)
+	require.NotNil(t, acc1)
+	require.Equal(t, accSeq1, acc1.GetSequence())
+
+	// remove one account
+	mapper.RemoveAccount(ctx, acc1)
+	acc1 = mapper.GetAccount(ctx, addr1)
+	require.Nil(t, acc1)
+
+	acc2 = mapper.GetAccount(ctx, addr2)
+	require.NotNil(t, acc2)
+	require.Equal(t, accSeq2, acc2.GetSequence())
+}
+
 func BenchmarkAccountMapperGetAccountFound(b *testing.B) {
 	ms, capKey, _ := setupMultiStore()
 	cdc := codec.New()
--- a/x/distribution/types/codec.go
+++ b/x/distribution/types/codec.go
@ -0,0 +1,23 @@
+package types
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+)
+
+// Register concrete types on codec codec
+func RegisterCodec(cdc *codec.Codec) {
+	cdc.RegisterConcrete(MsgWithdrawDelegatorRewardsAll{}, "cosmos-sdk/MsgWithdrawDelegationRewardsAll", nil)
+	cdc.RegisterConcrete(MsgWithdrawDelegatorReward{}, "cosmos-sdk/MsgWithdrawDelegationReward", nil)
+	cdc.RegisterConcrete(MsgWithdrawValidatorRewardsAll{}, "cosmos-sdk/MsgWithdrawValidatorRewardsAll", nil)
+	cdc.RegisterConcrete(MsgSetWithdrawAddress{}, "cosmos-sdk/MsgModifyWithdrawAddress", nil)
+}
+
+// generic sealed codec to be used throughout module
+var MsgCdc *codec.Codec
+
+func init() {
+	cdc := codec.New()
+	RegisterCodec(cdc)
+	codec.RegisterCrypto(cdc)
+	MsgCdc = cdc.Seal()
+}
--- a/x/distribution/types/dec_coin.go
+++ b/x/distribution/types/dec_coin.go
@ -0,0 +1,149 @@
+package types
+
+import (
+	"fmt"
+	"strings"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// Coins which can have additional decimal points
+type DecCoin struct {
+	Denom  string  `json:"denom"`
+	Amount sdk.Dec `json:"amount"`
+}
+
+func NewDecCoin(denom string, amount int64) DecCoin {
+	return DecCoin{
+		Denom:  denom,
+		Amount: sdk.NewDec(amount),
+	}
+}
+
+func NewDecCoinFromCoin(coin sdk.Coin) DecCoin {
+	return DecCoin{
+		Denom:  coin.Denom,
+		Amount: sdk.NewDecFromInt(coin.Amount),
+	}
+}
+
+// Adds amounts of two coins with same denom
+func (coin DecCoin) Plus(coinB DecCoin) DecCoin {
+	if coin.Denom != coinB.Denom {
+		panic(fmt.Sprintf("coin denom different: %v %v\n", coin.Denom, coinB.Denom))
+	}
+	return DecCoin{coin.Denom, coin.Amount.Add(coinB.Amount)}
+}
+
+// Subtracts amounts of two coins with same denom
+func (coin DecCoin) Minus(coinB DecCoin) DecCoin {
+	if coin.Denom != coinB.Denom {
+		panic(fmt.Sprintf("coin denom different: %v %v\n", coin.Denom, coinB.Denom))
+	}
+	return DecCoin{coin.Denom, coin.Amount.Sub(coinB.Amount)}
+}
+
+// return the decimal coins with trunctated decimals
+func (coin DecCoin) TruncateDecimal() sdk.Coin {
+	return sdk.NewCoin(coin.Denom, coin.Amount.TruncateInt())
+}
+
+//_______________________________________________________________________
+
+// coins with decimal
+type DecCoins []DecCoin
+
+func NewDecCoins(coins sdk.Coins) DecCoins {
+	dcs := make(DecCoins, len(coins))
+	for i, coin := range coins {
+		dcs[i] = NewDecCoinFromCoin(coin)
+	}
+	return dcs
+}
+
+// return the coins with trunctated decimals
+func (coins DecCoins) TruncateDecimal() sdk.Coins {
+	out := make(sdk.Coins, len(coins))
+	for i, coin := range coins {
+		out[i] = coin.TruncateDecimal()
+	}
+	return out
+}
+
+// Plus combines two sets of coins
+// CONTRACT: Plus will never return Coins where one Coin has a 0 amount.
+func (coins DecCoins) Plus(coinsB DecCoins) DecCoins {
+	sum := ([]DecCoin)(nil)
+	indexA, indexB := 0, 0
+	lenA, lenB := len(coins), len(coinsB)
+	for {
+		if indexA == lenA {
+			if indexB == lenB {
+				return sum
+			}
+			return append(sum, coinsB[indexB:]...)
+		} else if indexB == lenB {
+			return append(sum, coins[indexA:]...)
+		}
+		coinA, coinB := coins[indexA], coinsB[indexB]
+		switch strings.Compare(coinA.Denom, coinB.Denom) {
+		case -1:
+			sum = append(sum, coinA)
+			indexA++
+		case 0:
+			if coinA.Amount.Add(coinB.Amount).IsZero() {
+				// ignore 0 sum coin type
+			} else {
+				sum = append(sum, coinA.Plus(coinB))
+			}
+			indexA++
+			indexB++
+		case 1:
+			sum = append(sum, coinB)
+			indexB++
+		}
+	}
+}
+
+// Negative returns a set of coins with all amount negative
+func (coins DecCoins) Negative() DecCoins {
+	res := make([]DecCoin, 0, len(coins))
+	for _, coin := range coins {
+		res = append(res, DecCoin{
+			Denom:  coin.Denom,
+			Amount: coin.Amount.Neg(),
+		})
+	}
+	return res
+}
+
+// Minus subtracts a set of coins from another (adds the inverse)
+func (coins DecCoins) Minus(coinsB DecCoins) DecCoins {
+	return coins.Plus(coinsB.Negative())
+}
+
+// multiply all the coins by a decimal
+func (coins DecCoins) MulDec(d sdk.Dec) DecCoins {
+	res := make([]DecCoin, len(coins))
+	for i, coin := range coins {
+		product := DecCoin{
+			Denom:  coin.Denom,
+			Amount: coin.Amount.Mul(d),
+		}
+		res[i] = product
+	}
+	return res
+}
+
+// divide all the coins by a multiple
+func (coins DecCoins) QuoDec(d sdk.Dec) DecCoins {
+	res := make([]DecCoin, len(coins))
+	for i, coin := range coins {
+		quotient := DecCoin{
+			Denom:  coin.Denom,
+			Amount: coin.Amount.Quo(d),
+		}
+		res[i] = quotient
+	}
+	return res
+}
--- a/x/distribution/types/dec_coin_test.go
+++ b/x/distribution/types/dec_coin_test.go
@ -0,0 +1,49 @@
+package types
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPlusDecCoin(t *testing.T) {
+	decCoinA1 := DecCoin{"A", sdk.NewDecWithPrec(11, 1)}
+	decCoinA2 := DecCoin{"A", sdk.NewDecWithPrec(22, 1)}
+	decCoinB1 := DecCoin{"B", sdk.NewDecWithPrec(11, 1)}
+
+	// regular add
+	res := decCoinA1.Plus(decCoinA1)
+	require.Equal(t, decCoinA2, res, "sum of coins is incorrect")
+
+	// bad denom add
+	assert.Panics(t, func() {
+		decCoinA1.Plus(decCoinB1)
+	}, "expected panic on sum of different denoms")
+
+}
+
+func TestPlusCoins(t *testing.T) {
+	one := sdk.NewDec(1)
+	zero := sdk.NewDec(0)
+	negone := sdk.NewDec(-1)
+	two := sdk.NewDec(2)
+
+	cases := []struct {
+		inputOne DecCoins
+		inputTwo DecCoins
+		expected DecCoins
+	}{
+		{DecCoins{{"A", one}, {"B", one}}, DecCoins{{"A", one}, {"B", one}}, DecCoins{{"A", two}, {"B", two}}},
+		{DecCoins{{"A", zero}, {"B", one}}, DecCoins{{"A", zero}, {"B", zero}}, DecCoins{{"B", one}}},
+		{DecCoins{{"A", zero}, {"B", zero}}, DecCoins{{"A", zero}, {"B", zero}}, DecCoins(nil)},
+		{DecCoins{{"A", one}, {"B", zero}}, DecCoins{{"A", negone}, {"B", zero}}, DecCoins(nil)},
+		{DecCoins{{"A", negone}, {"B", zero}}, DecCoins{{"A", zero}, {"B", zero}}, DecCoins{{"A", negone}}},
+	}
+
+	for tcIndex, tc := range cases {
+		res := tc.inputOne.Plus(tc.inputTwo)
+		require.Equal(t, tc.expected, res, "sum of coins is incorrect, tc #%d", tcIndex)
+	}
+}
--- a/x/distribution/types/delegator_info.go
+++ b/x/distribution/types/delegator_info.go
@ -0,0 +1,47 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// distribution info for a delegation - used to determine entitled rewards
+type DelegatorDistInfo struct {
+	DelegatorAddr    sdk.AccAddress `json:"delegator_addr"`
+	ValOperatorAddr  sdk.ValAddress `json:"val_operator_addr"`
+	WithdrawalHeight int64          `json:"withdrawal_height"` // last time this delegation withdrew rewards
+}
+
+func NewDelegatorDistInfo(delegatorAddr sdk.AccAddress, valOperatorAddr sdk.ValAddress,
+	currentHeight int64) DelegatorDistInfo {
+
+	return DelegatorDistInfo{
+		DelegatorAddr:    delegatorAddr,
+		ValOperatorAddr:  valOperatorAddr,
+		WithdrawalHeight: currentHeight,
+	}
+}
+
+// withdraw rewards from delegator
+func (di DelegatorDistInfo) WithdrawRewards(fp FeePool, vi ValidatorDistInfo,
+	height int64, totalBonded, vdTokens, totalDelShares, delegatorShares,
+	commissionRate sdk.Dec) (DelegatorDistInfo, ValidatorDistInfo, FeePool, DecCoins) {
+
+	vi = vi.UpdateTotalDelAccum(height, totalDelShares)
+
+	if vi.DelAccum.Accum.IsZero() {
+		return di, vi, fp, DecCoins{}
+	}
+
+	vi, fp = vi.TakeFeePoolRewards(fp, height, totalBonded, vdTokens, commissionRate)
+
+	blocks := height - di.WithdrawalHeight
+	di.WithdrawalHeight = height
+	accum := delegatorShares.MulInt(sdk.NewInt(blocks))
+	withdrawalTokens := vi.Pool.MulDec(accum).QuoDec(vi.DelAccum.Accum)
+	remainingTokens := vi.Pool.Minus(withdrawalTokens)
+
+	vi.Pool = remainingTokens
+	vi.DelAccum.Accum = vi.DelAccum.Accum.Sub(accum)
+
+	return di, vi, fp, withdrawalTokens
+}
--- a/x/distribution/types/delegator_info_test.go
+++ b/x/distribution/types/delegator_info_test.go
@ -0,0 +1,56 @@
+package types
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWithdrawRewards(t *testing.T) {
+
+	// initialize
+	height := int64(0)
+	fp := InitialFeePool()
+	vi := NewValidatorDistInfo(valAddr1, height)
+	commissionRate := sdk.NewDecWithPrec(2, 2)
+	validatorTokens := sdk.NewDec(10)
+	validatorDelShares := sdk.NewDec(10)
+	totalBondedTokens := validatorTokens.Add(sdk.NewDec(90)) // validator-1 is 10% of total power
+
+	di1 := NewDelegatorDistInfo(delAddr1, valAddr1, height)
+	di1Shares := sdk.NewDec(5) // this delegator has half the shares in the validator
+
+	di2 := NewDelegatorDistInfo(delAddr2, valAddr1, height)
+	di2Shares := sdk.NewDec(5)
+
+	// simulate adding some stake for inflation
+	height = 10
+	fp.Pool = DecCoins{NewDecCoin("stake", 1000)}
+
+	// withdraw rewards
+	di1, vi, fp, rewardRecv1 := di1.WithdrawRewards(fp, vi, height, totalBondedTokens,
+		validatorTokens, validatorDelShares, di1Shares, commissionRate)
+
+	assert.Equal(t, height, di1.WithdrawalHeight)
+	assert.True(sdk.DecEq(t, sdk.NewDec(900), fp.ValAccum.Accum))
+	assert.True(sdk.DecEq(t, sdk.NewDec(900), fp.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(49), vi.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(2), vi.PoolCommission[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(49), rewardRecv1[0].Amount))
+
+	// add more blocks and inflation
+	height = 20
+	fp.Pool[0].Amount = fp.Pool[0].Amount.Add(sdk.NewDec(1000))
+
+	// withdraw rewards
+	di2, vi, fp, rewardRecv2 := di2.WithdrawRewards(fp, vi, height, totalBondedTokens,
+		validatorTokens, validatorDelShares, di2Shares, commissionRate)
+
+	assert.Equal(t, height, di2.WithdrawalHeight)
+	assert.True(sdk.DecEq(t, sdk.NewDec(1800), fp.ValAccum.Accum))
+	assert.True(sdk.DecEq(t, sdk.NewDec(1800), fp.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(49), vi.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(4), vi.PoolCommission[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(98), rewardRecv2[0].Amount))
+}
--- a/x/distribution/types/errors.go
+++ b/x/distribution/types/errors.go
@ -0,0 +1,23 @@
+// nolint
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type CodeType = sdk.CodeType
+
+const (
+	DefaultCodespace sdk.CodespaceType = 6
+	CodeInvalidInput CodeType          = 103
+)
+
+func ErrNilDelegatorAddr(codespace sdk.CodespaceType) sdk.Error {
+	return sdk.NewError(codespace, CodeInvalidInput, "delegator address is nil")
+}
+func ErrNilWithdrawAddr(codespace sdk.CodespaceType) sdk.Error {
+	return sdk.NewError(codespace, CodeInvalidInput, "withdraw address is nil")
+}
+func ErrNilValidatorAddr(codespace sdk.CodespaceType) sdk.Error {
+	return sdk.NewError(codespace, CodeInvalidInput, "validator address is nil")
+}
--- a/x/distribution/types/fee_pool.go
+++ b/x/distribution/types/fee_pool.go
@ -0,0 +1,54 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// total accumulation tracker
+type TotalAccum struct {
+	UpdateHeight int64   `json:"update_height"`
+	Accum        sdk.Dec `json:"accum"`
+}
+
+func NewTotalAccum(height int64) TotalAccum {
+	return TotalAccum{
+		UpdateHeight: height,
+		Accum:        sdk.ZeroDec(),
+	}
+}
+
+// update total validator accumulation factor for the new height
+// CONTRACT: height should be greater than the old height
+func (ta TotalAccum) UpdateForNewHeight(height int64, accumCreatedPerBlock sdk.Dec) TotalAccum {
+	blocks := height - ta.UpdateHeight
+	if blocks < 0 {
+		panic("reverse updated for new height")
+	}
+	ta.Accum = ta.Accum.Add(accumCreatedPerBlock.MulInt(sdk.NewInt(blocks)))
+	ta.UpdateHeight = height
+	return ta
+}
+
+//___________________________________________________________________________________________
+
+// global fee pool for distribution
+type FeePool struct {
+	ValAccum      TotalAccum `json:"val_accum"`      // total valdator accum held by validators
+	Pool          DecCoins   `json:"pool"`           // funds for all validators which have yet to be withdrawn
+	CommunityPool DecCoins   `json:"community_pool"` // pool for community funds yet to be spent
+}
+
+// update total validator accumulation factor
+func (f FeePool) UpdateTotalValAccum(height int64, totalBondedTokens sdk.Dec) FeePool {
+	f.ValAccum = f.ValAccum.UpdateForNewHeight(height, totalBondedTokens)
+	return f
+}
+
+// zero fee pool
+func InitialFeePool() FeePool {
+	return FeePool{
+		ValAccum:      NewTotalAccum(0),
+		Pool:          DecCoins{},
+		CommunityPool: DecCoins{},
+	}
+}
--- a/x/distribution/types/fee_pool_test.go
+++ b/x/distribution/types/fee_pool_test.go
@ -0,0 +1,30 @@
+package types
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestTotalAccumUpdateForNewHeight(t *testing.T) {
+
+	ta := NewTotalAccum(0)
+
+	ta = ta.UpdateForNewHeight(5, sdk.NewDec(3))
+	require.True(sdk.DecEq(t, sdk.NewDec(15), ta.Accum))
+
+	ta = ta.UpdateForNewHeight(8, sdk.NewDec(2))
+	require.True(sdk.DecEq(t, sdk.NewDec(21), ta.Accum))
+}
+
+func TestUpdateTotalValAccum(t *testing.T) {
+
+	fp := InitialFeePool()
+
+	fp = fp.UpdateTotalValAccum(5, sdk.NewDec(3))
+	require.True(sdk.DecEq(t, sdk.NewDec(15), fp.ValAccum.Accum))
+
+	fp = fp.UpdateTotalValAccum(8, sdk.NewDec(2))
+	require.True(sdk.DecEq(t, sdk.NewDec(21), fp.ValAccum.Accum))
+}
--- a/x/distribution/types/genesis.go
+++ b/x/distribution/types/genesis.go
@ -0,0 +1,33 @@
+package types
+
+import sdk "github.com/cosmos/cosmos-sdk/types"
+
+// the address for where distributions rewards are withdrawn to by default
+// this struct is only used at genesis to feed in default withdraw addresses
+type DelegatorWithdrawInfo struct {
+	DelegatorAddr sdk.AccAddress `json:"delegator_addr"`
+	WithdrawAddr  sdk.AccAddress `json:"withdraw_addr"`
+}
+
+// GenesisState - all distribution state that must be provided at genesis
+type GenesisState struct {
+	FeePool                FeePool                 `json:"fee_pool"`
+	ValidatorDistInfos     []ValidatorDistInfo     `json:"validator_dist_infos"`
+	DelegatorDistInfos     []DelegatorDistInfo     `json:"delegator_dist_infos"`
+	DelegatorWithdrawInfos []DelegatorWithdrawInfo `json:"delegator_withdraw_infos"`
+}
+
+func NewGenesisState(feePool FeePool, vdis []ValidatorDistInfo, ddis []DelegatorDistInfo) GenesisState {
+	return GenesisState{
+		FeePool:            feePool,
+		ValidatorDistInfos: vdis,
+		DelegatorDistInfos: ddis,
+	}
+}
+
+// get raw genesis raw message for testing
+func DefaultGenesisState() GenesisState {
+	return GenesisState{
+		FeePool: InitialFeePool(),
+	}
+}
--- a/x/distribution/types/keepers.go
+++ b/x/distribution/types/keepers.go
@ -0,0 +1,24 @@
+package types
+
+import sdk "github.com/cosmos/cosmos-sdk/types"
+
+// expected stake keeper
+type StakeKeeper interface {
+	IterateDelegations(ctx sdk.Context, delegator sdk.AccAddress,
+		fn func(index int64, delegation sdk.Delegation) (stop bool))
+	Delegation(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) sdk.Delegation
+	Validator(ctx sdk.Context, valAddr sdk.ValAddress) sdk.Validator
+	ValidatorByConsAddr(ctx sdk.Context, consAddr sdk.ConsAddress) sdk.Validator
+	TotalPower(ctx sdk.Context) sdk.Dec
+}
+
+// expected coin keeper
+type BankKeeper interface {
+	AddCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) (sdk.Coins, sdk.Tags, sdk.Error)
+}
+
+// from ante handler
+type FeeCollectionKeeper interface {
+	GetCollectedFees(ctx sdk.Context) sdk.Coins
+	ClearCollectedFees(ctx sdk.Context)
+}
--- a/x/distribution/types/msg.go
+++ b/x/distribution/types/msg.go
@ -0,0 +1,175 @@
+//nolint
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// name to identify transaction types
+const MsgType = "distr"
+
+// Verify interface at compile time
+var _, _ sdk.Msg = &MsgSetWithdrawAddress{}, &MsgWithdrawDelegatorRewardsAll{}
+var _, _ sdk.Msg = &MsgWithdrawDelegatorReward{}, &MsgWithdrawValidatorRewardsAll{}
+
+//______________________________________________________________________
+
+// msg struct for changing the withdraw address for a delegator (or validator self-delegation)
+type MsgSetWithdrawAddress struct {
+	DelegatorAddr sdk.AccAddress `json:"delegator_addr"`
+	WithdrawAddr  sdk.AccAddress `json:"delegator_addr"`
+}
+
+func NewMsgSetWithdrawAddress(delAddr, withdrawAddr sdk.AccAddress) MsgSetWithdrawAddress {
+	return MsgSetWithdrawAddress{
+		DelegatorAddr: delAddr,
+		WithdrawAddr:  withdrawAddr,
+	}
+}
+
+func (msg MsgSetWithdrawAddress) Type() string { return MsgType }
+func (msg MsgSetWithdrawAddress) Name() string { return "set_withdraw_address" }
+
+// Return address that must sign over msg.GetSignBytes()
+func (msg MsgSetWithdrawAddress) GetSigners() []sdk.AccAddress {
+	return []sdk.AccAddress{sdk.AccAddress(msg.DelegatorAddr)}
+}
+
+// get the bytes for the message signer to sign on
+func (msg MsgSetWithdrawAddress) GetSignBytes() []byte {
+	b, err := MsgCdc.MarshalJSON(msg)
+	if err != nil {
+		panic(err)
+	}
+	return sdk.MustSortJSON(b)
+}
+
+// quick validity check
+func (msg MsgSetWithdrawAddress) ValidateBasic() sdk.Error {
+	if msg.DelegatorAddr == nil {
+		return ErrNilDelegatorAddr(DefaultCodespace)
+	}
+	if msg.WithdrawAddr == nil {
+		return ErrNilWithdrawAddr(DefaultCodespace)
+	}
+	return nil
+}
+
+//______________________________________________________________________
+
+// msg struct for delegation withdraw for all of the delegator's delegations
+type MsgWithdrawDelegatorRewardsAll struct {
+	DelegatorAddr sdk.AccAddress `json:"delegator_addr"`
+}
+
+func NewMsgWithdrawDelegatorRewardsAll(delAddr sdk.AccAddress) MsgWithdrawDelegatorRewardsAll {
+	return MsgWithdrawDelegatorRewardsAll{
+		DelegatorAddr: delAddr,
+	}
+}
+
+func (msg MsgWithdrawDelegatorRewardsAll) Type() string { return MsgType }
+func (msg MsgWithdrawDelegatorRewardsAll) Name() string { return "withdraw_delegation_rewards_all" }
+
+// Return address that must sign over msg.GetSignBytes()
+func (msg MsgWithdrawDelegatorRewardsAll) GetSigners() []sdk.AccAddress {
+	return []sdk.AccAddress{sdk.AccAddress(msg.DelegatorAddr)}
+}
+
+// get the bytes for the message signer to sign on
+func (msg MsgWithdrawDelegatorRewardsAll) GetSignBytes() []byte {
+	b, err := MsgCdc.MarshalJSON(msg)
+	if err != nil {
+		panic(err)
+	}
+	return sdk.MustSortJSON(b)
+}
+
+// quick validity check
+func (msg MsgWithdrawDelegatorRewardsAll) ValidateBasic() sdk.Error {
+	if msg.DelegatorAddr == nil {
+		return ErrNilDelegatorAddr(DefaultCodespace)
+	}
+	return nil
+}
+
+//______________________________________________________________________
+
+// msg struct for delegation withdraw from a single validator
+type MsgWithdrawDelegatorReward struct {
+	DelegatorAddr sdk.AccAddress `json:"delegator_addr"`
+	ValidatorAddr sdk.ValAddress `json:"validator_addr"`
+}
+
+func NewMsgWithdrawDelegatorReward(delAddr sdk.AccAddress, valAddr sdk.ValAddress) MsgWithdrawDelegatorReward {
+	return MsgWithdrawDelegatorReward{
+		DelegatorAddr: delAddr,
+		ValidatorAddr: valAddr,
+	}
+}
+
+func (msg MsgWithdrawDelegatorReward) Type() string { return MsgType }
+func (msg MsgWithdrawDelegatorReward) Name() string { return "withdraw_delegation_reward" }
+
+// Return address that must sign over msg.GetSignBytes()
+func (msg MsgWithdrawDelegatorReward) GetSigners() []sdk.AccAddress {
+	return []sdk.AccAddress{sdk.AccAddress(msg.DelegatorAddr)}
+}
+
+// get the bytes for the message signer to sign on
+func (msg MsgWithdrawDelegatorReward) GetSignBytes() []byte {
+	b, err := MsgCdc.MarshalJSON(msg)
+	if err != nil {
+		panic(err)
+	}
+	return sdk.MustSortJSON(b)
+}
+
+// quick validity check
+func (msg MsgWithdrawDelegatorReward) ValidateBasic() sdk.Error {
+	if msg.DelegatorAddr == nil {
+		return ErrNilDelegatorAddr(DefaultCodespace)
+	}
+	if msg.ValidatorAddr == nil {
+		return ErrNilValidatorAddr(DefaultCodespace)
+	}
+	return nil
+}
+
+//______________________________________________________________________
+
+// msg struct for validator withdraw
+type MsgWithdrawValidatorRewardsAll struct {
+	ValidatorAddr sdk.ValAddress `json:"validator_addr"`
+}
+
+func NewMsgWithdrawValidatorRewardsAll(valAddr sdk.ValAddress) MsgWithdrawValidatorRewardsAll {
+	return MsgWithdrawValidatorRewardsAll{
+		ValidatorAddr: valAddr,
+	}
+}
+
+func (msg MsgWithdrawValidatorRewardsAll) Type() string { return MsgType }
+func (msg MsgWithdrawValidatorRewardsAll) Name() string { return "withdraw_validator_rewards_all" }
+
+// Return address that must sign over msg.GetSignBytes()
+func (msg MsgWithdrawValidatorRewardsAll) GetSigners() []sdk.AccAddress {
+	return []sdk.AccAddress{sdk.AccAddress(msg.ValidatorAddr.Bytes())}
+}
+
+// get the bytes for the message signer to sign on
+func (msg MsgWithdrawValidatorRewardsAll) GetSignBytes() []byte {
+	b, err := MsgCdc.MarshalJSON(msg)
+	if err != nil {
+		panic(err)
+	}
+	return sdk.MustSortJSON(b)
+}
+
+// quick validity check
+func (msg MsgWithdrawValidatorRewardsAll) ValidateBasic() sdk.Error {
+	if msg.ValidatorAddr == nil {
+		return ErrNilValidatorAddr(DefaultCodespace)
+	}
+	return nil
+}
--- a/x/distribution/types/msg_test.go
+++ b/x/distribution/types/msg_test.go
@ -0,0 +1,93 @@
+package types
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// test ValidateBasic for MsgCreateValidator
+func TestMsgSetWithdrawAddress(t *testing.T) {
+	tests := []struct {
+		delegatorAddr sdk.AccAddress
+		withdrawAddr  sdk.AccAddress
+		expectPass    bool
+	}{
+		{delAddr1, delAddr2, true},
+		{delAddr1, delAddr1, true},
+		{emptyDelAddr, delAddr1, false},
+		{delAddr1, emptyDelAddr, false},
+		{emptyDelAddr, emptyDelAddr, false},
+	}
+
+	for i, tc := range tests {
+		msg := NewMsgSetWithdrawAddress(tc.delegatorAddr, tc.withdrawAddr)
+		if tc.expectPass {
+			require.Nil(t, msg.ValidateBasic(), "test index: %v", i)
+		} else {
+			require.NotNil(t, msg.ValidateBasic(), "test index: %v", i)
+		}
+	}
+}
+
+// test ValidateBasic for MsgEditValidator
+func TestMsgWithdrawDelegatorReward(t *testing.T) {
+	tests := []struct {
+		delegatorAddr sdk.AccAddress
+		validatorAddr sdk.ValAddress
+		expectPass    bool
+	}{
+		{delAddr1, valAddr1, true},
+		{emptyDelAddr, valAddr1, false},
+		{delAddr1, emptyValAddr, false},
+		{emptyDelAddr, emptyValAddr, false},
+	}
+	for i, tc := range tests {
+		msg := NewMsgWithdrawDelegatorReward(tc.delegatorAddr, tc.validatorAddr)
+		if tc.expectPass {
+			require.Nil(t, msg.ValidateBasic(), "test index: %v", i)
+		} else {
+			require.NotNil(t, msg.ValidateBasic(), "test index: %v", i)
+		}
+	}
+}
+
+// test ValidateBasic and GetSigners for MsgCreateValidatorOnBehalfOf
+func TestMsgWithdrawDelegatorRewardsAll(t *testing.T) {
+	tests := []struct {
+		delegatorAddr sdk.AccAddress
+		expectPass    bool
+	}{
+		{delAddr1, true},
+		{emptyDelAddr, false},
+	}
+	for i, tc := range tests {
+		msg := NewMsgWithdrawDelegatorRewardsAll(tc.delegatorAddr)
+		if tc.expectPass {
+			require.Nil(t, msg.ValidateBasic(), "test index: %v", i)
+		} else {
+			require.NotNil(t, msg.ValidateBasic(), "test index: %v", i)
+		}
+	}
+}
+
+// test ValidateBasic for MsgDelegate
+func TestMsgWithdrawValidatorRewardsAll(t *testing.T) {
+	tests := []struct {
+		validatorAddr sdk.ValAddress
+		expectPass    bool
+	}{
+		{valAddr1, true},
+		{emptyValAddr, false},
+	}
+	for i, tc := range tests {
+		msg := NewMsgWithdrawValidatorRewardsAll(tc.validatorAddr)
+		if tc.expectPass {
+			require.Nil(t, msg.ValidateBasic(), "test index: %v", i)
+		} else {
+			require.NotNil(t, msg.ValidateBasic(), "test index: %v", i)
+		}
+	}
+}
--- a/x/distribution/types/test_utils.go
+++ b/x/distribution/types/test_utils.go
@ -0,0 +1,27 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/crypto/ed25519"
+)
+
+var (
+	delPk1       = ed25519.GenPrivKey().PubKey()
+	delPk2       = ed25519.GenPrivKey().PubKey()
+	delPk3       = ed25519.GenPrivKey().PubKey()
+	delAddr1     = sdk.AccAddress(delPk1.Address())
+	delAddr2     = sdk.AccAddress(delPk2.Address())
+	delAddr3     = sdk.AccAddress(delPk3.Address())
+	emptyDelAddr sdk.AccAddress
+
+	valPk1       = ed25519.GenPrivKey().PubKey()
+	valPk2       = ed25519.GenPrivKey().PubKey()
+	valPk3       = ed25519.GenPrivKey().PubKey()
+	valAddr1     = sdk.ValAddress(delPk1.Address())
+	valAddr2     = sdk.ValAddress(delPk2.Address())
+	valAddr3     = sdk.ValAddress(delPk3.Address())
+	emptyValAddr sdk.ValAddress
+
+	emptyPubkey crypto.PubKey
+)
--- a/x/distribution/types/validator_info.go
+++ b/x/distribution/types/validator_info.go
@ -0,0 +1,72 @@
+package types
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// distribution info for a particular validator
+type ValidatorDistInfo struct {
+	OperatorAddr sdk.ValAddress `json:"operator_addr"`
+
+	FeePoolWithdrawalHeight int64    `json:"global_withdrawal_height"` // last height this validator withdrew from the global pool
+	Pool                    DecCoins `json:"pool"`                     // rewards owed to delegators, commission has already been charged (includes proposer reward)
+	PoolCommission          DecCoins `json:"pool_commission"`          // commission collected by this validator (pending withdrawal)
+
+	DelAccum TotalAccum `json:"del_accum"` // total proposer pool accumulation factor held by delegators
+}
+
+func NewValidatorDistInfo(operatorAddr sdk.ValAddress, currentHeight int64) ValidatorDistInfo {
+	return ValidatorDistInfo{
+		OperatorAddr:            operatorAddr,
+		FeePoolWithdrawalHeight: currentHeight,
+		Pool:           DecCoins{},
+		PoolCommission: DecCoins{},
+		DelAccum:       NewTotalAccum(currentHeight),
+	}
+}
+
+// update total delegator accumululation
+func (vi ValidatorDistInfo) UpdateTotalDelAccum(height int64, totalDelShares sdk.Dec) ValidatorDistInfo {
+	vi.DelAccum = vi.DelAccum.UpdateForNewHeight(height, totalDelShares)
+	return vi
+}
+
+// move any available accumulated fees in the FeePool to the validator's pool
+func (vi ValidatorDistInfo) TakeFeePoolRewards(fp FeePool, height int64, totalBonded, vdTokens,
+	commissionRate sdk.Dec) (ValidatorDistInfo, FeePool) {
+
+	fp = fp.UpdateTotalValAccum(height, totalBonded)
+
+	if fp.ValAccum.Accum.IsZero() {
+		return vi, fp
+	}
+
+	// update the validators pool
+	blocks := height - vi.FeePoolWithdrawalHeight
+	vi.FeePoolWithdrawalHeight = height
+	accum := vdTokens.MulInt(sdk.NewInt(blocks))
+	withdrawalTokens := fp.Pool.MulDec(accum).QuoDec(fp.ValAccum.Accum)
+	remainingTokens := fp.Pool.Minus(withdrawalTokens)
+
+	commission := withdrawalTokens.MulDec(commissionRate)
+	afterCommission := withdrawalTokens.Minus(commission)
+
+	fp.ValAccum.Accum = fp.ValAccum.Accum.Sub(accum)
+	fp.Pool = remainingTokens
+	vi.PoolCommission = vi.PoolCommission.Plus(commission)
+	vi.Pool = vi.Pool.Plus(afterCommission)
+
+	return vi, fp
+}
+
+// withdraw commission rewards
+func (vi ValidatorDistInfo) WithdrawCommission(fp FeePool, height int64,
+	totalBonded, vdTokens, commissionRate sdk.Dec) (vio ValidatorDistInfo, fpo FeePool, withdrawn DecCoins) {
+
+	vi, fp = vi.TakeFeePoolRewards(fp, height, totalBonded, vdTokens, commissionRate)
+
+	withdrawalTokens := vi.PoolCommission
+	vi.PoolCommission = DecCoins{} // zero
+
+	return vi, fp, withdrawalTokens
+}
--- a/x/distribution/types/validator_info_test.go
+++ b/x/distribution/types/validator_info_test.go
@ -0,0 +1,85 @@
+package types
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestTakeFeePoolRewards(t *testing.T) {
+
+	// initialize
+	height := int64(0)
+	fp := InitialFeePool()
+	vi1 := NewValidatorDistInfo(valAddr1, height)
+	vi2 := NewValidatorDistInfo(valAddr2, height)
+	vi3 := NewValidatorDistInfo(valAddr3, height)
+	commissionRate1 := sdk.NewDecWithPrec(2, 2)
+	commissionRate2 := sdk.NewDecWithPrec(3, 2)
+	commissionRate3 := sdk.NewDecWithPrec(4, 2)
+	validatorTokens1 := sdk.NewDec(10)
+	validatorTokens2 := sdk.NewDec(40)
+	validatorTokens3 := sdk.NewDec(50)
+	totalBondedTokens := validatorTokens1.Add(validatorTokens2).Add(validatorTokens3)
+
+	// simulate adding some stake for inflation
+	height = 10
+	fp.Pool = DecCoins{NewDecCoin("stake", 1000)}
+
+	vi1, fp = vi1.TakeFeePoolRewards(fp, height, totalBondedTokens, validatorTokens1, commissionRate1)
+	require.True(sdk.DecEq(t, sdk.NewDec(900), fp.ValAccum.Accum))
+	assert.True(sdk.DecEq(t, sdk.NewDec(900), fp.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(100-2), vi1.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(2), vi1.PoolCommission[0].Amount))
+
+	vi2, fp = vi2.TakeFeePoolRewards(fp, height, totalBondedTokens, validatorTokens2, commissionRate2)
+	require.True(sdk.DecEq(t, sdk.NewDec(500), fp.ValAccum.Accum))
+	assert.True(sdk.DecEq(t, sdk.NewDec(500), fp.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(400-12), vi2.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, vi2.PoolCommission[0].Amount, sdk.NewDec(12)))
+
+	// add more blocks and inflation
+	height = 20
+	fp.Pool[0].Amount = fp.Pool[0].Amount.Add(sdk.NewDec(1000))
+
+	vi3, fp = vi3.TakeFeePoolRewards(fp, height, totalBondedTokens, validatorTokens3, commissionRate3)
+	require.True(sdk.DecEq(t, sdk.NewDec(500), fp.ValAccum.Accum))
+	assert.True(sdk.DecEq(t, sdk.NewDec(500), fp.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(1000-40), vi3.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, vi3.PoolCommission[0].Amount, sdk.NewDec(40)))
+}
+
+func TestWithdrawCommission(t *testing.T) {
+
+	// initialize
+	height := int64(0)
+	fp := InitialFeePool()
+	vi := NewValidatorDistInfo(valAddr1, height)
+	commissionRate := sdk.NewDecWithPrec(2, 2)
+	validatorTokens := sdk.NewDec(10)
+	totalBondedTokens := validatorTokens.Add(sdk.NewDec(90)) // validator-1 is 10% of total power
+
+	// simulate adding some stake for inflation
+	height = 10
+	fp.Pool = DecCoins{NewDecCoin("stake", 1000)}
+
+	// for a more fun staring condition, have an non-withdraw update
+	vi, fp = vi.TakeFeePoolRewards(fp, height, totalBondedTokens, validatorTokens, commissionRate)
+	require.True(sdk.DecEq(t, sdk.NewDec(900), fp.ValAccum.Accum))
+	assert.True(sdk.DecEq(t, sdk.NewDec(900), fp.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(100-2), vi.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(2), vi.PoolCommission[0].Amount))
+
+	// add more blocks and inflation
+	height = 20
+	fp.Pool[0].Amount = fp.Pool[0].Amount.Add(sdk.NewDec(1000))
+
+	vi, fp, commissionRecv := vi.WithdrawCommission(fp, height, totalBondedTokens, validatorTokens, commissionRate)
+	require.True(sdk.DecEq(t, sdk.NewDec(1800), fp.ValAccum.Accum))
+	assert.True(sdk.DecEq(t, sdk.NewDec(1800), fp.Pool[0].Amount))
+	assert.True(sdk.DecEq(t, sdk.NewDec(200-4), vi.Pool[0].Amount))
+	assert.Zero(t, len(vi.PoolCommission))
+	assert.True(sdk.DecEq(t, sdk.NewDec(4), commissionRecv[0].Amount))
+}
--- 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/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"

@ -75,3 +77,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, params types.Params, valSrcAddr sd
 	minTime time.Time, height int64, completeNow bool) {

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

@ -362,31 +465,32 @@ func (k Keeper) getBeginInfo(ctx sdk.Context, params types.Params, valSrcAddr sd

 // 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
 	params := k.GetParams(ctx)
 	minTime, height, completeNow := k.getBeginInfo(ctx, params, valAddr)
+
+	returnAmount, err := k.unbond(ctx, delAddr, valAddr, sharesAmount)
+	if err != nil {
+		return types.UnbondingDelegation{}, err
+	}
+
 	balance := sdk.NewCoin(params.BondDenom, 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{
@ -398,10 +502,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)
@ -409,12 +515,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
@ -425,34 +525,34 @@ 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
 	}

 	params := k.GetParams(ctx)
 	returnCoin := sdk.NewCoin(params.BondDenom, 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, params, valSrcAddr)

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

 	red := types.Redelegation{
@ -467,7 +567,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"
@ -25,6 +26,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
@ -134,6 +137,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
@ -177,31 +186,37 @@ func GetREDByValDstIndexKey(delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.V
 	return key
 }

-// rearranges the ValSrcIndexKey to get the REDKey
-func GetREDKeyFromValSrcIndexKey(IndexKey []byte) []byte {
-	addrs := IndexKey[1:] // remove prefix bytes
-	if len(addrs) != 3*sdk.AddrLen {
+// GetREDKeyFromValSrcIndexKey rearranges the ValSrcIndexKey to get the REDKey
+func GetREDKeyFromValSrcIndexKey(indexKey []byte) []byte {
+	// note that first byte is prefix byte
+	if len(indexKey) != 3*sdk.AddrLen+1 {
 		panic("unexpected key length")
 	}
-	valSrcAddr := addrs[:sdk.AddrLen]
-	delAddr := addrs[sdk.AddrLen : 2*sdk.AddrLen]
-	valDstAddr := addrs[2*sdk.AddrLen:]
+	valSrcAddr := indexKey[1 : sdk.AddrLen+1]
+	delAddr := indexKey[sdk.AddrLen+1 : 2*sdk.AddrLen+1]
+	valDstAddr := indexKey[2*sdk.AddrLen+1 : 3*sdk.AddrLen+1]

 	return GetREDKey(delAddr, valSrcAddr, valDstAddr)
 }

-// rearranges the ValDstIndexKey to get the REDKey
-func GetREDKeyFromValDstIndexKey(IndexKey []byte) []byte {
-	addrs := IndexKey[1:] // remove prefix bytes
-	if len(addrs) != 3*sdk.AddrLen {
+// GetREDKeyFromValDstIndexKey rearranges the ValDstIndexKey to get the REDKey
+func GetREDKeyFromValDstIndexKey(indexKey []byte) []byte {
+	// note that first byte is prefix byte
+	if len(indexKey) != 3*sdk.AddrLen+1 {
 		panic("unexpected key length")
 	}
-	valDstAddr := addrs[:sdk.AddrLen]
-	delAddr := addrs[sdk.AddrLen : 2*sdk.AddrLen]
-	valSrcAddr := addrs[2*sdk.AddrLen:]
+	valDstAddr := indexKey[1 : sdk.AddrLen+1]
+	delAddr := indexKey[sdk.AddrLen+1 : 2*sdk.AddrLen+1]
+	valSrcAddr := indexKey[2*sdk.AddrLen+1 : 3*sdk.AddrLen+1]
 	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/key_test.go
+++ b/x/stake/keeper/key_test.go
@ -2,30 +2,43 @@ package keeper

 import (
 	"encoding/hex"
+	"math/big"
 	"testing"

-	"github.com/stretchr/testify/assert"
-
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/stake/types"
+	"github.com/stretchr/testify/assert"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 )

 var (
-	pk1 = ed25519.GenPrivKey().PubKey()
+	pk1   = ed25519.GenPrivKeyFromSecret([]byte{1}).PubKey()
+	pk2   = ed25519.GenPrivKeyFromSecret([]byte{2}).PubKey()
+	pk3   = ed25519.GenPrivKeyFromSecret([]byte{3}).PubKey()
+	addr1 = pk1.Address()
+	addr2 = pk2.Address()
+	addr3 = pk3.Address()
 )

 func TestGetValidatorPowerRank(t *testing.T) {
-	valAddr1 := sdk.ValAddress(pk1.Bytes())
+	valAddr1 := sdk.ValAddress(addr1)
 	emptyDesc := types.Description{}
 	val1 := types.NewValidator(valAddr1, pk1, emptyDesc)
-	val1.Tokens = sdk.NewDec(12)
+	val1.Tokens = sdk.NewDec(0)
+	val2, val3, val4 := val1, val1, val1
+	val2.Tokens = sdk.NewDec(1)
+	val3.Tokens = sdk.NewDec(10)
+	x := new(big.Int).Exp(big.NewInt(2), big.NewInt(40), big.NewInt(0))
+	val4.Tokens = sdk.NewDecFromBigInt(x)

 	tests := []struct {
 		validator types.Validator
 		wantHex   string
 	}{
-		{val1, "05303030303030303030303132ffffffffffffffffffff"},
+		{val1, "05303030303030303030303030ffffffffffffffffffff"},
+		{val2, "05303030303030303030303031ffffffffffffffffffff"},
+		{val3, "05303030303030303030303130ffffffffffffffffffff"},
+		{val4, "0531303939353131363237373736ffffffffffffffffffff"},
 	}
 	for i, tt := range tests {
 		got := hex.EncodeToString(getValidatorPowerRank(tt.validator))
@ -33,3 +46,45 @@ func TestGetValidatorPowerRank(t *testing.T) {
 		assert.Equal(t, tt.wantHex, got, "Keys did not match on test case %d", i)
 	}
 }
+
+func TestGetREDByValDstIndexKey(t *testing.T) {
+	tests := []struct {
+		delAddr    sdk.AccAddress
+		valSrcAddr sdk.ValAddress
+		valDstAddr sdk.ValAddress
+		wantHex    string
+	}{
+		{sdk.AccAddress(addr1), sdk.ValAddress(addr1), sdk.ValAddress(addr1),
+			"0c63d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f08609"},
+		{sdk.AccAddress(addr1), sdk.ValAddress(addr2), sdk.ValAddress(addr3),
+			"0c3ab62f0d93849be495e21e3e9013a517038f45bd63d771218209d8bd03c482f69dfba57310f086095ef3b5f25c54946d4a89fc0d09d2f126614540f2"},
+		{sdk.AccAddress(addr2), sdk.ValAddress(addr1), sdk.ValAddress(addr3),
+			"0c3ab62f0d93849be495e21e3e9013a517038f45bd5ef3b5f25c54946d4a89fc0d09d2f126614540f263d771218209d8bd03c482f69dfba57310f08609"},
+	}
+	for i, tt := range tests {
+		got := hex.EncodeToString(GetREDByValDstIndexKey(tt.delAddr, tt.valSrcAddr, tt.valDstAddr))
+
+		assert.Equal(t, tt.wantHex, got, "Keys did not match on test case %d", i)
+	}
+}
+
+func TestGetREDByValSrcIndexKey(t *testing.T) {
+	tests := []struct {
+		delAddr    sdk.AccAddress
+		valSrcAddr sdk.ValAddress
+		valDstAddr sdk.ValAddress
+		wantHex    string
+	}{
+		{sdk.AccAddress(addr1), sdk.ValAddress(addr1), sdk.ValAddress(addr1),
+			"0b63d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f0860963d771218209d8bd03c482f69dfba57310f08609"},
+		{sdk.AccAddress(addr1), sdk.ValAddress(addr2), sdk.ValAddress(addr3),
+			"0b5ef3b5f25c54946d4a89fc0d09d2f126614540f263d771218209d8bd03c482f69dfba57310f086093ab62f0d93849be495e21e3e9013a517038f45bd"},
+		{sdk.AccAddress(addr2), sdk.ValAddress(addr1), sdk.ValAddress(addr3),
+			"0b63d771218209d8bd03c482f69dfba57310f086095ef3b5f25c54946d4a89fc0d09d2f126614540f23ab62f0d93849be495e21e3e9013a517038f45bd"},
+	}
+	for i, tt := range tests {
+		got := hex.EncodeToString(GetREDByValSrcIndexKey(tt.delAddr, tt.valSrcAddr, tt.valDstAddr))
+
+		assert.Equal(t, tt.wantHex, got, "Keys did not match on test case %d", i)
+	}
+}
--- a/x/stake/keeper/test_common.go
+++ b/x/stake/keeper/test_common.go
@ -62,9 +62,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
@ -49,9 +49,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
@ -9,27 +9,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 (
@ -76,9 +74,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)
-		}
-	}
-}