diff --git a/cmd/gaia/app/app_test.go b/cmd/gaia/app/app_test.go
index 9524f598f..39f56bb60 100644
--- a/cmd/gaia/app/app_test.go
+++ b/cmd/gaia/app/app_test.go
@@ -409,7 +409,7 @@ func TestStakeMsgs(t *testing.T) {
 	require.True(t, found)
 	require.Equal(t, addr1, validator.Address)
 	require.Equal(t, sdk.Bonded, validator.Status)
-	require.True(sdk.RatEq(t, sdk.NewRat(10), validator.BondedShares))
+	require.True(sdk.RatEq(t, sdk.NewRat(10), validator.PShares.Bonded()))
 
 	// check the bond that should have been created as well
 	bond, found := gapp.stakeKeeper.GetDelegation(ctxDeliver, addr1, addr1)
diff --git a/x/stake/handler.go b/x/stake/handler.go
index 5d6c44b1f..cf88fcc5e 100644
--- a/x/stake/handler.go
+++ b/x/stake/handler.go
@@ -118,38 +118,26 @@ func handleMsgEditCandidacy(ctx sdk.Context, msg MsgEditCandidacy, k Keeper) sdk
 }
 
 func handleMsgDelegate(ctx sdk.Context, msg MsgDelegate, k Keeper) sdk.Result {
-	fmt.Println("wackydebugoutput handleMsgDelegate 0")
 
 	validator, found := k.GetValidator(ctx, msg.ValidatorAddr)
 	if !found {
-		fmt.Println("wackydebugoutput handleMsgDelegate 1")
 		return ErrBadValidatorAddr(k.codespace).Result()
 	}
-	fmt.Println("wackydebugoutput handleMsgDelegate 2")
 	if msg.Bond.Denom != k.GetParams(ctx).BondDenom {
-		fmt.Println("wackydebugoutput handleMsgDelegate 3")
 		return ErrBadBondingDenom(k.codespace).Result()
 	}
-	fmt.Println("wackydebugoutput handleMsgDelegate 4")
 	if validator.Status == sdk.Revoked {
-		fmt.Println("wackydebugoutput handleMsgDelegate 5")
 		return ErrValidatorRevoked(k.codespace).Result()
 	}
-	fmt.Println("wackydebugoutput handleMsgDelegate 6")
 	if ctx.IsCheckTx() {
-		fmt.Println("wackydebugoutput handleMsgDelegate 7")
 		return sdk.Result{
 			GasUsed: GasDelegate,
 		}
-		fmt.Println("wackydebugoutput handleMsgDelegate 9")
 	}
-	fmt.Println("wackydebugoutput handleMsgDelegate 10")
 	tags, err := delegate(ctx, k, msg.DelegatorAddr, msg.Bond, validator)
 	if err != nil {
-		fmt.Println("wackydebugoutput handleMsgDelegate 11")
 		return err.Result()
 	}
-	fmt.Println("wackydebugoutput handleMsgDelegate 12")
 	return sdk.Result{
 		Tags: tags,
 	}
@@ -158,30 +146,23 @@ func handleMsgDelegate(ctx sdk.Context, msg MsgDelegate, k Keeper) sdk.Result {
 // common functionality between handlers
 func delegate(ctx sdk.Context, k Keeper, delegatorAddr sdk.Address,
 	bondAmt sdk.Coin, validator Validator) (sdk.Tags, sdk.Error) {
-	fmt.Println("wackydebugoutput delegate 0")
 
 	// Get or create the delegator bond
 	bond, found := k.GetDelegation(ctx, delegatorAddr, validator.Address)
 	if !found {
-		fmt.Println("wackydebugoutput delegate 1")
 		bond = Delegation{
 			DelegatorAddr: delegatorAddr,
 			ValidatorAddr: validator.Address,
 			Shares:        sdk.ZeroRat(),
 		}
-		fmt.Println("wackydebugoutput delegate 3")
 	}
-	fmt.Println("wackydebugoutput delegate 4")
 
 	// Account new shares, save
 	pool := k.GetPool(ctx)
 	_, _, err := k.coinKeeper.SubtractCoins(ctx, bond.DelegatorAddr, sdk.Coins{bondAmt})
-	fmt.Println("wackydebugoutput delegate 5")
 	if err != nil {
-		fmt.Println("wackydebugoutput delegate 6")
 		return nil, err
 	}
-	fmt.Println("wackydebugoutput delegate 7")
 	validator, pool, newShares := validator.addTokensFromDel(pool, bondAmt.Amount)
 	fmt.Printf("debug newShares: %v\n", newShares)
 	bond.Shares = bond.Shares.Add(newShares)
diff --git a/x/stake/handler_test.go b/x/stake/handler_test.go
index 4e3db669d..a88cf220d 100644
--- a/x/stake/handler_test.go
+++ b/x/stake/handler_test.go
@@ -47,7 +47,7 @@ func TestDuplicatesMsgDeclareCandidacy(t *testing.T) {
 	assert.Equal(t, sdk.Bonded, validator.Status)
 	assert.Equal(t, validatorAddr, validator.Address)
 	assert.Equal(t, pk, validator.PubKey)
-	assert.Equal(t, sdk.NewRat(10), validator.BondedShares)
+	assert.Equal(t, sdk.NewRat(10), validator.PShares.Bonded())
 	assert.Equal(t, sdk.NewRat(10), validator.DelegatorShares)
 	assert.Equal(t, Description{}, validator.Description)
 
@@ -74,7 +74,7 @@ func TestIncrementsMsgDelegate(t *testing.T) {
 	require.True(t, found)
 	require.Equal(t, sdk.Bonded, validator.Status)
 	assert.Equal(t, bondAmount, validator.DelegatorShares.Evaluate())
-	assert.Equal(t, bondAmount, validator.BondedShares.Evaluate(), "validator: %v", validator)
+	assert.Equal(t, bondAmount, validator.PShares.Bonded().Evaluate(), "validator: %v", validator)
 
 	_, found = keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
 	require.False(t, found)
@@ -150,7 +150,7 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 	validator, found := keeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
 	assert.Equal(t, initBond*2, validator.DelegatorShares.Evaluate())
-	assert.Equal(t, initBond*2, validator.BondedShares.Evaluate())
+	assert.Equal(t, initBond*2, validator.PShares.Bonded().Evaluate())
 
 	// just send the same msgUnbond multiple times
 	// TODO use decimals here
diff --git a/x/stake/keeper_test.go b/x/stake/keeper_test.go
index dc21abc7f..fa3321fc0 100644
--- a/x/stake/keeper_test.go
+++ b/x/stake/keeper_test.go
@@ -31,7 +31,7 @@ func TestSetValidator(t *testing.T) {
 	validator := NewValidator(addrVals[0], pks[0], Description{})
 	validator, pool, _ = validator.addTokensFromDel(pool, 10)
 	require.Equal(t, sdk.Unbonded, validator.Status)
-	assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.UnbondedShares))
+	assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.PShares.Unbonded()))
 	assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.DelegatorShares))
 	keeper.setPool(ctx, pool)
 	keeper.setValidator(ctx, validator)
@@ -39,7 +39,7 @@ func TestSetValidator(t *testing.T) {
 	validator, found := keeper.GetValidator(ctx, addrVals[0])
 	require.True(t, found)
 	require.Equal(t, sdk.Bonded, validator.Status)
-	assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.BondedShares))
+	assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.PShares.Bonded()))
 	assert.True(sdk.RatEq(t, sdk.NewRat(10), validator.DelegatorShares))
 
 }
@@ -75,7 +75,7 @@ func TestValidatorBasics(t *testing.T) {
 	assert.True(ValEq(t, validators[0], resVals[0]))
 
 	// modify a records, save, and retrieve
-	validators[0].BondedShares = sdk.NewRat(10)
+	validators[0].PShares = NewBondedShares(sdk.NewRat(10))
 	validators[0].DelegatorShares = sdk.NewRat(10)
 	keeper.setValidator(ctx, validators[0])
 	resVal, found = keeper.GetValidator(ctx, addrVals[0])
@@ -118,7 +118,7 @@ func GetValidatorSortingUnmixed(t *testing.T) {
 	var validators [5]Validator
 	for i, amt := range amts {
 		validators[i] = NewValidator(addrs[i], pks[i], Description{})
-		validators[i].BondedShares = sdk.NewRat(amt)
+		validators[i].PShares = NewBondedShares(sdk.NewRat(amt))
 		validators[i].DelegatorShares = sdk.NewRat(amt)
 		keeper.setValidator(ctx, validators[i])
 	}
@@ -126,11 +126,11 @@ func GetValidatorSortingUnmixed(t *testing.T) {
 	// first make sure everything made it in to the gotValidator group
 	gotValidators := keeper.GetValidatorsBondedByPower(ctx)
 	require.Equal(t, n, len(gotValidators))
-	assert.Equal(t, sdk.NewRat(400), gotValidators[0].BondedShares, "%v", gotValidators)
-	assert.Equal(t, sdk.NewRat(200), gotValidators[1].BondedShares, "%v", gotValidators)
-	assert.Equal(t, sdk.NewRat(100), gotValidators[2].BondedShares, "%v", gotValidators)
-	assert.Equal(t, sdk.NewRat(1), gotValidators[3].BondedShares, "%v", gotValidators)
-	assert.Equal(t, sdk.NewRat(0), gotValidators[4].BondedShares, "%v", gotValidators)
+	assert.Equal(t, sdk.NewRat(400), gotValidators[0].PShares.Bonded(), "%v", gotValidators)
+	assert.Equal(t, sdk.NewRat(200), gotValidators[1].PShares.Bonded(), "%v", gotValidators)
+	assert.Equal(t, sdk.NewRat(100), gotValidators[2].PShares.Bonded(), "%v", gotValidators)
+	assert.Equal(t, sdk.NewRat(1), gotValidators[3].PShares.Bonded(), "%v", gotValidators)
+	assert.Equal(t, sdk.NewRat(0), gotValidators[4].PShares.Bonded(), "%v", gotValidators)
 	assert.Equal(t, validators[3].Address, gotValidators[0].Address, "%v", gotValidators)
 	assert.Equal(t, validators[4].Address, gotValidators[1].Address, "%v", gotValidators)
 	assert.Equal(t, validators[1].Address, gotValidators[2].Address, "%v", gotValidators)
@@ -138,14 +138,14 @@ func GetValidatorSortingUnmixed(t *testing.T) {
 	assert.Equal(t, validators[0].Address, gotValidators[4].Address, "%v", gotValidators)
 
 	// test a basic increase in voting power
-	validators[3].BondedShares = sdk.NewRat(500)
+	validators[3].PShares = NewBondedShares(sdk.NewRat(500))
 	keeper.setValidator(ctx, validators[3])
 	gotValidators = keeper.GetValidatorsBondedByPower(ctx)
 	require.Equal(t, len(gotValidators), n)
 	assert.True(ValEq(t, validators[3], gotValidators[0]))
 
 	// test a decrease in voting power
-	validators[3].BondedShares = sdk.NewRat(300)
+	validators[3].PShares = NewBondedShares(sdk.NewRat(300))
 	keeper.setValidator(ctx, validators[3])
 	gotValidators = keeper.GetValidatorsBondedByPower(ctx)
 	require.Equal(t, len(gotValidators), n)
@@ -153,7 +153,7 @@ func GetValidatorSortingUnmixed(t *testing.T) {
 	assert.True(ValEq(t, validators[4], gotValidators[1]))
 
 	// test equal voting power, different age
-	validators[3].BondedShares = sdk.NewRat(200)
+	validators[3].PShares = NewBondedShares(sdk.NewRat(200))
 	ctx = ctx.WithBlockHeight(10)
 	keeper.setValidator(ctx, validators[3])
 	gotValidators = keeper.GetValidatorsBondedByPower(ctx)
@@ -172,8 +172,8 @@ func GetValidatorSortingUnmixed(t *testing.T) {
 	assert.True(ValEq(t, validators[4], gotValidators[1]))
 
 	// change in voting power of both validators, both still in v-set, no age change
-	validators[3].BondedShares = sdk.NewRat(300)
-	validators[4].BondedShares = sdk.NewRat(300)
+	validators[3].PShares = NewBondedShares(sdk.NewRat(300))
+	validators[4].PShares = NewBondedShares(sdk.NewRat(300))
 	keeper.setValidator(ctx, validators[3])
 	gotValidators = keeper.GetValidatorsBondedByPower(ctx)
 	require.Equal(t, len(gotValidators), n)
@@ -202,11 +202,11 @@ func GetValidatorSortingMixed(t *testing.T) {
 		validators[i] = NewValidator(addrs[i], pks[i], Description{})
 		validators[i].DelegatorShares = sdk.NewRat(amt)
 	}
-	validators[0].UnbondedShares = sdk.NewRat(amts[0])
-	validators[1].UnbondedShares = sdk.NewRat(amts[1])
-	validators[2].UnbondedShares = sdk.NewRat(amts[2])
-	validators[3].BondedShares = sdk.NewRat(amts[3])
-	validators[4].BondedShares = sdk.NewRat(amts[4])
+	validators[0].PShares = NewUnbondedShares(sdk.NewRat(amts[0]))
+	validators[1].PShares = NewUnbondedShares(sdk.NewRat(amts[1]))
+	validators[2].PShares = NewUnbondedShares(sdk.NewRat(amts[2]))
+	validators[3].PShares = NewBondedShares(sdk.NewRat(amts[3]))
+	validators[4].PShares = NewBondedShares(sdk.NewRat(amts[4]))
 	for i := range amts {
 		keeper.setValidator(ctx, validators[i])
 	}
@@ -229,11 +229,11 @@ func GetValidatorSortingMixed(t *testing.T) {
 	// first make sure everything made it in to the gotValidator group
 	gotValidators := keeper.GetValidatorsBondedByPower(ctx)
 	require.Equal(t, n, len(gotValidators))
-	assert.Equal(t, sdk.NewRat(400), gotValidators[0].BondedShares, "%v", gotValidators)
-	assert.Equal(t, sdk.NewRat(200), gotValidators[1].BondedShares, "%v", gotValidators)
-	assert.Equal(t, sdk.NewRat(100), gotValidators[2].BondedShares, "%v", gotValidators)
-	assert.Equal(t, sdk.NewRat(1), gotValidators[3].BondedShares, "%v", gotValidators)
-	assert.Equal(t, sdk.NewRat(0), gotValidators[4].BondedShares, "%v", gotValidators)
+	assert.Equal(t, sdk.NewRat(400), gotValidators[0].PShares.Bonded(), "%v", gotValidators)
+	assert.Equal(t, sdk.NewRat(200), gotValidators[1].PShares.Bonded(), "%v", gotValidators)
+	assert.Equal(t, sdk.NewRat(100), gotValidators[2].PShares.Bonded(), "%v", gotValidators)
+	assert.Equal(t, sdk.NewRat(1), gotValidators[3].PShares.Bonded(), "%v", gotValidators)
+	assert.Equal(t, sdk.NewRat(0), gotValidators[4].PShares.Bonded(), "%v", gotValidators)
 	assert.Equal(t, validators[3].Address, gotValidators[0].Address, "%v", gotValidators)
 	assert.Equal(t, validators[4].Address, gotValidators[1].Address, "%v", gotValidators)
 	assert.Equal(t, validators[1].Address, gotValidators[2].Address, "%v", gotValidators)
@@ -258,15 +258,15 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 		validators[i] = NewValidator(addrs[i], pks[i], Description{})
 		validators[i].DelegatorShares = sdk.NewRat(amt)
 	}
-	validators[0].UnbondedShares = sdk.NewRat(amts[0])
-	validators[1].UnbondedShares = sdk.NewRat(amts[1])
-	validators[2].BondedShares = sdk.NewRat(amts[2])
-	validators[3].BondedShares = sdk.NewRat(amts[3])
+	validators[0].PShares = NewUnbondedShares(sdk.NewRat(amts[0]))
+	validators[1].PShares = NewUnbondedShares(sdk.NewRat(amts[1]))
+	validators[2].PShares = NewBondedShares(sdk.NewRat(amts[2]))
+	validators[3].PShares = NewBondedShares(sdk.NewRat(amts[3]))
 	for i := range amts {
 		keeper.setValidator(ctx, validators[i])
 	}
 
-	validators[0].UnbondedShares = sdk.NewRat(500)
+	validators[0].PShares = NewUnbondedShares(sdk.NewRat(500))
 	keeper.setValidator(ctx, validators[0])
 	gotValidators := keeper.GetValidatorsBondedByPower(ctx)
 	require.Equal(t, nMax, uint16(len(gotValidators)))
@@ -279,7 +279,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	// then increases to the original voting power, does not get its spot back in the
 	// case of a tie.
 	// ref https://github.com/cosmos/cosmos-sdk/issues/582#issuecomment-380757108
-	validators[3].BondedShares = sdk.NewRat(401)
+	validators[3].PShares = NewBondedShares(sdk.NewRat(401))
 	keeper.setValidator(ctx, validators[3])
 	gotValidators = keeper.GetValidatorsBondedByPower(ctx)
 	require.Equal(t, nMax, uint16(len(gotValidators)))
@@ -288,7 +288,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	ctx = ctx.WithBlockHeight(40)
 
 	// validator 3 kicked out temporarily
-	validators[3].BondedShares = sdk.NewRat(200)
+	validators[3].PShares = NewBondedShares(sdk.NewRat(200))
 	keeper.setValidator(ctx, validators[3])
 	gotValidators = keeper.GetValidatorsBondedByPower(ctx)
 	require.Equal(t, nMax, uint16(len(gotValidators)))
@@ -296,7 +296,7 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	assert.True(ValEq(t, validators[2], gotValidators[1]))
 
 	// validator 4 does not get spot back
-	validators[3].BondedShares = sdk.NewRat(400)
+	validators[3].PShares = NewBondedShares(sdk.NewRat(400))
 	keeper.setValidator(ctx, validators[3])
 	gotValidators = keeper.GetValidatorsBondedByPower(ctx)
 	require.Equal(t, nMax, uint16(len(gotValidators)))
@@ -319,14 +319,14 @@ func TestValidatorBondHeight(t *testing.T) {
 	// initialize some validators into the state
 	var validators [3]Validator
 	validators[0] = NewValidator(addrs[0], pks[0], Description{})
-	validators[0].BondedShares = sdk.NewRat(200)
+	validators[0].PShares = NewBondedShares(sdk.NewRat(200))
 	validators[0].DelegatorShares = sdk.NewRat(200)
 	keeper.setValidator(ctx, validators[0])
 	validators[1] = NewValidator(addrs[1], pks[1], Description{})
-	validators[1].BondedShares = sdk.NewRat(100)
+	validators[1].PShares = NewBondedShares(sdk.NewRat(100))
 	validators[1].DelegatorShares = sdk.NewRat(100)
 	validators[2] = NewValidator(addrs[2], pks[2], Description{})
-	validators[2].UnbondedShares = sdk.NewRat(100)
+	validators[2].PShares = NewUnbondedShares(sdk.NewRat(100))
 	validators[2].DelegatorShares = sdk.NewRat(100)
 
 	////////////////////////////////////////
@@ -338,8 +338,8 @@ func TestValidatorBondHeight(t *testing.T) {
 	require.Equal(t, uint16(len(gotValidators)), params.MaxValidators)
 	assert.True(ValEq(t, validators[0], gotValidators[0]))
 	assert.True(ValEq(t, validators[1], gotValidators[1]))
-	validators[1].BondedShares = sdk.NewRat(1100)
-	validators[2].BondedShares = sdk.NewRat(1100)
+	validators[1].PShares = NewBondedShares(sdk.NewRat(1100))
+	validators[2].PShares = NewBondedShares(sdk.NewRat(1100))
 	keeper.setValidator(ctx, validators[2])
 	keeper.setValidator(ctx, validators[1])
 	gotValidators = keeper.GetValidatorsBondedByPower(ctx)
@@ -363,13 +363,13 @@ func TestGetValidatorsEdgeCases2(t *testing.T) {
 	var validators [5]Validator
 	for i, amt := range amts {
 		validators[i] = NewValidator(addrs[i], pks[i], Description{})
-		validators[i].BondedShares = sdk.NewRat(amt)
+		validators[i].PShares = NewBondedShares(sdk.NewRat(amt))
 		validators[i].DelegatorShares = sdk.NewRat(amt)
 		keeper.setValidator(ctx, validators[i])
 	}
 
 	// test a swap in voting power
-	validators[0].BondedShares = sdk.NewRat(600)
+	validators[0].PShares = NewBondedShares(sdk.NewRat(600))
 	keeper.setValidator(ctx, validators[0])
 	gotValidators := keeper.GetValidatorsBondedByPower(ctx)
 	require.Equal(t, len(gotValidators), n)
@@ -395,7 +395,7 @@ func TestClearTendermintUpdates(t *testing.T) {
 	validators := make([]Validator, len(amts))
 	for i, amt := range amts {
 		validators[i] = NewValidator(addrs[i], pks[i], Description{})
-		validators[i].BondedShares = sdk.NewRat(amt)
+		validators[i].PShares = NewBondedShares(sdk.NewRat(amt))
 		validators[i].DelegatorShares = sdk.NewRat(amt)
 		keeper.setValidator(ctx, validators[i])
 	}
@@ -423,7 +423,7 @@ func TestGetTendermintUpdates(t *testing.T) {
 	var validatorsIn [5]Validator
 	for i, amt := range amts {
 		validatorsIn[i] = NewValidator(addrs[i], pks[i], Description{})
-		validatorsIn[i].BondedShares = sdk.NewRat(amt)
+		validatorsIn[i].PShares = NewBondedShares(sdk.NewRat(amt))
 		validatorsIn[i].DelegatorShares = sdk.NewRat(amt)
 	}
 
@@ -469,12 +469,12 @@ func TestGetTendermintUpdates(t *testing.T) {
 	assert.Equal(t, 2, len(keeper.GetValidatorsBonded(ctx)))
 	assert.Equal(t, 0, len(keeper.getTendermintUpdates(ctx)))
 
-	validators[0].BondedShares = sdk.NewRat(600)
+	validators[0].PShares = NewBondedShares(sdk.NewRat(600))
 	keeper.setValidator(ctx, validators[0])
 
 	validators = keeper.GetValidatorsBonded(ctx)
 	require.Equal(t, 2, len(validators))
-	assert.True(t, validators[0].BondedShares.Equal(sdk.NewRat(600)))
+	assert.True(t, validators[0].PShares.Bonded().Equal(sdk.NewRat(600)))
 	updates = keeper.getTendermintUpdates(ctx)
 	require.Equal(t, 1, len(updates))
 	assert.Equal(t, validators[0].abciValidator(keeper.cdc), updates[0])
@@ -486,8 +486,8 @@ func TestGetTendermintUpdates(t *testing.T) {
 	assert.Equal(t, 2, len(keeper.GetValidatorsBonded(ctx)))
 	assert.Equal(t, 0, len(keeper.getTendermintUpdates(ctx)))
 
-	validators[0].BondedShares = sdk.NewRat(200)
-	validators[1].BondedShares = sdk.NewRat(100)
+	validators[0].PShares = NewBondedShares(sdk.NewRat(200))
+	validators[1].PShares = NewBondedShares(sdk.NewRat(100))
 	keeper.setValidator(ctx, validators[0])
 	keeper.setValidator(ctx, validators[1])
 
@@ -550,7 +550,7 @@ func TestGetTendermintUpdates(t *testing.T) {
 	assert.Equal(t, 4, len(keeper.GetValidatorsBonded(ctx)))
 	assert.Equal(t, 0, len(keeper.getTendermintUpdates(ctx)))
 
-	validatorsIn[4].BondedShares = sdk.NewRat(1)
+	validatorsIn[4].PShares = NewBondedShares(sdk.NewRat(1))
 	keeper.setValidator(ctx, validatorsIn[4])
 
 	assert.Equal(t, 5, len(keeper.GetValidatorsBonded(ctx)))
@@ -566,7 +566,7 @@ func TestGetTendermintUpdates(t *testing.T) {
 	assert.Equal(t, 4, len(keeper.GetValidatorsBonded(ctx)))
 	assert.Equal(t, 0, len(keeper.getTendermintUpdates(ctx)))
 
-	validatorsIn[4].BondedShares = sdk.NewRat(1000)
+	validatorsIn[4].PShares = NewBondedShares(sdk.NewRat(1000))
 	keeper.setValidator(ctx, validatorsIn[4])
 
 	validators = keeper.GetValidatorsBonded(ctx)
@@ -625,7 +625,7 @@ func TestBond(t *testing.T) {
 	var validators [3]Validator
 	for i, amt := range amts {
 		validators[i] = NewValidator(addrVals[i], pks[i], Description{})
-		validators[i].BondedShares = sdk.NewRat(amt)
+		validators[i].PShares = NewBondedShares(sdk.NewRat(amt))
 		validators[i].DelegatorShares = sdk.NewRat(amt)
 	}
 
diff --git a/x/stake/tick_test.go b/x/stake/tick_test.go
index 896ca1208..c73b5460e 100644
--- a/x/stake/tick_test.go
+++ b/x/stake/tick_test.go
@@ -72,11 +72,12 @@ func TestProcessProvisions(t *testing.T) {
 			Status:          sdk.Unbonded,
 			PubKey:          pks[i],
 			Address:         addrs[i],
-			BondedShares:    sdk.NewRat(0),
+			PShares:         NewUnbondedShares(sdk.NewRat(0)),
 			DelegatorShares: sdk.NewRat(0),
 		}
 		if i < 5 {
 			v.Status = sdk.Bonded
+			v.PShares.Kind = ShareBonded
 		}
 		mintedTokens := int64((i + 1) * 10000000)
 		pool.TotalSupply += mintedTokens
diff --git a/x/stake/validator_test.go b/x/stake/validator_test.go
index 4343ad094..cf0576f8f 100644
--- a/x/stake/validator_test.go
+++ b/x/stake/validator_test.go
@@ -24,7 +24,7 @@ func TestAddTokensValidatorBonded(t *testing.T) {
 	assert.Equal(t, sdk.OneRat(), pool.unbondedShareExRate())
 
 	assert.True(sdk.RatEq(t, sdk.NewRat(10), delShares))
-	assert.True(sdk.RatEq(t, sdk.NewRat(10), val.BondedShares))
+	assert.True(sdk.RatEq(t, sdk.NewRat(10), val.PShares.Bonded()))
 }
 
 func TestAddTokensValidatorUnbonding(t *testing.T) {
@@ -41,7 +41,7 @@ func TestAddTokensValidatorUnbonding(t *testing.T) {
 	assert.Equal(t, sdk.OneRat(), pool.unbondedShareExRate())
 
 	assert.True(sdk.RatEq(t, sdk.NewRat(10), delShares))
-	assert.True(sdk.RatEq(t, sdk.NewRat(10), val.UnbondingShares))
+	assert.True(sdk.RatEq(t, sdk.NewRat(10), val.PShares.Unbonding()))
 }
 
 func TestAddTokensValidatorUnbonded(t *testing.T) {
@@ -58,7 +58,7 @@ func TestAddTokensValidatorUnbonded(t *testing.T) {
 	assert.Equal(t, sdk.OneRat(), pool.unbondedShareExRate())
 
 	assert.True(sdk.RatEq(t, sdk.NewRat(10), delShares))
-	assert.True(sdk.RatEq(t, sdk.NewRat(10), val.UnbondedShares))
+	assert.True(sdk.RatEq(t, sdk.NewRat(10), val.PShares.Unbonded()))
 }
 
 // TODO refactor to make simpler like the AddToken tests above
@@ -70,11 +70,11 @@ func TestRemoveShares(t *testing.T) {
 		Status:          sdk.Bonded,
 		Address:         addrs[0],
 		PubKey:          pks[0],
-		BondedShares:    sdk.NewRat(9),
+		PShares:         NewBondedShares(sdk.NewRat(9)),
 		DelegatorShares: sdk.NewRat(9),
 	}
-	poolA.BondedTokens = valA.BondedShares.Evaluate()
-	poolA.BondedShares = valA.BondedShares
+	poolA.BondedTokens = valA.PShares.Bonded().Evaluate()
+	poolA.BondedShares = valA.PShares.Bonded()
 	assert.Equal(t, valA.DelegatorShareExRate(poolA), sdk.OneRat())
 	assert.Equal(t, poolA.bondedShareExRate(), sdk.OneRat())
 	assert.Equal(t, poolA.unbondedShareExRate(), sdk.OneRat())
@@ -83,7 +83,7 @@ func TestRemoveShares(t *testing.T) {
 	// coins were created
 	assert.Equal(t, coinsB, int64(10))
 	// pool shares were removed
-	assert.Equal(t, valB.BondedShares, valA.BondedShares.Sub(sdk.NewRat(10).Mul(valA.DelegatorShareExRate(poolA))))
+	assert.Equal(t, valB.PShares.Bonded(), valA.PShares.Bonded().Sub(sdk.NewRat(10).Mul(valA.DelegatorShareExRate(poolA))))
 	// conservation of tokens
 	assert.Equal(t, poolB.UnbondedTokens+poolB.BondedTokens+coinsB, poolA.UnbondedTokens+poolA.BondedTokens)
 
@@ -94,7 +94,7 @@ func TestRemoveShares(t *testing.T) {
 		Status:          sdk.Bonded,
 		Address:         addrs[0],
 		PubKey:          pks[0],
-		BondedShares:    assets,
+		PShares:         NewBondedShares(assets),
 		DelegatorShares: liabilities,
 	}
 	pool := Pool{
@@ -108,7 +108,7 @@ func TestRemoveShares(t *testing.T) {
 	}
 	shares := sdk.NewRat(29)
 	msg := fmt.Sprintf("validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
-		val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(pool))
+		val.Address, val.Status, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(pool))
 	msg = fmt.Sprintf("Removed %v shares from %s", shares, msg)
 	_, newPool, tokens := val.removeDelShares(pool, shares)
 	require.Equal(t,
@@ -124,28 +124,28 @@ func TestUpdateSharesLocation(t *testing.T) {
 	val := NewValidator(addrs[0], pks[0], Description{})
 	val.Status = sdk.Unbonded
 	val, pool, _ = val.addTokensFromDel(pool, 100)
-	assert.Equal(t, int64(0), val.BondedShares.Evaluate())
-	assert.Equal(t, int64(0), val.UnbondingShares.Evaluate())
-	assert.Equal(t, int64(100), val.UnbondedShares.Evaluate())
+	assert.Equal(t, int64(0), val.PShares.Bonded().Evaluate())
+	assert.Equal(t, int64(0), val.PShares.Unbonding().Evaluate())
+	assert.Equal(t, int64(100), val.PShares.Unbonded().Evaluate())
 	assert.Equal(t, int64(0), pool.BondedTokens)
 	assert.Equal(t, int64(0), pool.UnbondingTokens)
 	assert.Equal(t, int64(100), pool.UnbondedTokens)
 
 	val.Status = sdk.Unbonding
 	val, pool = val.UpdateSharesLocation(pool)
-	//require.Fail(t, "", "%v", val.BondedShares.IsZero())
-	assert.Equal(t, int64(0), val.BondedShares.Evaluate())
-	assert.Equal(t, int64(100), val.UnbondingShares.Evaluate())
-	assert.Equal(t, int64(0), val.UnbondedShares.Evaluate())
+	//require.Fail(t, "", "%v", val.PShares.Bonded().IsZero())
+	assert.Equal(t, int64(0), val.PShares.Bonded().Evaluate())
+	assert.Equal(t, int64(100), val.PShares.Unbonding().Evaluate())
+	assert.Equal(t, int64(0), val.PShares.Unbonded().Evaluate())
 	assert.Equal(t, int64(0), pool.BondedTokens)
 	assert.Equal(t, int64(100), pool.UnbondingTokens)
 	assert.Equal(t, int64(0), pool.UnbondedTokens)
 
 	val.Status = sdk.Bonded
 	val, pool = val.UpdateSharesLocation(pool)
-	assert.Equal(t, int64(100), val.BondedShares.Evaluate())
-	assert.Equal(t, int64(0), val.UnbondingShares.Evaluate())
-	assert.Equal(t, int64(0), val.UnbondedShares.Evaluate())
+	assert.Equal(t, int64(100), val.PShares.Bonded().Evaluate())
+	assert.Equal(t, int64(0), val.PShares.Unbonding().Evaluate())
+	assert.Equal(t, int64(0), val.PShares.Unbonded().Evaluate())
 	assert.Equal(t, int64(100), pool.BondedTokens)
 	assert.Equal(t, int64(0), pool.UnbondingTokens)
 	assert.Equal(t, int64(0), pool.UnbondedTokens)
@@ -168,7 +168,7 @@ func randomValidator(r *rand.Rand) Validator {
 		Status:          status,
 		Address:         addrs[0],
 		PubKey:          pks[0],
-		BondedShares:    assets,
+		PShares:         NewBondedShares(assets),
 		DelegatorShares: liabilities,
 	}
 }
@@ -189,11 +189,11 @@ func randomSetup(r *rand.Rand, numValidators int) (Pool, Validators) {
 	for i := 0; i < numValidators; i++ {
 		validator := randomValidator(r)
 		if validator.Status == sdk.Bonded {
-			pool.BondedShares = pool.BondedShares.Add(validator.BondedShares)
-			pool.BondedTokens += validator.BondedShares.Evaluate()
+			pool.BondedShares = pool.BondedShares.Add(validator.PShares.Bonded())
+			pool.BondedTokens += validator.PShares.Bonded().Evaluate()
 		} else if validator.Status == sdk.Unbonded {
-			pool.UnbondedShares = pool.UnbondedShares.Add(validator.BondedShares)
-			pool.UnbondedTokens += validator.BondedShares.Evaluate()
+			pool.UnbondedShares = pool.UnbondedShares.Add(validator.PShares.Bonded())
+			pool.UnbondedTokens += validator.PShares.Bonded().Evaluate()
 		}
 		validators[i] = validator
 	}
@@ -210,11 +210,11 @@ func OpBondOrUnbond(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64
 	var msg string
 	if val.Status == sdk.Bonded {
 		msg = fmt.Sprintf("sdk.Unbonded previously bonded validator %s (assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
-			val.Address, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
+			val.Address, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(p))
 		val.Status = sdk.Unbonded
 	} else if val.Status == sdk.Unbonded {
 		msg = fmt.Sprintf("sdk.Bonded previously unbonded validator %s (assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
-			val.Address, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
+			val.Address, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(p))
 		val.Status = sdk.Bonded
 	}
 	val, p = val.UpdateSharesLocation(p)
@@ -225,7 +225,7 @@ func OpBondOrUnbond(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64
 func OpAddTokens(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64, string) {
 	tokens := int64(r.Int31n(1000))
 	msg := fmt.Sprintf("validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
-		val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
+		val.Address, val.Status, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(p))
 	val, p, _ = val.addTokensFromDel(p, tokens)
 	msg = fmt.Sprintf("Added %d tokens to %s", tokens, msg)
 	return p, val, -1 * tokens, msg // tokens are removed so for accounting must be negative
@@ -242,7 +242,7 @@ func OpRemoveShares(r *rand.Rand, p Pool, val Validator) (Pool, Validator, int64
 	}
 
 	msg := fmt.Sprintf("Removed %v shares from validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
-		shares, val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(p))
+		shares, val.Address, val.Status, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(p))
 
 	val, p, tokens := val.removeDelShares(p, shares)
 	return p, val, tokens, msg
@@ -263,13 +263,13 @@ func randomOperation(r *rand.Rand) Operation {
 
 // ensure invariants that should always be true are true
 func assertInvariants(t *testing.T, msg string,
-	pOrig Pool, cOrig Validators, pMod Pool, cMods Validators, tokens int64) {
+	pOrig Pool, cOrig Validators, pMod Pool, vMods Validators, tokens int64) {
 
 	// total tokens conserved
 	require.Equal(t,
 		pOrig.UnbondedTokens+pOrig.BondedTokens,
 		pMod.UnbondedTokens+pMod.BondedTokens+tokens,
-		"Tokens not conserved - msg: %v\n, pOrig.BondedShares: %v, pOrig.UnbondedShares: %v, pMod.BondedShares: %v, pMod.UnbondedShares: %v, pOrig.UnbondedTokens: %v, pOrig.BondedTokens: %v, pMod.UnbondedTokens: %v, pMod.BondedTokens: %v, tokens: %v\n",
+		"Tokens not conserved - msg: %v\n, pOrig.PShares.Bonded(): %v, pOrig.PShares.Unbonded(): %v, pMod.PShares.Bonded(): %v, pMod.PShares.Unbonded(): %v, pOrig.UnbondedTokens: %v, pOrig.BondedTokens: %v, pMod.UnbondedTokens: %v, pMod.BondedTokens: %v, tokens: %v\n",
 		msg,
 		pOrig.BondedShares, pOrig.UnbondedShares,
 		pMod.BondedShares, pMod.UnbondedShares,
@@ -296,34 +296,34 @@ func assertInvariants(t *testing.T, msg string,
 		"Applying operation \"%s\" resulted in negative unbondedShareExRate: %d",
 		msg, pMod.unbondedShareExRate().Evaluate())
 
-	for _, cMod := range cMods {
+	for _, vMod := range vMods {
 
 		// nonnegative ex rate
-		require.False(t, cMod.DelegatorShareExRate(pMod).LT(sdk.ZeroRat()),
+		require.False(t, vMod.DelegatorShareExRate(pMod).LT(sdk.ZeroRat()),
 			"Applying operation \"%s\" resulted in negative validator.DelegatorShareExRate(): %v (validator.Address: %s)",
 			msg,
-			cMod.DelegatorShareExRate(pMod),
-			cMod.Address,
+			vMod.DelegatorShareExRate(pMod),
+			vMod.Address,
 		)
 
 		// nonnegative assets
-		require.False(t, cMod.BondedShares.LT(sdk.ZeroRat()),
-			"Applying operation \"%s\" resulted in negative validator.BondedShares: %v (validator.DelegatorShares: %v, validator.DelegatorShareExRate: %v, validator.Address: %s)",
+		require.False(t, vMod.PShares.Bonded().LT(sdk.ZeroRat()),
+			"Applying operation \"%s\" resulted in negative validator.PShares.Bonded(): %v (validator.DelegatorShares: %v, validator.DelegatorShareExRate: %v, validator.Address: %s)",
 			msg,
-			cMod.BondedShares,
-			cMod.DelegatorShares,
-			cMod.DelegatorShareExRate(pMod),
-			cMod.Address,
+			vMod.PShares.Bonded(),
+			vMod.DelegatorShares,
+			vMod.DelegatorShareExRate(pMod),
+			vMod.Address,
 		)
 
 		// nonnegative liabilities
-		require.False(t, cMod.DelegatorShares.LT(sdk.ZeroRat()),
-			"Applying operation \"%s\" resulted in negative validator.DelegatorShares: %v (validator.BondedShares: %v, validator.DelegatorShareExRate: %v, validator.Address: %s)",
+		require.False(t, vMod.DelegatorShares.LT(sdk.ZeroRat()),
+			"Applying operation \"%s\" resulted in negative validator.DelegatorShares: %v (validator.PShares.Bonded(): %v, validator.DelegatorShareExRate: %v, validator.Address: %s)",
 			msg,
-			cMod.DelegatorShares,
-			cMod.BondedShares,
-			cMod.DelegatorShareExRate(pMod),
-			cMod.Address,
+			vMod.DelegatorShares,
+			vMod.PShares.Bonded(),
+			vMod.DelegatorShareExRate(pMod),
+			vMod.Address,
 		)
 
 	}
@@ -337,7 +337,7 @@ func TestPossibleOverflow(t *testing.T) {
 		Status:          sdk.Bonded,
 		Address:         addrs[0],
 		PubKey:          pks[0],
-		BondedShares:    assets,
+		PShares:         NewBondedShares(assets),
 		DelegatorShares: liabilities,
 	}
 	pool := Pool{
@@ -351,7 +351,7 @@ func TestPossibleOverflow(t *testing.T) {
 	}
 	tokens := int64(71)
 	msg := fmt.Sprintf("validator %s (status: %d, assets: %v, liabilities: %v, DelegatorShareExRate: %v)",
-		val.Address, val.Status, val.BondedShares, val.DelegatorShares, val.DelegatorShareExRate(pool))
+		val.Address, val.Status, val.PShares.Bonded(), val.DelegatorShares, val.DelegatorShareExRate(pool))
 	newValidator, _, _ := val.addTokensFromDel(pool, tokens)
 
 	msg = fmt.Sprintf("Added %d tokens to %s", tokens, msg)
diff --git a/x/stake/view_slash_keeper_test.go b/x/stake/view_slash_keeper_test.go
index 6130edb3f..a1013fc46 100644
--- a/x/stake/view_slash_keeper_test.go
+++ b/x/stake/view_slash_keeper_test.go
@@ -18,9 +18,9 @@ func TestViewSlashBond(t *testing.T) {
 	var validators [3]Validator
 	for i, amt := range amts {
 		validators[i] = Validator{
-			Address:     addrVals[i],
-			PubKey:      pks[i],
-			BondedShares:      sdk.NewRat(amt),
+			Address:         addrVals[i],
+			PubKey:          pks[i],
+			PShares:         NewBondedShares(sdk.NewRat(amt)),
 			DelegatorShares: sdk.NewRat(amt),
 		}
 	}