diff --git a/PENDING.md b/PENDING.md
index 8aa9ca3c56af..69a8293cc9c5 100644
--- a/PENDING.md
+++ b/PENDING.md
@@ -20,6 +20,7 @@ BREAKING CHANGES
   *  [\#3457](https://github.com/cosmos/cosmos-sdk/issues/3457) Changed governance tally validatorGovInfo to use sdk.Int power instead of sdk.Dec
 
 * SDK
+  * \#2513 Tendermint updates are adjusted by 10^-6 relative to staking tokens, 
   * [\#3487](https://github.com/cosmos/cosmos-sdk/pull/3487) Move HTTP/REST utilities out of client/utils into a new dedicated client/rest package.
   * [\#3490](https://github.com/cosmos/cosmos-sdk/issues/3490) ReadRESTReq() returns bool to avoid callers to write error responses twice.
   * [\#3502](https://github.com/cosmos/cosmos-sdk/pull/3502) Fixes issue when comparing genesis states
@@ -75,6 +76,7 @@ IMPROVEMENTS
   * [\#2605] x/params add subkey accessing
   * [\#2986](https://github.com/cosmos/cosmos-sdk/pull/2986) Store Refactor
   * \#3435 Test that store implementations do not allow nil values
+  * \#2509 Sanitize all usage of Dec.RoundInt64()
   * [\#556](https://github.com/cosmos/cosmos-sdk/issues/556) Increase `BaseApp`
   test coverage.
 
diff --git a/client/lcd/lcd_test.go b/client/lcd/lcd_test.go
index 25860f79e041..31aed1fd1a3e 100644
--- a/client/lcd/lcd_test.go
+++ b/client/lcd/lcd_test.go
@@ -27,7 +27,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/slashing"
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 const (
@@ -39,7 +38,7 @@ const (
 	altPw = "12345678901"
 )
 
-var fees = sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)}
+var fees = sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)}
 
 func init() {
 	mintkey.BcryptSecurityParameter = 1
@@ -48,7 +47,7 @@ func init() {
 
 func TestSeedsAreDifferent(t *testing.T) {
 	addr, _ := CreateAddr(t, name1, pw, GetKeyBase(t))
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 
 	mnemonic1 := getKeysSeed(t, port)
@@ -58,7 +57,7 @@ func TestSeedsAreDifferent(t *testing.T) {
 }
 
 func TestKeyRecover(t *testing.T) {
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
 	defer cleanup()
 
 	myName1 := "TestKeyRecover_1"
@@ -79,7 +78,7 @@ func TestKeyRecover(t *testing.T) {
 }
 
 func TestKeyRecoverHDPath(t *testing.T) {
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
 	defer cleanup()
 
 	mnemonic := getKeysSeed(t, port)
@@ -108,7 +107,7 @@ func TestKeys(t *testing.T) {
 	addr1, _ := CreateAddr(t, name1, pw, GetKeyBase(t))
 	addr1Bech32 := addr1.String()
 
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr1})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr1}, true)
 	defer cleanup()
 
 	// get new seed & recover key
@@ -157,7 +156,7 @@ func TestVersion(t *testing.T) {
 		t.SkipNow()
 	}
 
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
 	defer cleanup()
 
 	// node info
@@ -180,14 +179,14 @@ func TestVersion(t *testing.T) {
 }
 
 func TestNodeStatus(t *testing.T) {
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
 	defer cleanup()
 	getNodeInfo(t, port)
 	getSyncStatus(t, port, false)
 }
 
 func TestBlock(t *testing.T) {
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
 	defer cleanup()
 	getBlock(t, port, -1, false)
 	getBlock(t, port, 2, false)
@@ -195,7 +194,7 @@ func TestBlock(t *testing.T) {
 }
 
 func TestValidators(t *testing.T) {
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
 	defer cleanup()
 	resultVals := getValidatorSets(t, port, -1, false)
 	require.Contains(t, resultVals.Validators[0].Address.String(), "cosmosvaloper")
@@ -206,7 +205,7 @@ func TestValidators(t *testing.T) {
 
 func TestCoinSend(t *testing.T) {
 	addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 
 	bz, err := hex.DecodeString("8FA6AB57AD6870F6B5B2E57735F38F2F30E73CB6")
@@ -232,14 +231,14 @@ func TestCoinSend(t *testing.T) {
 	coins := acc.GetCoins()
 	expectedBalance := initialBalance[0].Minus(fees[0])
 
-	require.Equal(t, stakingTypes.DefaultBondDenom, coins[0].Denom)
+	require.Equal(t, staking.DefaultBondDenom, coins[0].Denom)
 	require.Equal(t, expectedBalance.Amount.SubRaw(1), coins[0].Amount)
 	expectedBalance = coins[0]
 
 	// query receiver
 	acc2 := getAccount(t, port, receiveAddr)
 	coins2 := acc2.GetCoins()
-	require.Equal(t, stakingTypes.DefaultBondDenom, coins2[0].Denom)
+	require.Equal(t, staking.DefaultBondDenom, coins2[0].Denom)
 	require.Equal(t, int64(1), coins2[0].Amount.Int64())
 
 	// test failure with too little gas
@@ -275,7 +274,7 @@ func TestCoinSend(t *testing.T) {
 	require.NotZero(t, gasEstResp.GasEstimate)
 
 	acc = getAccount(t, port, addr)
-	require.Equal(t, expectedBalance.Amount, acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom))
+	require.Equal(t, expectedBalance.Amount, acc.GetCoins().AmountOf(staking.DefaultBondDenom))
 
 	// run successful tx
 	gas := fmt.Sprintf("%d", gasEstResp.GasEstimate)
@@ -290,12 +289,12 @@ func TestCoinSend(t *testing.T) {
 
 	acc = getAccount(t, port, addr)
 	expectedBalance = expectedBalance.Minus(fees[0])
-	require.Equal(t, expectedBalance.Amount.SubRaw(1), acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom))
+	require.Equal(t, expectedBalance.Amount.SubRaw(1), acc.GetCoins().AmountOf(staking.DefaultBondDenom))
 }
 
 func TestCoinSendAccAuto(t *testing.T) {
 	addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 
 	acc := getAccount(t, port, addr)
@@ -310,13 +309,13 @@ func TestCoinSendAccAuto(t *testing.T) {
 	coins := acc.GetCoins()
 	expectedBalance := initialBalance[0].Minus(fees[0])
 
-	require.Equal(t, stakingTypes.DefaultBondDenom, coins[0].Denom)
+	require.Equal(t, staking.DefaultBondDenom, coins[0].Denom)
 	require.Equal(t, expectedBalance.Amount.SubRaw(1), coins[0].Amount)
 }
 
 func TestCoinMultiSendGenerateOnly(t *testing.T) {
 	addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 
 	// generate only
@@ -337,7 +336,7 @@ func TestCoinMultiSendGenerateOnly(t *testing.T) {
 
 func TestCoinSendGenerateSignAndBroadcast(t *testing.T) {
 	addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 	acc := getAccount(t, port, addr)
 
@@ -409,7 +408,7 @@ func TestCoinSendGenerateSignAndBroadcast(t *testing.T) {
 
 func TestTxs(t *testing.T) {
 	addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 
 	var emptyTxs []sdk.TxResponse
@@ -448,7 +447,7 @@ func TestTxs(t *testing.T) {
 
 func TestPoolParamsQuery(t *testing.T) {
 	addr, _ := CreateAddr(t, name1, pw, GetKeyBase(t))
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 
 	defaultParams := staking.DefaultParams()
@@ -459,16 +458,21 @@ func TestPoolParamsQuery(t *testing.T) {
 	pool := getStakingPool(t, port)
 
 	initialPool := staking.InitialPool()
-	initialPool.NotBondedTokens = initialPool.NotBondedTokens.Add(sdk.NewInt(100))
-	initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewInt(100))      // Delegate tx on GaiaAppGenState
-	initialPool.NotBondedTokens = initialPool.NotBondedTokens.Add(sdk.NewInt(50)) // freeFermionsAcc = 50 on GaiaAppGenState
+	tokens := staking.TokensFromTendermintPower(100)
+	freeFermions := staking.TokensFromTendermintPower(50)
+	initialPool.NotBondedTokens = initialPool.NotBondedTokens.Add(tokens)
+	initialPool.BondedTokens = initialPool.BondedTokens.Add(tokens)             // Delegate tx on GaiaAppGenState
+	initialPool.NotBondedTokens = initialPool.NotBondedTokens.Add(freeFermions) // freeFermionsAcc = 50 on GaiaAppGenState
 
 	require.Equal(t, initialPool.BondedTokens, pool.BondedTokens)
-	require.Equal(t, initialPool.NotBondedTokens, pool.NotBondedTokens)
+
+	//TODO include this test once REST for distribution is online, need to include distribution tokens from inflation
+	//     for this equality to make sense
+	//require.Equal(t, initialPool.NotBondedTokens, pool.NotBondedTokens)
 }
 
 func TestValidatorsQuery(t *testing.T) {
-	cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
+	cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
 	defer cleanup()
 
 	require.Equal(t, 1, len(valPubKeys))
@@ -488,7 +492,7 @@ func TestValidatorsQuery(t *testing.T) {
 }
 
 func TestValidatorQuery(t *testing.T) {
-	cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
+	cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
 	defer cleanup()
 	require.Equal(t, 1, len(valPubKeys))
 	require.Equal(t, 1, len(operAddrs))
@@ -500,20 +504,22 @@ func TestValidatorQuery(t *testing.T) {
 func TestBonding(t *testing.T) {
 	addr, _ := CreateAddr(t, name1, pw, GetKeyBase(t))
 
-	cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 2, []sdk.AccAddress{addr})
+	cleanup, valPubKeys, operAddrs, port := InitializeTestLCD(t, 2, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 
 	require.Equal(t, 2, len(valPubKeys))
 	require.Equal(t, 2, len(operAddrs))
 
-	amt := sdk.NewDec(60)
+	amt := staking.TokensFromTendermintPower(60)
+	amtDec := sdk.NewDecFromInt(amt)
 	validator := getValidator(t, port, operAddrs[0])
 
 	acc := getAccount(t, port, addr)
 	initialBalance := acc.GetCoins()
 
 	// create bond TX
-	resultTx := doDelegate(t, port, name1, pw, addr, operAddrs[0], 60, fees)
+	delTokens := staking.TokensFromTendermintPower(60)
+	resultTx := doDelegate(t, port, name1, pw, addr, operAddrs[0], delTokens, fees)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	require.Equal(t, uint32(0), resultTx.Code)
@@ -530,16 +536,16 @@ func TestBonding(t *testing.T) {
 	acc = getAccount(t, port, addr)
 	coins := acc.GetCoins()
 	expectedBalance := initialBalance[0].Minus(fees[0])
-	require.Equal(t, expectedBalance.Amount.SubRaw(60), coins.AmountOf(stakingTypes.DefaultBondDenom))
+	require.Equal(t, expectedBalance.Amount.Sub(delTokens), coins.AmountOf(staking.DefaultBondDenom))
 	expectedBalance = coins[0]
 
 	// query delegation
 	bond := getDelegation(t, port, addr, operAddrs[0])
-	require.Equal(t, amt, bond.Shares)
+	require.Equal(t, amtDec, bond.Shares)
 
 	delegatorDels := getDelegatorDelegations(t, port, addr)
 	require.Len(t, delegatorDels, 1)
-	require.Equal(t, amt, delegatorDels[0].Shares)
+	require.Equal(t, amtDec, delegatorDels[0].Shares)
 
 	// query all delegations to validator
 	bonds := getValidatorDelegations(t, port, operAddrs[0])
@@ -548,13 +554,14 @@ func TestBonding(t *testing.T) {
 	bondedValidators := getDelegatorValidators(t, port, addr)
 	require.Len(t, bondedValidators, 1)
 	require.Equal(t, operAddrs[0], bondedValidators[0].OperatorAddr)
-	require.Equal(t, validator.DelegatorShares.Add(amt).String(), bondedValidators[0].DelegatorShares.String())
+	require.Equal(t, validator.DelegatorShares.Add(amtDec).String(), bondedValidators[0].DelegatorShares.String())
 
 	bondedValidator := getDelegatorValidator(t, port, addr, operAddrs[0])
 	require.Equal(t, operAddrs[0], bondedValidator.OperatorAddr)
 
 	// testing unbonding
-	resultTx = doUndelegate(t, port, name1, pw, addr, operAddrs[0], 30, fees)
+	unbondingTokens := staking.TokensFromTendermintPower(30)
+	resultTx = doUndelegate(t, port, name1, pw, addr, operAddrs[0], unbondingTokens, fees)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	require.Equal(t, uint32(0), resultTx.Code)
@@ -564,8 +571,8 @@ func TestBonding(t *testing.T) {
 	coins = acc.GetCoins()
 	expectedBalance = expectedBalance.Minus(fees[0])
 	require.True(t,
-		expectedBalance.Amount.LT(coins.AmountOf(stakingTypes.DefaultBondDenom)) ||
-			expectedBalance.Amount.Equal(coins.AmountOf(stakingTypes.DefaultBondDenom)),
+		expectedBalance.Amount.LT(coins.AmountOf(staking.DefaultBondDenom)) ||
+			expectedBalance.Amount.Equal(coins.AmountOf(staking.DefaultBondDenom)),
 		"should get tokens back from automatic withdrawal after an unbonding delegation",
 	)
 	expectedBalance = coins[0]
@@ -580,10 +587,11 @@ func TestBonding(t *testing.T) {
 
 	ubd := getUnbondingDelegation(t, port, addr, operAddrs[0])
 	require.Len(t, ubd.Entries, 1)
-	require.Equal(t, int64(30), ubd.Entries[0].Balance.Amount.Int64())
+	require.Equal(t, delTokens.DivRaw(2), ubd.Entries[0].Balance.Amount)
 
 	// test redelegation
-	resultTx = doBeginRedelegation(t, port, name1, pw, addr, operAddrs[0], operAddrs[1], 30, fees)
+	rdTokens := staking.TokensFromTendermintPower(30)
+	resultTx = doBeginRedelegation(t, port, name1, pw, addr, operAddrs[0], operAddrs[1], rdTokens, fees)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	require.Equal(t, uint32(0), resultTx.Code)
@@ -592,8 +600,8 @@ func TestBonding(t *testing.T) {
 	acc = getAccount(t, port, addr)
 	expectedBalance = expectedBalance.Minus(fees[0])
 	require.True(t,
-		expectedBalance.Amount.LT(coins.AmountOf(stakingTypes.DefaultBondDenom)) ||
-			expectedBalance.Amount.Equal(coins.AmountOf(stakingTypes.DefaultBondDenom)),
+		expectedBalance.Amount.LT(coins.AmountOf(staking.DefaultBondDenom)) ||
+			expectedBalance.Amount.Equal(coins.AmountOf(staking.DefaultBondDenom)),
 		"should get tokens back from automatic withdrawal after an unbonding delegation",
 	)
 
@@ -607,34 +615,35 @@ func TestBonding(t *testing.T) {
 	require.Equal(t, resultTx.Height, txs[0].Height)
 
 	// query delegations, unbondings and redelegations from validator and delegator
+	rdShares := sdk.NewDecFromInt(rdTokens)
 	delegatorDels = getDelegatorDelegations(t, port, addr)
 	require.Len(t, delegatorDels, 1)
-	require.Equal(t, "30.000000000000000000", delegatorDels[0].GetShares().String())
+	require.Equal(t, rdShares, delegatorDels[0].GetShares())
 
 	redelegation := getRedelegations(t, port, addr, operAddrs[0], operAddrs[1])
 	require.Len(t, redelegation, 1)
 	require.Len(t, redelegation[0].Entries, 1)
-	require.Equal(t, "30", redelegation[0].Entries[0].Balance.Amount.String())
+	require.Equal(t, rdTokens, redelegation[0].Entries[0].Balance.Amount)
 
 	delegatorUbds := getDelegatorUnbondingDelegations(t, port, addr)
 	require.Len(t, delegatorUbds, 1)
 	require.Len(t, delegatorUbds[0].Entries, 1)
-	require.Equal(t, "30", delegatorUbds[0].Entries[0].Balance.Amount.String())
+	require.Equal(t, rdTokens, delegatorUbds[0].Entries[0].Balance.Amount)
 
 	delegatorReds := getRedelegations(t, port, addr, nil, nil)
 	require.Len(t, delegatorReds, 1)
 	require.Len(t, delegatorReds[0].Entries, 1)
-	require.Equal(t, "30", delegatorReds[0].Entries[0].Balance.Amount.String())
+	require.Equal(t, rdTokens, delegatorReds[0].Entries[0].Balance.Amount)
 
 	validatorUbds := getValidatorUnbondingDelegations(t, port, operAddrs[0])
 	require.Len(t, validatorUbds, 1)
 	require.Len(t, validatorUbds[0].Entries, 1)
-	require.Equal(t, "30", validatorUbds[0].Entries[0].Balance.Amount.String())
+	require.Equal(t, rdTokens, validatorUbds[0].Entries[0].Balance.Amount)
 
 	validatorReds := getRedelegations(t, port, nil, operAddrs[0], nil)
 	require.Len(t, validatorReds, 1)
 	require.Len(t, validatorReds[0].Entries, 1)
-	require.Equal(t, "30", validatorReds[0].Entries[0].Balance.Amount.String())
+	require.Equal(t, rdTokens, validatorReds[0].Entries[0].Balance.Amount)
 
 	// TODO Undonding status not currently implemented
 	// require.Equal(t, sdk.Unbonding, bondedValidators[0].Status)
@@ -655,14 +664,15 @@ func TestBonding(t *testing.T) {
 
 func TestSubmitProposal(t *testing.T) {
 	addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 
 	acc := getAccount(t, port, addr)
 	initialBalance := acc.GetCoins()
 
 	// create SubmitProposal TX
-	resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, 5, fees)
+	proposalTokens := staking.TokensFromTendermintPower(5)
+	resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, proposalTokens, fees)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	// check if tx was committed
@@ -674,7 +684,7 @@ func TestSubmitProposal(t *testing.T) {
 	// verify balance
 	acc = getAccount(t, port, addr)
 	expectedBalance := initialBalance[0].Minus(fees[0])
-	require.Equal(t, expectedBalance.Amount.SubRaw(5), acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom))
+	require.Equal(t, expectedBalance.Amount.Sub(proposalTokens), acc.GetCoins().AmountOf(staking.DefaultBondDenom))
 
 	// query proposal
 	proposal := getProposal(t, port, proposalID)
@@ -687,14 +697,15 @@ func TestSubmitProposal(t *testing.T) {
 
 func TestDeposit(t *testing.T) {
 	addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 
 	acc := getAccount(t, port, addr)
 	initialBalance := acc.GetCoins()
 
 	// create SubmitProposal TX
-	resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, 5, fees)
+	proposalTokens := staking.TokensFromTendermintPower(5)
+	resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, proposalTokens, fees)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	// check if tx was committed
@@ -707,7 +718,7 @@ func TestDeposit(t *testing.T) {
 	acc = getAccount(t, port, addr)
 	coins := acc.GetCoins()
 	expectedBalance := initialBalance[0].Minus(fees[0])
-	require.Equal(t, expectedBalance.Amount.SubRaw(5), coins.AmountOf(stakingTypes.DefaultBondDenom))
+	require.Equal(t, expectedBalance.Amount.Sub(proposalTokens), coins.AmountOf(staking.DefaultBondDenom))
 	expectedBalance = coins[0]
 
 	// query proposal
@@ -715,13 +726,14 @@ func TestDeposit(t *testing.T) {
 	require.Equal(t, "Test", proposal.GetTitle())
 
 	// create SubmitProposal TX
-	resultTx = doDeposit(t, port, seed, name1, pw, addr, proposalID, 5, fees)
+	depositTokens := staking.TokensFromTendermintPower(5)
+	resultTx = doDeposit(t, port, seed, name1, pw, addr, proposalID, depositTokens, fees)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	// verify balance after deposit and fee
 	acc = getAccount(t, port, addr)
 	expectedBalance = expectedBalance.Minus(fees[0])
-	require.Equal(t, expectedBalance.Amount.SubRaw(5), acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom))
+	require.Equal(t, expectedBalance.Amount.Sub(depositTokens), acc.GetCoins().AmountOf(staking.DefaultBondDenom))
 
 	// query tx
 	txs := getTransactions(t, port, fmt.Sprintf("action=deposit&depositor=%s", addr))
@@ -729,24 +741,26 @@ func TestDeposit(t *testing.T) {
 	require.Equal(t, resultTx.Height, txs[0].Height)
 
 	// query proposal
+	totalCoins := sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, staking.TokensFromTendermintPower(10))}
 	proposal = getProposal(t, port, proposalID)
-	require.True(t, proposal.GetTotalDeposit().IsEqual(sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10)}))
+	require.True(t, proposal.GetTotalDeposit().IsEqual(totalCoins))
 
 	// query deposit
 	deposit := getDeposit(t, port, proposalID, addr)
-	require.True(t, deposit.Amount.IsEqual(sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10)}))
+	require.True(t, deposit.Amount.IsEqual(totalCoins))
 }
 
 func TestVote(t *testing.T) {
 	addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
-	cleanup, _, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, _, operAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 
 	acc := getAccount(t, port, addr)
 	initialBalance := acc.GetCoins()
 
 	// create SubmitProposal TX
-	resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, 10, fees)
+	proposalTokens := staking.TokensFromTendermintPower(10)
+	resultTx := doSubmitProposal(t, port, seed, name1, pw, addr, proposalTokens, fees)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	// check if tx was committed
@@ -759,7 +773,7 @@ func TestVote(t *testing.T) {
 	acc = getAccount(t, port, addr)
 	coins := acc.GetCoins()
 	expectedBalance := initialBalance[0].Minus(fees[0])
-	require.Equal(t, expectedBalance.Amount.SubRaw(10), coins.AmountOf(stakingTypes.DefaultBondDenom))
+	require.Equal(t, expectedBalance.Amount.Sub(proposalTokens), coins.AmountOf(staking.DefaultBondDenom))
 	expectedBalance = coins[0]
 
 	// query proposal
@@ -775,7 +789,7 @@ func TestVote(t *testing.T) {
 	acc = getAccount(t, port, addr)
 	coins = acc.GetCoins()
 	expectedBalance = expectedBalance.Minus(fees[0])
-	require.Equal(t, expectedBalance.Amount, coins.AmountOf(stakingTypes.DefaultBondDenom))
+	require.Equal(t, expectedBalance.Amount, coins.AmountOf(staking.DefaultBondDenom))
 	expectedBalance = coins[0]
 
 	// query tx
@@ -791,18 +805,19 @@ func TestVote(t *testing.T) {
 	require.Equal(t, sdk.ZeroDec(), tally.Yes, "tally should be 0 as the address is not bonded")
 
 	// create bond TX
-	resultTx = doDelegate(t, port, name1, pw, addr, operAddrs[0], 60, fees)
+	delTokens := staking.TokensFromTendermintPower(60)
+	resultTx = doDelegate(t, port, name1, pw, addr, operAddrs[0], delTokens, fees)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	// verify balance
 	acc = getAccount(t, port, addr)
 	coins = acc.GetCoins()
 	expectedBalance = expectedBalance.Minus(fees[0])
-	require.Equal(t, expectedBalance.Amount.SubRaw(60), coins.AmountOf(stakingTypes.DefaultBondDenom))
+	require.Equal(t, expectedBalance.Amount.Sub(delTokens), coins.AmountOf(staking.DefaultBondDenom))
 	expectedBalance = coins[0]
 
 	tally = getTally(t, port, proposalID)
-	require.Equal(t, sdk.NewDec(60), tally.Yes, "tally should be equal to the amount delegated")
+	require.Equal(t, sdk.NewDecFromInt(delTokens), tally.Yes, "tally should be equal to the amount delegated")
 
 	// change vote option
 	resultTx = doVote(t, port, seed, name1, pw, addr, proposalID, "No", fees)
@@ -811,16 +826,16 @@ func TestVote(t *testing.T) {
 	// verify balance
 	acc = getAccount(t, port, addr)
 	expectedBalance = expectedBalance.Minus(fees[0])
-	require.Equal(t, expectedBalance.Amount, acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom))
+	require.Equal(t, expectedBalance.Amount, acc.GetCoins().AmountOf(staking.DefaultBondDenom))
 
 	tally = getTally(t, port, proposalID)
 	require.Equal(t, sdk.ZeroDec(), tally.Yes, "tally should be 0 the user changed the option")
-	require.Equal(t, sdk.NewDec(60), tally.No, "tally should be equal to the amount delegated")
+	require.Equal(t, sdk.NewDecFromInt(delTokens), tally.No, "tally should be equal to the amount delegated")
 }
 
 func TestUnjail(t *testing.T) {
 	addr, _ := CreateAddr(t, name1, pw, GetKeyBase(t))
-	cleanup, valPubKeys, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, valPubKeys, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, true)
 	defer cleanup()
 
 	// XXX: any less than this and it fails
@@ -836,11 +851,11 @@ func TestUnjail(t *testing.T) {
 func TestProposalsQuery(t *testing.T) {
 	addrs, seeds, names, passwords := CreateAddrs(t, GetKeyBase(t), 2)
 
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addrs[0], addrs[1]})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addrs[0], addrs[1]}, true)
 	defer cleanup()
 
 	depositParam := getDepositParam(t, port)
-	halfMinDeposit := depositParam.MinDeposit.AmountOf(stakingTypes.DefaultBondDenom).Int64() / 2
+	halfMinDeposit := depositParam.MinDeposit.AmountOf(staking.DefaultBondDenom).DivRaw(2)
 	getVotingParam(t, port)
 	getTallyingParam(t, port)
 
@@ -887,7 +902,8 @@ func TestProposalsQuery(t *testing.T) {
 	require.Equal(t, deposit, deposits[0])
 
 	// increasing the amount of the deposit should update the existing one
-	resultTx = doDeposit(t, port, seeds[0], names[0], passwords[0], addrs[0], proposalID1, 1, fees)
+	depositTokens := staking.TokensFromTendermintPower(1)
+	resultTx = doDeposit(t, port, seeds[0], names[0], passwords[0], addrs[0], proposalID1, depositTokens, fees)
 	tests.WaitForHeight(resultTx.Height+1, port)
 
 	deposits = getDeposits(t, port, proposalID1)
@@ -955,7 +971,7 @@ func TestProposalsQuery(t *testing.T) {
 }
 
 func TestSlashingGetParams(t *testing.T) {
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
 	defer cleanup()
 
 	res, body := Request(t, port, "GET", "/slashing/parameters", nil)
@@ -967,7 +983,7 @@ func TestSlashingGetParams(t *testing.T) {
 }
 
 func TestDistributionGetParams(t *testing.T) {
-	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{})
+	cleanup, _, _, port := InitializeTestLCD(t, 1, []sdk.AccAddress{}, true)
 	defer cleanup()
 
 	res, body := Request(t, port, "GET", "/distribution/parameters", nil)
@@ -977,8 +993,7 @@ func TestDistributionGetParams(t *testing.T) {
 
 func TestDistributionFlow(t *testing.T) {
 	addr, seed := CreateAddr(t, name1, pw, GetKeyBase(t))
-	//addr2, seed2 = CreateAddr(t, name2, pw, GetKeyBase(t))
-	cleanup, _, valAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr})
+	cleanup, _, valAddrs, port := InitializeTestLCD(t, 1, []sdk.AccAddress{addr}, false)
 	defer cleanup()
 
 	valAddr := valAddrs[0]
@@ -999,7 +1014,8 @@ func TestDistributionFlow(t *testing.T) {
 	require.Equal(t, valDistInfo.SelfBondRewards, sdk.DecCoins(nil))
 
 	// Delegate some coins
-	resultTx := doDelegate(t, port, name1, pw, addr, valAddr, 60, fees)
+	delTokens := staking.TokensFromTendermintPower(60)
+	resultTx := doDelegate(t, port, name1, pw, addr, valAddr, delTokens, fees)
 	tests.WaitForHeight(resultTx.Height+1, port)
 	require.Equal(t, uint32(0), resultTx.Code)
 
diff --git a/client/lcd/test_helpers.go b/client/lcd/test_helpers.go
index 2c6223de3b98..588285233574 100644
--- a/client/lcd/test_helpers.go
+++ b/client/lcd/test_helpers.go
@@ -15,6 +15,9 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/keys"
 	"github.com/cosmos/cosmos-sdk/client/rest"
@@ -23,26 +26,22 @@ import (
 	gapp "github.com/cosmos/cosmos-sdk/cmd/gaia/app"
 	"github.com/cosmos/cosmos-sdk/codec"
 	crkeys "github.com/cosmos/cosmos-sdk/crypto/keys"
-	cryptoKeys "github.com/cosmos/cosmos-sdk/crypto/keys"
 	"github.com/cosmos/cosmos-sdk/server"
 	"github.com/cosmos/cosmos-sdk/tests"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
-	authRest "github.com/cosmos/cosmos-sdk/x/auth/client/rest"
 	authrest "github.com/cosmos/cosmos-sdk/x/auth/client/rest"
 	txbuilder "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
-	bankRest "github.com/cosmos/cosmos-sdk/x/bank/client/rest"
+	bankrest "github.com/cosmos/cosmos-sdk/x/bank/client/rest"
+	distr "github.com/cosmos/cosmos-sdk/x/distribution"
+	distrrest "github.com/cosmos/cosmos-sdk/x/distribution/client/rest"
 	"github.com/cosmos/cosmos-sdk/x/gov"
-	govRest "github.com/cosmos/cosmos-sdk/x/gov/client/rest"
+	govrest "github.com/cosmos/cosmos-sdk/x/gov/client/rest"
 	gcutils "github.com/cosmos/cosmos-sdk/x/gov/client/utils"
 	"github.com/cosmos/cosmos-sdk/x/slashing"
-	slashingRest "github.com/cosmos/cosmos-sdk/x/slashing/client/rest"
+	slashingrest "github.com/cosmos/cosmos-sdk/x/slashing/client/rest"
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingRest "github.com/cosmos/cosmos-sdk/x/staking/client/rest"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
-
-	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
+	stakingrest "github.com/cosmos/cosmos-sdk/x/staking/client/rest"
 
 	abci "github.com/tendermint/tendermint/abci/types"
 	tmcfg "github.com/tendermint/tendermint/config"
@@ -59,9 +58,6 @@ import (
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 	tmrpc "github.com/tendermint/tendermint/rpc/lib/server"
 	tmtypes "github.com/tendermint/tendermint/types"
-
-	distr "github.com/cosmos/cosmos-sdk/x/distribution"
-	distrRest "github.com/cosmos/cosmos-sdk/x/distribution/client/rest"
 )
 
 // makePathname creates a unique pathname for each test. It will panic if it
@@ -202,9 +198,8 @@ func (b AddrSeedSlice) Swap(i, j int) {
 // their respective sockets where nValidators is the total number of validators
 // and initAddrs are the accounts to initialize with some steak tokens. It
 // returns a cleanup function, a set of validator public keys, and a port.
-func InitializeTestLCD(
-	t *testing.T, nValidators int, initAddrs []sdk.AccAddress,
-) (cleanup func(), valConsPubKeys []crypto.PubKey, valOperAddrs []sdk.ValAddress, port string) {
+func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.AccAddress, minting bool) (
+	cleanup func(), valConsPubKeys []crypto.PubKey, valOperAddrs []sdk.ValAddress, port string) {
 
 	if nValidators < 1 {
 		panic("InitializeTestLCD must use at least one validator")
@@ -239,16 +234,19 @@ func InitializeTestLCD(
 		operPrivKey := secp256k1.GenPrivKey()
 		operAddr := operPrivKey.PubKey().Address()
 		pubKey := privVal.GetPubKey()
-		delegation := 100
+
+		power := int64(100)
 		if i > 0 {
 			pubKey = ed25519.GenPrivKey().PubKey()
-			delegation = 1
+			power = 1
 		}
+		startTokens := staking.TokensFromTendermintPower(power)
+
 		msg := staking.NewMsgCreateValidator(
 			sdk.ValAddress(operAddr),
 			pubKey,
-			sdk.NewCoin(stakingTypes.DefaultBondDenom, sdk.NewInt(int64(delegation))),
-			staking.Description{Moniker: fmt.Sprintf("validator-%d", i+1)},
+			sdk.NewCoin(staking.DefaultBondDenom, startTokens),
+			staking.NewDescription(fmt.Sprintf("validator-%d", i+1), "", "", ""),
 			staking.NewCommissionMsg(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()),
 		)
 		stdSignMsg := txbuilder.StdSignMsg{
@@ -260,12 +258,14 @@ func InitializeTestLCD(
 		tx := auth.NewStdTx([]sdk.Msg{msg}, auth.StdFee{}, []auth.StdSignature{{Signature: sig, PubKey: operPrivKey.PubKey()}}, "")
 		txBytes, err := cdc.MarshalJSON(tx)
 		require.Nil(t, err)
+
 		genTxs = append(genTxs, txBytes)
 		valConsPubKeys = append(valConsPubKeys, pubKey)
 		valOperAddrs = append(valOperAddrs, sdk.ValAddress(operAddr))
 
 		accAuth := auth.NewBaseAccountWithAddress(sdk.AccAddress(operAddr))
-		accAuth.Coins = sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 150)}
+		accTokens := staking.TokensFromTendermintPower(150)
+		accAuth.Coins = sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, accTokens)}
 		accs = append(accs, gapp.NewGenesisAccount(&accAuth))
 	}
 
@@ -279,15 +279,21 @@ func InitializeTestLCD(
 	// add some tokens to init accounts
 	for _, addr := range initAddrs {
 		accAuth := auth.NewBaseAccountWithAddress(addr)
-		accAuth.Coins = sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 100)}
+		accTokens := staking.TokensFromTendermintPower(100)
+		accAuth.Coins = sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, accTokens)}
 		acc := gapp.NewGenesisAccount(&accAuth)
 		genesisState.Accounts = append(genesisState.Accounts, acc)
-		genesisState.StakingData.Pool.NotBondedTokens = genesisState.StakingData.Pool.NotBondedTokens.Add(sdk.NewInt(100))
+		genesisState.StakingData.Pool.NotBondedTokens = genesisState.StakingData.Pool.NotBondedTokens.Add(accTokens)
 	}
 
-	inflationMin := sdk.MustNewDecFromStr("10000.0")
+	inflationMin := sdk.ZeroDec()
+	if minting {
+		inflationMin = sdk.MustNewDecFromStr("10000.0")
+		genesisState.MintData.Params.InflationMax = sdk.MustNewDecFromStr("15000.0")
+	} else {
+		genesisState.MintData.Params.InflationMax = inflationMin
+	}
 	genesisState.MintData.Minter.Inflation = inflationMin
-	genesisState.MintData.Params.InflationMax = sdk.MustNewDecFromStr("15000.0")
 	genesisState.MintData.Params.InflationMin = inflationMin
 
 	appState, err := codec.MarshalJSONIndent(cdc, genesisState)
@@ -335,6 +341,7 @@ func startTM(
 	tmcfg *tmcfg.Config, logger log.Logger, genDoc *tmtypes.GenesisDoc,
 	privVal tmtypes.PrivValidator, app abci.Application,
 ) (*nm.Node, error) {
+
 	genDocProvider := func() (*tmtypes.GenesisDoc, error) { return genDoc, nil }
 	dbProvider := func(*nm.DBContext) (dbm.DB, error) { return dbm.NewMemDB(), nil }
 	nodeKey, err := p2p.LoadOrGenNodeKey(tmcfg.NodeKeyFile())
@@ -384,12 +391,12 @@ func registerRoutes(rs *RestServer) {
 	keys.RegisterRoutes(rs.Mux, rs.CliCtx.Indent)
 	rpc.RegisterRoutes(rs.CliCtx, rs.Mux)
 	tx.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc)
-	authRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, auth.StoreKey)
-	bankRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
-	distrRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, distr.StoreKey)
-	stakingRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
-	slashingRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
-	govRest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc)
+	authrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, auth.StoreKey)
+	bankrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
+	distrrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, distr.StoreKey)
+	stakingrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
+	slashingrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc, rs.KeyBase)
+	govrest.RegisterRoutes(rs.CliCtx, rs.Mux, rs.Cdc)
 }
 
 // Request makes a test LCD test request. It returns a response object and a
@@ -678,7 +685,7 @@ func doTransferWithGas(
 	kb := client.MockKeyBase()
 
 	receiveInfo, _, err := kb.CreateMnemonic(
-		"receive_address", cryptoKeys.English, gapp.DefaultKeyPass, cryptoKeys.SigningAlgo("secp256k1"),
+		"receive_address", crkeys.English, gapp.DefaultKeyPass, crkeys.SigningAlgo("secp256k1"),
 	)
 	require.Nil(t, err)
 
@@ -700,7 +707,7 @@ func doTransferWithGas(
 	)
 
 	sr := rest.SendReq{
-		Amount:  sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 1)},
+		Amount:  sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 1)},
 		BaseReq: baseReq,
 	}
 
@@ -720,7 +727,7 @@ func doTransferWithGasAccAuto(
 	kb := client.MockKeyBase()
 
 	receiveInfo, _, err := kb.CreateMnemonic(
-		"receive_address", cryptoKeys.English, gapp.DefaultKeyPass, cryptoKeys.SigningAlgo("secp256k1"),
+		"receive_address", crkeys.English, gapp.DefaultKeyPass, crkeys.SigningAlgo("secp256k1"),
 	)
 	require.Nil(t, err)
 
@@ -733,7 +740,7 @@ func doTransferWithGasAccAuto(
 	)
 
 	sr := rest.SendReq{
-		Amount:  sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 1)},
+		Amount:  sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 1)},
 		BaseReq: baseReq,
 	}
 
@@ -755,7 +762,8 @@ type sendReq struct {
 
 // POST /staking/delegators/{delegatorAddr}/delegations Submit delegation
 func doDelegate(t *testing.T, port, name, password string,
-	delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount int64, fees sdk.Coins) (resultTx sdk.TxResponse) {
+	delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount sdk.Int, fees sdk.Coins) (resultTx sdk.TxResponse) {
+
 	acc := getAccount(t, port, delAddr)
 	accnum := acc.GetAccountNumber()
 	sequence := acc.GetSequence()
@@ -765,7 +773,7 @@ func doDelegate(t *testing.T, port, name, password string,
 		BaseReq:       baseReq,
 		DelegatorAddr: delAddr,
 		ValidatorAddr: valAddr,
-		Delegation:    sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, amount),
+		Delegation:    sdk.NewCoin(staking.DefaultBondDenom, amount),
 	}
 	req, err := cdc.MarshalJSON(msg)
 	require.NoError(t, err)
@@ -788,7 +796,7 @@ type msgDelegationsInput struct {
 
 // POST /staking/delegators/{delegatorAddr}/delegations Submit delegation
 func doUndelegate(t *testing.T, port, name, password string,
-	delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount int64, fees sdk.Coins) (resultTx sdk.TxResponse) {
+	delAddr sdk.AccAddress, valAddr sdk.ValAddress, amount sdk.Int, fees sdk.Coins) (resultTx sdk.TxResponse) {
 
 	acc := getAccount(t, port, delAddr)
 	accnum := acc.GetAccountNumber()
@@ -799,7 +807,7 @@ func doUndelegate(t *testing.T, port, name, password string,
 		BaseReq:       baseReq,
 		DelegatorAddr: delAddr,
 		ValidatorAddr: valAddr,
-		SharesAmount:  sdk.NewDec(amount),
+		SharesAmount:  sdk.NewDecFromInt(amount),
 	}
 	req, err := cdc.MarshalJSON(msg)
 	require.NoError(t, err)
@@ -823,7 +831,8 @@ type msgUndelegateInput struct {
 
 // POST /staking/delegators/{delegatorAddr}/delegations Submit delegation
 func doBeginRedelegation(t *testing.T, port, name, password string,
-	delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress, amount int64, fees sdk.Coins) (resultTx sdk.TxResponse) {
+	delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress, amount sdk.Int,
+	fees sdk.Coins) (resultTx sdk.TxResponse) {
 
 	acc := getAccount(t, port, delAddr)
 	accnum := acc.GetAccountNumber()
@@ -837,7 +846,7 @@ func doBeginRedelegation(t *testing.T, port, name, password string,
 		DelegatorAddr:    delAddr,
 		ValidatorSrcAddr: valSrcAddr,
 		ValidatorDstAddr: valDstAddr,
-		SharesAmount:     sdk.NewDec(amount),
+		SharesAmount:     sdk.NewDecFromInt(amount),
 	}
 	req, err := cdc.MarshalJSON(msg)
 	require.NoError(t, err)
@@ -1056,7 +1065,9 @@ func getStakingParams(t *testing.T, port string) staking.Params {
 // ICS 22 - Gov
 // ----------------------------------------------------------------------
 // POST /gov/proposals Submit a proposal
-func doSubmitProposal(t *testing.T, port, seed, name, password string, proposerAddr sdk.AccAddress, amount int64, fees sdk.Coins) (resultTx sdk.TxResponse) {
+func doSubmitProposal(t *testing.T, port, seed, name, password string, proposerAddr sdk.AccAddress,
+	amount sdk.Int, fees sdk.Coins) (resultTx sdk.TxResponse) {
+
 	acc := getAccount(t, port, proposerAddr)
 	accnum := acc.GetAccountNumber()
 	sequence := acc.GetSequence()
@@ -1068,7 +1079,7 @@ func doSubmitProposal(t *testing.T, port, seed, name, password string, proposerA
 		Description:    "test",
 		ProposalType:   "Text",
 		Proposer:       proposerAddr,
-		InitialDeposit: sdk.Coins{sdk.NewCoin(stakingTypes.DefaultBondDenom, sdk.NewInt(amount))},
+		InitialDeposit: sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, amount)},
 		BaseReq:        baseReq,
 	}
 
@@ -1151,7 +1162,8 @@ func getProposalsFilterStatus(t *testing.T, port string, status gov.ProposalStat
 }
 
 // POST /gov/proposals/{proposalId}/deposits Deposit tokens to a proposal
-func doDeposit(t *testing.T, port, seed, name, password string, proposerAddr sdk.AccAddress, proposalID uint64, amount int64, fees sdk.Coins) (resultTx sdk.TxResponse) {
+func doDeposit(t *testing.T, port, seed, name, password string, proposerAddr sdk.AccAddress, proposalID uint64,
+	amount sdk.Int, fees sdk.Coins) (resultTx sdk.TxResponse) {
 
 	acc := getAccount(t, port, proposerAddr)
 	accnum := acc.GetAccountNumber()
@@ -1161,7 +1173,7 @@ func doDeposit(t *testing.T, port, seed, name, password string, proposerAddr sdk
 
 	dr := rest.DepositReq{
 		Depositor: proposerAddr,
-		Amount:    sdk.Coins{sdk.NewCoin(stakingTypes.DefaultBondDenom, sdk.NewInt(amount))},
+		Amount:    sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, amount)},
 		BaseReq:   baseReq,
 	}
 
diff --git a/cmd/gaia/app/genesis.go b/cmd/gaia/app/genesis.go
index 3eae8af87508..da71e750a0e0 100644
--- a/cmd/gaia/app/genesis.go
+++ b/cmd/gaia/app/genesis.go
@@ -23,14 +23,12 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/mint"
 	"github.com/cosmos/cosmos-sdk/x/slashing"
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 var (
 	// bonded tokens given to genesis validators/accounts
-	freeFermionVal  = int64(100)
-	freeFermionsAcc = sdk.NewInt(150)
-	bondDenom       = stakingTypes.DefaultBondDenom
+	freeFermionsAcc = staking.TokensFromTendermintPower(150)
+	bondDenom       = staking.DefaultBondDenom
 )
 
 // State to Unmarshal
diff --git a/cmd/gaia/app/genesis_test.go b/cmd/gaia/app/genesis_test.go
index 82829b699499..eb45112177ce 100644
--- a/cmd/gaia/app/genesis_test.go
+++ b/cmd/gaia/app/genesis_test.go
@@ -15,7 +15,6 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 var (
@@ -104,7 +103,7 @@ func TestGaiaAppGenState(t *testing.T) {
 
 func makeMsg(name string, pk crypto.PubKey) auth.StdTx {
 	desc := staking.NewDescription(name, "", "", "")
-	comm := stakingTypes.CommissionMsg{}
+	comm := staking.CommissionMsg{}
 	msg := staking.NewMsgCreateValidator(sdk.ValAddress(pk.Address()), pk, sdk.NewInt64Coin(bondDenom,
 		50), desc, comm)
 	return auth.NewStdTx([]sdk.Msg{msg}, auth.StdFee{}, nil, "")
@@ -131,7 +130,7 @@ func TestGaiaGenesisValidation(t *testing.T) {
 
 	// require bonded + jailed validator fails validation
 	genesisState = makeGenesisState(t, genTxs)
-	val1 := stakingTypes.NewValidator(addr1, pk1, stakingTypes.Description{Moniker: "test #2"})
+	val1 := staking.NewValidator(addr1, pk1, staking.NewDescription("test #2", "", "", ""))
 	val1.Jailed = true
 	val1.Status = sdk.Bonded
 	genesisState.StakingData.Validators = append(genesisState.StakingData.Validators, val1)
@@ -141,7 +140,7 @@ func TestGaiaGenesisValidation(t *testing.T) {
 	// require duplicate validator fails validation
 	val1.Jailed = false
 	genesisState = makeGenesisState(t, genTxs)
-	val2 := stakingTypes.NewValidator(addr1, pk1, stakingTypes.Description{Moniker: "test #3"})
+	val2 := staking.NewValidator(addr1, pk1, staking.NewDescription("test #3", "", "", ""))
 	genesisState.StakingData.Validators = append(genesisState.StakingData.Validators, val1)
 	genesisState.StakingData.Validators = append(genesisState.StakingData.Validators, val2)
 	err = GaiaValidateGenesisState(genesisState)
@@ -152,7 +151,7 @@ func TestNewDefaultGenesisAccount(t *testing.T) {
 	addr := secp256k1.GenPrivKeySecp256k1([]byte("")).PubKey().Address()
 	acc := NewDefaultGenesisAccount(sdk.AccAddress(addr))
 	require.Equal(t, sdk.NewInt(1000), acc.Coins.AmountOf("footoken"))
-	require.Equal(t, sdk.NewInt(150), acc.Coins.AmountOf(bondDenom))
+	require.Equal(t, staking.TokensFromTendermintPower(150), acc.Coins.AmountOf(bondDenom))
 }
 
 func TestGenesisStateSanitize(t *testing.T) {
diff --git a/cmd/gaia/app/sim_test.go b/cmd/gaia/app/sim_test.go
index 860404a56355..60ba58322f62 100644
--- a/cmd/gaia/app/sim_test.go
+++ b/cmd/gaia/app/sim_test.go
@@ -34,7 +34,6 @@ import (
 	slashingsim "github.com/cosmos/cosmos-sdk/x/slashing/simulation"
 	"github.com/cosmos/cosmos-sdk/x/staking"
 	stakingsim "github.com/cosmos/cosmos-sdk/x/staking/simulation"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 var (
@@ -98,7 +97,7 @@ func appStateRandomizedFn(r *rand.Rand, accs []simulation.Account, genesisTimest
 
 	// randomly generate some genesis accounts
 	for i, acc := range accs {
-		coins := sdk.Coins{sdk.NewCoin(stakingTypes.DefaultBondDenom, sdk.NewInt(amount))}
+		coins := sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(amount))}
 		bacc := auth.NewBaseAccountWithAddress(acc.Address)
 		bacc.SetCoins(coins)
 
@@ -155,7 +154,7 @@ func appStateRandomizedFn(r *rand.Rand, accs []simulation.Account, genesisTimest
 	govGenesis := gov.GenesisState{
 		StartingProposalID: uint64(r.Intn(100)),
 		DepositParams: gov.DepositParams{
-			MinDeposit:       sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, int64(r.Intn(1e3)))},
+			MinDeposit:       sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, int64(r.Intn(1e3)))},
 			MaxDepositPeriod: vp,
 		},
 		VotingParams: gov.VotingParams{
@@ -174,7 +173,7 @@ func appStateRandomizedFn(r *rand.Rand, accs []simulation.Account, genesisTimest
 		Params: staking.Params{
 			UnbondingTime: time.Duration(randIntBetween(r, 60, 60*60*24*3*2)) * time.Second,
 			MaxValidators: uint16(r.Intn(250)),
-			BondDenom:     stakingTypes.DefaultBondDenom,
+			BondDenom:     staking.DefaultBondDenom,
 		},
 	}
 	fmt.Printf("Selected randomly generated staking parameters:\n\t%+v\n", stakingGenesis)
@@ -195,7 +194,7 @@ func appStateRandomizedFn(r *rand.Rand, accs []simulation.Account, genesisTimest
 		Minter: mint.InitialMinter(
 			sdk.NewDecWithPrec(int64(r.Intn(99)), 2)),
 		Params: mint.NewParams(
-			stakingTypes.DefaultBondDenom,
+			staking.DefaultBondDenom,
 			sdk.NewDecWithPrec(int64(r.Intn(99)), 2),
 			sdk.NewDecWithPrec(20, 2),
 			sdk.NewDecWithPrec(7, 2),
diff --git a/cmd/gaia/cli_test/cli_test.go b/cmd/gaia/cli_test/cli_test.go
index 2139f1fd00a2..aefb2ab7fe72 100644
--- a/cmd/gaia/cli_test/cli_test.go
+++ b/cmd/gaia/cli_test/cli_test.go
@@ -20,7 +20,6 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 func TestGaiaCLIKeysAddMultisig(t *testing.T) {
@@ -167,8 +166,9 @@ func TestGaiaCLIFeesDeduction(t *testing.T) {
 	require.Equal(t, fooAmt.Int64(), fooAcc.GetCoins().AmountOf(fooDenom).Int64())
 
 	// insufficient funds (coins + fees) tx fails
+	largeCoins := staking.TokensFromTendermintPower(10000000)
 	success, _, _ = f.TxSend(
-		keyFoo, barAddr, sdk.NewInt64Coin(fooDenom, 10000000),
+		keyFoo, barAddr, sdk.NewCoin(fooDenom, largeCoins),
 		fmt.Sprintf("--fees=%s", sdk.NewInt64Coin(feeDenom, 2)))
 	require.False(t, success)
 
@@ -201,45 +201,47 @@ func TestGaiaCLISend(t *testing.T) {
 	barAddr := f.KeyAddress(keyBar)
 
 	fooAcc := f.QueryAccount(fooAddr)
-	require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
+	startTokens := staking.TokensFromTendermintPower(50)
+	require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
 
 	// Send some tokens from one account to the other
-	f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10))
+	sendTokens := staking.TokensFromTendermintPower(10)
+	f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens))
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// Ensure account balances match expected
 	barAcc := f.QueryAccount(barAddr)
-	require.Equal(t, int64(10), barAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, sendTokens, barAcc.GetCoins().AmountOf(denom))
 	fooAcc = f.QueryAccount(fooAddr)
-	require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, startTokens.Sub(sendTokens), fooAcc.GetCoins().AmountOf(denom))
 
 	// Test --dry-run
-	success, _, _ := f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--dry-run")
+	success, _, _ := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--dry-run")
 	require.True(t, success)
 
 	// Check state didn't change
 	fooAcc = f.QueryAccount(fooAddr)
-	require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, startTokens.Sub(sendTokens), fooAcc.GetCoins().AmountOf(denom))
 
 	// test autosequencing
-	f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10))
+	f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens))
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// Ensure account balances match expected
 	barAcc = f.QueryAccount(barAddr)
-	require.Equal(t, int64(20), barAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, sendTokens.MulRaw(2), barAcc.GetCoins().AmountOf(denom))
 	fooAcc = f.QueryAccount(fooAddr)
-	require.Equal(t, int64(30), fooAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, startTokens.Sub(sendTokens.MulRaw(2)), fooAcc.GetCoins().AmountOf(denom))
 
 	// test memo
-	f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--memo='testmemo'")
+	f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--memo='testmemo'")
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// Ensure account balances match expected
 	barAcc = f.QueryAccount(barAddr)
-	require.Equal(t, int64(30), barAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, sendTokens.MulRaw(3), barAcc.GetCoins().AmountOf(denom))
 	fooAcc = f.QueryAccount(fooAddr)
-	require.Equal(t, int64(20), fooAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, startTokens.Sub(sendTokens.MulRaw(3)), fooAcc.GetCoins().AmountOf(denom))
 
 	f.Cleanup()
 }
@@ -256,34 +258,36 @@ func TestGaiaCLIGasAuto(t *testing.T) {
 	barAddr := f.KeyAddress(keyBar)
 
 	fooAcc := f.QueryAccount(fooAddr)
-	require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
+	startTokens := staking.TokensFromTendermintPower(50)
+	require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
 
 	// Test failure with auto gas disabled and very little gas set by hand
-	success, _, _ := f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=10")
+	sendTokens := staking.TokensFromTendermintPower(10)
+	success, _, _ := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=10")
 	require.False(t, success)
 
 	// Check state didn't change
 	fooAcc = f.QueryAccount(fooAddr)
-	require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
 
 	// Test failure with negative gas
-	success, _, _ = f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=-100")
+	success, _, _ = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=-100")
 	require.False(t, success)
 
 	// Check state didn't change
 	fooAcc = f.QueryAccount(fooAddr)
-	require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
 
 	// Test failure with 0 gas
-	success, _, _ = f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=0")
+	success, _, _ = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=0")
 	require.False(t, success)
 
 	// Check state didn't change
 	fooAcc = f.QueryAccount(fooAddr)
-	require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
 
 	// Enable auto gas
-	success, stdout, stderr := f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=auto")
+	success, stdout, stderr := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=auto")
 	require.NotEmpty(t, stderr)
 	require.True(t, success)
 	cdc := app.MakeCodec()
@@ -295,7 +299,7 @@ func TestGaiaCLIGasAuto(t *testing.T) {
 
 	// Check state has changed accordingly
 	fooAcc = f.QueryAccount(fooAddr)
-	require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, startTokens.Sub(sendTokens), fooAcc.GetCoins().AmountOf(denom))
 
 	f.Cleanup()
 }
@@ -308,23 +312,17 @@ func TestGaiaCLICreateValidator(t *testing.T) {
 	proc := f.GDStart()
 	defer proc.Stop(false)
 
-	fooAddr := f.KeyAddress(keyFoo)
 	barAddr := f.KeyAddress(keyBar)
 	barVal := sdk.ValAddress(barAddr)
 
 	consPubKey := sdk.MustBech32ifyConsPub(ed25519.GenPrivKey().PubKey())
 
-	f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10))
+	sendTokens := staking.TokensFromTendermintPower(10)
+	f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens))
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	barAcc := f.QueryAccount(barAddr)
-	require.Equal(t, int64(10), barAcc.GetCoins().AmountOf(denom).Int64())
-	fooAcc := f.QueryAccount(fooAddr)
-	require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(denom).Int64())
-
-	defaultParams := staking.DefaultParams()
-	initialPool := staking.InitialPool()
-	initialPool.BondedTokens = initialPool.BondedTokens.Add(sdk.NewInt(101)) // Delegate tx on GaiaAppGenState
+	require.Equal(t, sendTokens, barAcc.GetCoins().AmountOf(denom))
 
 	// Generate a create validator transaction and ensure correctness
 	success, stdout, stderr := f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewInt64Coin(denom, 2), "--generate-only")
@@ -337,21 +335,22 @@ func TestGaiaCLICreateValidator(t *testing.T) {
 	require.Equal(t, 0, len(msg.GetSignatures()))
 
 	// Test --dry-run
-	success, _, _ = f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewInt64Coin(denom, 2), "--dry-run")
+	newValTokens := staking.TokensFromTendermintPower(2)
+	success, _, _ = f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewCoin(denom, newValTokens), "--dry-run")
 	require.True(t, success)
 
 	// Create the validator
-	f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewInt64Coin(denom, 2))
+	f.TxStakingCreateValidator(keyBar, consPubKey, sdk.NewCoin(denom, newValTokens))
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// Ensure funds were deducted properly
 	barAcc = f.QueryAccount(barAddr)
-	require.Equal(t, int64(8), barAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, sendTokens.Sub(newValTokens), barAcc.GetCoins().AmountOf(denom))
 
 	// Ensure that validator state is as expected
 	validator := f.QueryStakingValidator(barVal)
 	require.Equal(t, validator.OperatorAddr, barVal)
-	require.True(sdk.IntEq(t, sdk.NewInt(2), validator.Tokens))
+	require.True(sdk.IntEq(t, newValTokens, validator.Tokens))
 
 	// Query delegations to the validator
 	validatorDelegations := f.QueryStakingDelegationsTo(barVal)
@@ -359,27 +358,21 @@ func TestGaiaCLICreateValidator(t *testing.T) {
 	require.NotZero(t, validatorDelegations[0].Shares)
 
 	// unbond a single share
-	success = f.TxStakingUnbond(keyBar, "1", barVal)
+	unbondTokens := staking.TokensFromTendermintPower(1)
+	success = f.TxStakingUnbond(keyBar, unbondTokens.String(), barVal)
 	require.True(t, success)
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// Ensure bonded staking is correct
+	remainingTokens := newValTokens.Sub(unbondTokens)
 	validator = f.QueryStakingValidator(barVal)
-	require.Equal(t, "1", validator.Tokens.String())
+	require.Equal(t, remainingTokens, validator.Tokens)
 
 	// Get unbonding delegations from the validator
 	validatorUbds := f.QueryStakingUnbondingDelegationsFrom(barVal)
 	require.Len(t, validatorUbds, 1)
 	require.Len(t, validatorUbds[0].Entries, 1)
-	require.Equal(t, "1", validatorUbds[0].Entries[0].Balance.Amount.String())
-
-	// Query staking parameters
-	params := f.QueryStakingParameters()
-	require.True(t, defaultParams.Equal(params))
-
-	// Query staking pool
-	pool := f.QueryStakingPool()
-	require.Equal(t, initialPool.BondedTokens, pool.BondedTokens)
+	require.Equal(t, remainingTokens.String(), validatorUbds[0].Entries[0].Balance.Amount.String())
 
 	f.Cleanup()
 }
@@ -399,14 +392,16 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 	fooAddr := f.KeyAddress(keyFoo)
 
 	fooAcc := f.QueryAccount(fooAddr)
-	require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom).Int64())
+	startTokens := staking.TokensFromTendermintPower(50)
+	require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(staking.DefaultBondDenom))
 
 	proposalsQuery := f.QueryGovProposals()
 	require.Empty(t, proposalsQuery)
 
 	// Test submit generate only for submit proposal
+	proposalTokens := staking.TokensFromTendermintPower(5)
 	success, stdout, stderr := f.TxGovSubmitProposal(
-		keyFoo, "Text", "Test", "test", sdk.NewInt64Coin(denom, 5), "--generate-only")
+		keyFoo, "Text", "Test", "test", sdk.NewCoin(denom, proposalTokens), "--generate-only")
 	require.True(t, success)
 	require.Empty(t, stderr)
 	msg := unmarshalStdTx(t, stdout)
@@ -415,11 +410,11 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 	require.Equal(t, 0, len(msg.GetSignatures()))
 
 	// Test --dry-run
-	success, _, _ = f.TxGovSubmitProposal(keyFoo, "Text", "Test", "test", sdk.NewInt64Coin(denom, 5), "--dry-run")
+	success, _, _ = f.TxGovSubmitProposal(keyFoo, "Text", "Test", "test", sdk.NewCoin(denom, proposalTokens), "--dry-run")
 	require.True(t, success)
 
 	// Create the proposal
-	f.TxGovSubmitProposal(keyFoo, "Text", "Test", "test", sdk.NewInt64Coin(denom, 5))
+	f.TxGovSubmitProposal(keyFoo, "Text", "Test", "test", sdk.NewCoin(denom, proposalTokens))
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// Ensure transaction tags can be queried
@@ -428,7 +423,7 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 
 	// Ensure deposit was deducted
 	fooAcc = f.QueryAccount(fooAddr)
-	require.Equal(t, int64(45), fooAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, startTokens.Sub(proposalTokens), fooAcc.GetCoins().AmountOf(denom))
 
 	// Ensure propsal is directly queryable
 	proposal1 := f.QueryGovProposal(1)
@@ -441,10 +436,11 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 
 	// Query the deposits on the proposal
 	deposit := f.QueryGovDeposit(1, fooAddr)
-	require.Equal(t, int64(5), deposit.Amount.AmountOf(denom).Int64())
+	require.Equal(t, proposalTokens, deposit.Amount.AmountOf(denom))
 
 	// Test deposit generate only
-	success, stdout, stderr = f.TxGovDeposit(1, keyFoo, sdk.NewInt64Coin(denom, 10), "--generate-only")
+	depositTokens := staking.TokensFromTendermintPower(10)
+	success, stdout, stderr = f.TxGovDeposit(1, keyFoo, sdk.NewCoin(denom, depositTokens), "--generate-only")
 	require.True(t, success)
 	require.Empty(t, stderr)
 	msg = unmarshalStdTx(t, stdout)
@@ -453,17 +449,17 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 	require.Equal(t, 0, len(msg.GetSignatures()))
 
 	// Run the deposit transaction
-	f.TxGovDeposit(1, keyFoo, sdk.NewInt64Coin(denom, 10))
+	f.TxGovDeposit(1, keyFoo, sdk.NewCoin(denom, depositTokens))
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// test query deposit
 	deposits := f.QueryGovDeposits(1)
 	require.Len(t, deposits, 1)
-	require.Equal(t, int64(15), deposits[0].Amount.AmountOf(denom).Int64())
+	require.Equal(t, proposalTokens.Add(depositTokens), deposits[0].Amount.AmountOf(denom))
 
 	// Ensure querying the deposit returns the proper amount
 	deposit = f.QueryGovDeposit(1, fooAddr)
-	require.Equal(t, int64(15), deposit.Amount.AmountOf(denom).Int64())
+	require.Equal(t, proposalTokens.Add(depositTokens), deposit.Amount.AmountOf(denom))
 
 	// Ensure tags are set on the transaction
 	txs = f.QueryTxs(1, 50, "action:deposit", fmt.Sprintf("depositor:%s", fooAddr))
@@ -471,7 +467,7 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 
 	// Ensure account has expected amount of funds
 	fooAcc = f.QueryAccount(fooAddr)
-	require.Equal(t, int64(35), fooAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, startTokens.Sub(proposalTokens.Add(depositTokens)), fooAcc.GetCoins().AmountOf(denom))
 
 	// Fetch the proposal and ensure it is now in the voting period
 	proposal1 = f.QueryGovProposal(1)
@@ -515,7 +511,7 @@ func TestGaiaCLISubmitProposal(t *testing.T) {
 	require.Equal(t, uint64(1), proposalsQuery[0].GetProposalID())
 
 	// submit a second test proposal
-	f.TxGovSubmitProposal(keyFoo, "Text", "Apples", "test", sdk.NewInt64Coin(denom, 5))
+	f.TxGovSubmitProposal(keyFoo, "Text", "Apples", "test", sdk.NewCoin(denom, proposalTokens))
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// Test limit on proposals query
@@ -635,7 +631,8 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
 	barAddr := f.KeyAddress(keyBar)
 
 	// Test generate sendTx with default gas
-	success, stdout, stderr := f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--generate-only")
+	sendTokens := staking.TokensFromTendermintPower(10)
+	success, stdout, stderr := f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--generate-only")
 	require.True(t, success)
 	require.Empty(t, stderr)
 	msg := unmarshalStdTx(t, stdout)
@@ -644,7 +641,7 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
 	require.Equal(t, 0, len(msg.GetSignatures()))
 
 	// Test generate sendTx with --gas=$amount
-	success, stdout, stderr = f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=100", "--generate-only")
+	success, stdout, stderr = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=100", "--generate-only")
 	require.True(t, success)
 	require.Empty(t, stderr)
 	msg = unmarshalStdTx(t, stdout)
@@ -653,7 +650,7 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
 	require.Equal(t, 0, len(msg.GetSignatures()))
 
 	// Test generate sendTx, estimate gas
-	success, stdout, stderr = f.TxSend(keyFoo, barAddr, sdk.NewInt64Coin(denom, 10), "--gas=auto", "--generate-only")
+	success, stdout, stderr = f.TxSend(keyFoo, barAddr, sdk.NewCoin(denom, sendTokens), "--gas=auto", "--generate-only")
 	require.True(t, success)
 	require.NotEmpty(t, stderr)
 	msg = unmarshalStdTx(t, stdout)
@@ -689,7 +686,8 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
 
 	// Ensure foo has right amount of funds
 	fooAcc := f.QueryAccount(fooAddr)
-	require.Equal(t, int64(50), fooAcc.GetCoins().AmountOf(denom).Int64())
+	startTokens := staking.TokensFromTendermintPower(50)
+	require.Equal(t, startTokens, fooAcc.GetCoins().AmountOf(denom))
 
 	// Test broadcast
 	success, stdout, _ = f.TxBroadcast(signedTxFile.Name())
@@ -706,8 +704,8 @@ func TestGaiaCLISendGenerateSignAndBroadcast(t *testing.T) {
 	// Ensure account state
 	barAcc := f.QueryAccount(barAddr)
 	fooAcc = f.QueryAccount(fooAddr)
-	require.Equal(t, int64(10), barAcc.GetCoins().AmountOf(denom).Int64())
-	require.Equal(t, int64(40), fooAcc.GetCoins().AmountOf(denom).Int64())
+	require.Equal(t, sendTokens, barAcc.GetCoins().AmountOf(denom))
+	require.Equal(t, startTokens.Sub(sendTokens), fooAcc.GetCoins().AmountOf(denom))
 
 	f.Cleanup()
 }
diff --git a/cmd/gaia/cli_test/test_helpers.go b/cmd/gaia/cli_test/test_helpers.go
index 5a206a997807..d4941fbbdb05 100644
--- a/cmd/gaia/cli_test/test_helpers.go
+++ b/cmd/gaia/cli_test/test_helpers.go
@@ -38,10 +38,10 @@ const (
 )
 
 var startCoins = sdk.Coins{
-	sdk.NewInt64Coin(feeDenom, 1000000),
-	sdk.NewInt64Coin(fee2Denom, 1000000),
-	sdk.NewInt64Coin(fooDenom, 1000),
-	sdk.NewInt64Coin(denom, 150),
+	sdk.NewCoin(feeDenom, staking.TokensFromTendermintPower(1000000)),
+	sdk.NewCoin(fee2Denom, staking.TokensFromTendermintPower(1000000)),
+	sdk.NewCoin(fooDenom, staking.TokensFromTendermintPower(1000)),
+	sdk.NewCoin(denom, staking.TokensFromTendermintPower(150)),
 }
 
 //___________________________________________________________________________________
diff --git a/cmd/gaia/init/gentx.go b/cmd/gaia/init/gentx.go
index ec3ae3573946..d212808548dd 100644
--- a/cmd/gaia/init/gentx.go
+++ b/cmd/gaia/init/gentx.go
@@ -26,12 +26,13 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
+	"github.com/cosmos/cosmos-sdk/x/staking"
 	"github.com/cosmos/cosmos-sdk/x/staking/client/cli"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
-const (
-	defaultAmount                  = "100" + stakingTypes.DefaultBondDenom
+var (
+	defaultTokens                  = staking.TokensFromTendermintPower(100)
+	defaultAmount                  = defaultTokens.String() + staking.DefaultBondDenom
 	defaultCommissionRate          = "0.1"
 	defaultCommissionMaxRate       = "0.2"
 	defaultCommissionMaxChangeRate = "0.01"
diff --git a/cmd/gaia/init/testnet.go b/cmd/gaia/init/testnet.go
index c69384a2d659..7ce8115689c6 100644
--- a/cmd/gaia/init/testnet.go
+++ b/cmd/gaia/init/testnet.go
@@ -188,18 +188,21 @@ func initTestnet(config *tmconfig.Config, cdc *codec.Codec) error {
 			return err
 		}
 
+		accTokens := staking.TokensFromTendermintPower(1000)
+		accStakingTokens := staking.TokensFromTendermintPower(500)
 		accs = append(accs, app.GenesisAccount{
 			Address: addr,
 			Coins: sdk.Coins{
-				sdk.NewInt64Coin(fmt.Sprintf("%stoken", nodeDirName), 1000),
-				sdk.NewInt64Coin(stakingtypes.DefaultBondDenom, 500),
+				sdk.NewCoin(fmt.Sprintf("%stoken", nodeDirName), accTokens),
+				sdk.NewCoin(stakingtypes.DefaultBondDenom, accStakingTokens),
 			},
 		})
 
+		valTokens := staking.TokensFromTendermintPower(100)
 		msg := staking.NewMsgCreateValidator(
 			sdk.ValAddress(addr),
 			valPubKeys[i],
-			sdk.NewInt64Coin(stakingtypes.DefaultBondDenom, 100),
+			sdk.NewCoin(stakingtypes.DefaultBondDenom, valTokens),
 			staking.NewDescription(nodeDirName, "", "", ""),
 			staking.NewCommissionMsg(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()),
 		)
diff --git a/types/decimal.go b/types/decimal.go
index 976ddd560e79..5f59a0f54857 100644
--- a/types/decimal.go
+++ b/types/decimal.go
@@ -249,6 +249,16 @@ func (d Dec) MulInt(i Int) Dec {
 	return Dec{mul}
 }
 
+// MulInt64 - multiplication with int64
+func (d Dec) MulInt64(i int64) Dec {
+	mul := new(big.Int).Mul(d.Int, big.NewInt(i))
+
+	if mul.BitLen() > 255+DecimalPrecisionBits {
+		panic("Int overflow")
+	}
+	return Dec{mul}
+}
+
 // quotient
 func (d Dec) Quo(d2 Dec) Dec {
 
@@ -287,6 +297,12 @@ func (d Dec) QuoInt(i Int) Dec {
 	return Dec{mul}
 }
 
+// QuoInt64 - quotient with int64
+func (d Dec) QuoInt64(i int64) Dec {
+	mul := new(big.Int).Quo(d.Int, big.NewInt(i))
+	return Dec{mul}
+}
+
 // is integer, e.g. decimals are zero
 func (d Dec) IsInteger() bool {
 	return new(big.Int).Rem(d.Int, precisionReuse).Sign() == 0
diff --git a/types/stake.go b/types/stake.go
index 25c02d8489d4..cd3e442a6300 100644
--- a/types/stake.go
+++ b/types/stake.go
@@ -42,8 +42,9 @@ type Validator interface {
 	GetOperator() ValAddress      // operator address to receive/return validators coins
 	GetConsPubKey() crypto.PubKey // validation consensus pubkey
 	GetConsAddr() ConsAddress     // validation consensus address
-	GetPower() Int                // validation power
 	GetTokens() Int               // validation tokens
+	GetBondedTokens() Int         // validator bonded tokens
+	GetTendermintPower() int64    // validation power in tendermint
 	GetCommission() Dec           // validator commission rate
 	GetDelegatorShares() Dec      // total outstanding delegator shares
 	GetBondHeight() int64         // height in which the validator became active
@@ -54,7 +55,7 @@ type Validator interface {
 func ABCIValidator(v Validator) abci.Validator {
 	return abci.Validator{
 		Address: v.GetConsPubKey().Address(),
-		Power:   v.GetPower().Int64(),
+		Power:   v.GetTendermintPower(),
 	}
 }
 
diff --git a/x/auth/ante.go b/x/auth/ante.go
index bc39f5323af3..37f159536718 100644
--- a/x/auth/ante.go
+++ b/x/auth/ante.go
@@ -342,7 +342,7 @@ func EnsureSufficientMempoolFees(ctx sdk.Context, stdFee StdFee) sdk.Result {
 		glDec := sdk.NewDec(int64(stdFee.Gas))
 		for i, gp := range minGasPrices {
 			fee := gp.Amount.Mul(glDec)
-			requiredFees[i] = sdk.NewInt64Coin(gp.Denom, fee.Ceil().RoundInt64())
+			requiredFees[i] = sdk.NewCoin(gp.Denom, fee.Ceil().RoundInt())
 		}
 
 		if !stdFee.Amount.IsAllGTE(requiredFees) {
diff --git a/x/auth/client/txbuilder/txbuilder.go b/x/auth/client/txbuilder/txbuilder.go
index 331d811ba959..df8bb97829c0 100644
--- a/x/auth/client/txbuilder/txbuilder.go
+++ b/x/auth/client/txbuilder/txbuilder.go
@@ -177,7 +177,7 @@ func (bldr TxBuilder) Build(msgs []sdk.Msg) (StdSignMsg, error) {
 		fees = make(sdk.Coins, len(bldr.gasPrices))
 		for i, gp := range bldr.gasPrices {
 			fee := gp.Amount.Mul(glDec)
-			fees[i] = sdk.NewInt64Coin(gp.Denom, fee.Ceil().RoundInt64())
+			fees[i] = sdk.NewCoin(gp.Denom, fee.Ceil().RoundInt())
 		}
 	}
 
diff --git a/x/distribution/keeper/delegation_test.go b/x/distribution/keeper/delegation_test.go
index 3f601ad32974..fb0cda012c9c 100644
--- a/x/distribution/keeper/delegation_test.go
+++ b/x/distribution/keeper/delegation_test.go
@@ -71,9 +71,12 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
 
 	// create validator with 50% commission
 	commission := staking.NewCommissionMsg(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
+	valPower := int64(100)
+	valTokens := staking.TokensFromTendermintPower(valPower)
 	msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
-		sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(100)), staking.Description{}, commission)
-	require.True(t, sh(ctx, msg).IsOK())
+		sdk.NewCoin(staking.DefaultBondDenom, valTokens), staking.Description{}, commission)
+	got := sh(ctx, msg)
+	require.True(t, got.IsOK(), "%v", got)
 
 	// end block to bond validator
 	staking.EndBlocker(ctx, sk)
@@ -95,7 +98,7 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// slash the validator by 50%
-	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 100, sdk.NewDecWithPrec(5, 1))
+	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), valPower, sdk.NewDecWithPrec(5, 1))
 
 	// retrieve validator
 	val = sk.Validator(ctx, valOpAddr1)
@@ -104,8 +107,8 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// allocate some rewards
-	initial := int64(10)
-	tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}
+	initial := staking.TokensFromTendermintPower(10)
+	tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial)}}
 	k.AllocateTokensToValidator(ctx, val, tokens)
 
 	// end period
@@ -115,10 +118,11 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
 	rewards = k.calculateDelegationRewards(ctx, val, del, endingPeriod)
 
 	// rewards should be half the tokens
-	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial / 2)}}, rewards)
+	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial.DivRaw(2))}}, rewards)
 
 	// commission should be the other half
-	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial / 2)}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
+	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial.DivRaw(2))}},
+		k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
 }
 
 func TestCalculateRewardsAfterManySlashes(t *testing.T) {
@@ -129,9 +133,11 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
 	k.SetOutstandingRewards(ctx, sdk.DecCoins{})
 
 	// create validator with 50% commission
+	power := int64(100)
+	valTokens := staking.TokensFromTendermintPower(power)
 	commission := staking.NewCommissionMsg(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
 	msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
-		sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(100)), staking.Description{}, commission)
+		sdk.NewCoin(staking.DefaultBondDenom, valTokens), staking.Description{}, commission)
 	require.True(t, sh(ctx, msg).IsOK())
 
 	// end block to bond validator
@@ -154,7 +160,7 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// slash the validator by 50%
-	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 100, sdk.NewDecWithPrec(5, 1))
+	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
 
 	// fetch the validator again
 	val = sk.Validator(ctx, valOpAddr1)
@@ -163,12 +169,12 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// allocate some rewards
-	initial := int64(10)
-	tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}
+	initial := staking.TokensFromTendermintPower(10)
+	tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial)}}
 	k.AllocateTokensToValidator(ctx, val, tokens)
 
 	// slash the validator by 50% again
-	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 50, sdk.NewDecWithPrec(5, 1))
+	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power/2, sdk.NewDecWithPrec(5, 1))
 
 	// fetch the validator again
 	val = sk.Validator(ctx, valOpAddr1)
@@ -186,10 +192,11 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
 	rewards = k.calculateDelegationRewards(ctx, val, del, endingPeriod)
 
 	// rewards should be half the tokens
-	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}, rewards)
+	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial)}}, rewards)
 
 	// commission should be the other half
-	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
+	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial)}},
+		k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
 }
 
 func TestCalculateRewardsMultiDelegator(t *testing.T) {
@@ -251,22 +258,27 @@ func TestCalculateRewardsMultiDelegator(t *testing.T) {
 }
 
 func TestWithdrawDelegationRewardsBasic(t *testing.T) {
-	balance := int64(1000)
-	ctx, ak, k, sk, _ := CreateTestInputDefault(t, false, balance)
+	balancePower := int64(1000)
+	balanceTokens := staking.TokensFromTendermintPower(balancePower)
+	ctx, ak, k, sk, _ := CreateTestInputDefault(t, false, balancePower)
 	sh := staking.NewHandler(sk)
 
 	// initialize state
 	k.SetOutstandingRewards(ctx, sdk.DecCoins{})
 
 	// create validator with 50% commission
-	bond := int64(100)
+	power := int64(100)
+	valTokens := staking.TokensFromTendermintPower(power)
 	commission := staking.NewCommissionMsg(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
 	msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
-		sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(bond)), staking.Description{}, commission)
+		sdk.NewCoin(staking.DefaultBondDenom, valTokens), staking.Description{}, commission)
 	require.True(t, sh(ctx, msg).IsOK())
 
 	// assert correct initial balance
-	require.Equal(t, sdk.Coins{{staking.DefaultBondDenom, sdk.NewInt(balance - bond)}}, ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
+	expTokens := balanceTokens.Sub(valTokens)
+	require.Equal(t,
+		sdk.Coins{{staking.DefaultBondDenom, expTokens}},
+		ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
 
 	// end block to bond validator
 	staking.EndBlocker(ctx, sk)
@@ -278,8 +290,8 @@ func TestWithdrawDelegationRewardsBasic(t *testing.T) {
 	val := sk.Validator(ctx, valOpAddr1)
 
 	// allocate some rewards
-	initial := int64(10)
-	tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}
+	initial := staking.TokensFromTendermintPower(10)
+	tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDecFromInt(initial)}}
 	k.AllocateTokensToValidator(ctx, val, tokens)
 
 	// historical count should be 2 (initial + latest for delegation)
@@ -292,13 +304,15 @@ func TestWithdrawDelegationRewardsBasic(t *testing.T) {
 	require.Equal(t, uint64(2), k.GetValidatorHistoricalReferenceCount(ctx))
 
 	// assert correct balance
-	require.Equal(t, sdk.Coins{{staking.DefaultBondDenom, sdk.NewInt(balance - bond + (initial / 2))}}, ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
+	exp := balanceTokens.Sub(valTokens).Add(initial.DivRaw(2))
+	require.Equal(t, sdk.Coins{{staking.DefaultBondDenom, exp}}, ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
 
 	// withdraw commission
 	require.Nil(t, k.WithdrawValidatorCommission(ctx, valOpAddr1))
 
 	// assert correct balance
-	require.Equal(t, sdk.Coins{{staking.DefaultBondDenom, sdk.NewInt(balance - bond + initial)}}, ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
+	exp = balanceTokens.Sub(valTokens).Add(initial)
+	require.Equal(t, sdk.Coins{{staking.DefaultBondDenom, exp}}, ak.GetAccount(ctx, sdk.AccAddress(valOpAddr1)).GetCoins())
 }
 
 func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
@@ -309,9 +323,11 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
 	k.SetOutstandingRewards(ctx, sdk.DecCoins{})
 
 	// create validator with 50% commission
+	power := int64(100)
+	valTokens := staking.TokensFromTendermintPower(power)
 	commission := staking.NewCommissionMsg(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
 	msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
-		sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(100)), staking.Description{}, commission)
+		sdk.NewCoin(staking.DefaultBondDenom, valTokens), staking.Description{}, commission)
 	require.True(t, sh(ctx, msg).IsOK())
 
 	// end block to bond validator
@@ -334,15 +350,15 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// allocate some rewards
-	initial := int64(10)
-	tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}
+	initial := sdk.NewDecFromInt(staking.TokensFromTendermintPower(10))
+	tokens := sdk.DecCoins{{staking.DefaultBondDenom, initial}}
 	k.AllocateTokensToValidator(ctx, val, tokens)
 
 	// slash the validator by 50%
-	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 100, sdk.NewDecWithPrec(5, 1))
+	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
 
 	// slash the validator by 50% again
-	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 50, sdk.NewDecWithPrec(5, 1))
+	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power/2, sdk.NewDecWithPrec(5, 1))
 
 	// fetch the validator again
 	val = sk.Validator(ctx, valOpAddr1)
@@ -360,10 +376,10 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
 	rewards = k.calculateDelegationRewards(ctx, val, del, endingPeriod)
 
 	// rewards should be half the tokens
-	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}, rewards)
+	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, initial}}, rewards)
 
 	// commission should be the other half
-	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
+	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, initial}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
 }
 
 func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
@@ -375,8 +391,10 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
 
 	// create validator with 50% commission
 	commission := staking.NewCommissionMsg(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), sdk.NewDec(0))
+	power := int64(100)
+	valTokens := staking.TokensFromTendermintPower(power)
 	msg := staking.NewMsgCreateValidator(valOpAddr1, valConsPk1,
-		sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(100)), staking.Description{}, commission)
+		sdk.NewCoin(staking.DefaultBondDenom, valTokens), staking.Description{}, commission)
 	require.True(t, sh(ctx, msg).IsOK())
 
 	// end block to bond validator
@@ -387,17 +405,19 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
 	del1 := sk.Delegation(ctx, sdk.AccAddress(valOpAddr1), valOpAddr1)
 
 	// allocate some rewards
-	initial := int64(30)
-	tokens := sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}
+	initial := sdk.NewDecFromInt(staking.TokensFromTendermintPower(30))
+	tokens := sdk.DecCoins{{staking.DefaultBondDenom, initial}}
 	k.AllocateTokensToValidator(ctx, val, tokens)
 
 	// slash the validator
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
-	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 100, sdk.NewDecWithPrec(5, 1))
+	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// second delegation
-	msg2 := staking.NewMsgDelegate(sdk.AccAddress(valOpAddr2), valOpAddr1, sdk.NewCoin(staking.DefaultBondDenom, sdk.NewInt(100)))
+	delTokens := staking.TokensFromTendermintPower(100)
+	msg2 := staking.NewMsgDelegate(sdk.AccAddress(valOpAddr2), valOpAddr1,
+		sdk.NewCoin(staking.DefaultBondDenom, delTokens))
 	require.True(t, sh(ctx, msg2).IsOK())
 	del2 := sk.Delegation(ctx, sdk.AccAddress(valOpAddr2), valOpAddr1)
 
@@ -409,7 +429,7 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
 
 	// slash the validator again
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
-	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), 100, sdk.NewDecWithPrec(5, 1))
+	sk.Slash(ctx, valConsAddr1, ctx.BlockHeight(), power, sdk.NewDecWithPrec(5, 1))
 	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
 
 	// fetch updated validator
@@ -422,16 +442,16 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
 	rewards := k.calculateDelegationRewards(ctx, val, del1, endingPeriod)
 
 	// rewards for del1 should be 2/3 initial (half initial first period, 1/6 initial second period)
-	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec((initial / 2) + (initial / 6))}}, rewards)
+	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, initial.QuoInt64(2).Add(initial.QuoInt64(6))}}, rewards)
 
 	// calculate delegation rewards for del2
 	rewards = k.calculateDelegationRewards(ctx, val, del2, endingPeriod)
 
 	// rewards for del2 should be initial / 3
-	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial / 3)}}, rewards)
+	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, initial.QuoInt64(3)}}, rewards)
 
 	// commission should be equal to initial (twice 50% commission, unaffected by slashing)
-	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, sdk.NewDec(initial)}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
+	require.Equal(t, sdk.DecCoins{{staking.DefaultBondDenom, initial}}, k.GetValidatorAccumulatedCommission(ctx, valOpAddr1))
 }
 
 func TestCalculateRewardsMultiDelegatorMultWithdraw(t *testing.T) {
diff --git a/x/distribution/keeper/keeper_test.go b/x/distribution/keeper/keeper_test.go
index 702946918298..e30eb78f9a41 100644
--- a/x/distribution/keeper/keeper_test.go
+++ b/x/distribution/keeper/keeper_test.go
@@ -7,6 +7,7 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/distribution/types"
+	"github.com/cosmos/cosmos-sdk/x/staking"
 )
 
 func TestSetWithdrawAddr(t *testing.T) {
@@ -31,9 +32,10 @@ func TestWithdrawValidatorCommission(t *testing.T) {
 
 	// check initial balance
 	balance := ak.GetAccount(ctx, sdk.AccAddress(valOpAddr3)).GetCoins()
-	require.Equal(t, balance, sdk.Coins{
-		{"stake", sdk.NewInt(1000)},
-	})
+	expTokens := staking.TokensFromTendermintPower(1000)
+	require.Equal(t, sdk.Coins{
+		{"stake", staking.TokensFromTendermintPower(1000)},
+	}, balance)
 
 	// set commission
 	keeper.SetValidatorAccumulatedCommission(ctx, valOpAddr3, sdk.DecCoins{
@@ -46,17 +48,17 @@ func TestWithdrawValidatorCommission(t *testing.T) {
 
 	// check balance increase
 	balance = ak.GetAccount(ctx, sdk.AccAddress(valOpAddr3)).GetCoins()
-	require.Equal(t, balance, sdk.Coins{
+	require.Equal(t, sdk.Coins{
 		{"mytoken", sdk.NewInt(1)},
-		{"stake", sdk.NewInt(1001)},
-	})
+		{"stake", expTokens.AddRaw(1)},
+	}, balance)
 
 	// check remainder
 	remainder := keeper.GetValidatorAccumulatedCommission(ctx, valOpAddr3)
-	require.Equal(t, remainder, sdk.DecCoins{
+	require.Equal(t, sdk.DecCoins{
 		{"mytoken", sdk.NewDec(1).Quo(sdk.NewDec(4))},
 		{"stake", sdk.NewDec(1).Quo(sdk.NewDec(2))},
-	})
+	}, remainder)
 
 	require.True(t, true)
 }
diff --git a/x/distribution/keeper/test_common.go b/x/distribution/keeper/test_common.go
index 8e8b157c4106..0a36910e8357 100644
--- a/x/distribution/keeper/test_common.go
+++ b/x/distribution/keeper/test_common.go
@@ -71,18 +71,20 @@ func MakeTestCodec() *codec.Codec {
 }
 
 // test input with default values
-func CreateTestInputDefault(t *testing.T, isCheckTx bool, initCoins int64) (
+func CreateTestInputDefault(t *testing.T, isCheckTx bool, initPower int64) (
 	sdk.Context, auth.AccountKeeper, Keeper, staking.Keeper, DummyFeeCollectionKeeper) {
 
 	communityTax := sdk.NewDecWithPrec(2, 2)
-	return CreateTestInputAdvanced(t, isCheckTx, initCoins, communityTax)
+	return CreateTestInputAdvanced(t, isCheckTx, initPower, communityTax)
 }
 
 // hogpodge of all sorts of input required for testing
-func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initCoins int64,
+func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initPower int64,
 	communityTax sdk.Dec) (
 	sdk.Context, auth.AccountKeeper, Keeper, staking.Keeper, DummyFeeCollectionKeeper) {
 
+	initCoins := staking.TokensFromTendermintPower(initPower)
+
 	keyDistr := sdk.NewKVStoreKey(types.StoreKey)
 	keyStaking := sdk.NewKVStoreKey(staking.StoreKey)
 	tkeyStaking := sdk.NewTransientStoreKey(staking.TStoreKey)
@@ -119,10 +121,10 @@ func CreateTestInputAdvanced(t *testing.T, isCheckTx bool, initCoins int64,
 	for _, addr := range addrs {
 		pool := sk.GetPool(ctx)
 		_, _, err := ck.AddCoins(ctx, addr, sdk.Coins{
-			{sk.GetParams(ctx).BondDenom, sdk.NewInt(initCoins)},
+			sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins),
 		})
 		require.Nil(t, err)
-		pool.NotBondedTokens = pool.NotBondedTokens.Add(sdk.NewInt(initCoins))
+		pool.NotBondedTokens = pool.NotBondedTokens.Add(initCoins)
 		sk.SetPool(ctx, pool)
 	}
 
diff --git a/x/gov/endblocker_test.go b/x/gov/endblocker_test.go
index 952f87f771a3..9ce46419ed31 100644
--- a/x/gov/endblocker_test.go
+++ b/x/gov/endblocker_test.go
@@ -9,7 +9,7 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	"github.com/cosmos/cosmos-sdk/x/staking"
 )
 
 func TestTickExpiredDepositPeriod(t *testing.T) {
@@ -23,7 +23,7 @@ func TestTickExpiredDepositPeriod(t *testing.T) {
 	require.False(t, inactiveQueue.Valid())
 	inactiveQueue.Close()
 
-	newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
+	newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)})
 
 	res := govHandler(ctx, newProposalMsg)
 	require.True(t, res.IsOK())
@@ -66,7 +66,7 @@ func TestTickMultipleExpiredDepositPeriod(t *testing.T) {
 	require.False(t, inactiveQueue.Valid())
 	inactiveQueue.Close()
 
-	newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
+	newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)})
 
 	res := govHandler(ctx, newProposalMsg)
 	require.True(t, res.IsOK())
@@ -83,7 +83,7 @@ func TestTickMultipleExpiredDepositPeriod(t *testing.T) {
 	require.False(t, inactiveQueue.Valid())
 	inactiveQueue.Close()
 
-	newProposalMsg2 := NewMsgSubmitProposal("Test2", "test2", ProposalTypeText, addrs[1], sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
+	newProposalMsg2 := NewMsgSubmitProposal("Test2", "test2", ProposalTypeText, addrs[1], sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)})
 	res = govHandler(ctx, newProposalMsg2)
 	require.True(t, res.IsOK())
 
@@ -126,7 +126,7 @@ func TestTickPassedDepositPeriod(t *testing.T) {
 	require.False(t, activeQueue.Valid())
 	activeQueue.Close()
 
-	newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
+	newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)})
 
 	res := govHandler(ctx, newProposalMsg)
 	require.True(t, res.IsOK())
@@ -145,7 +145,7 @@ func TestTickPassedDepositPeriod(t *testing.T) {
 	require.False(t, inactiveQueue.Valid())
 	inactiveQueue.Close()
 
-	newDepositMsg := NewMsgDeposit(addrs[1], proposalID, sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
+	newDepositMsg := NewMsgDeposit(addrs[1], proposalID, sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 5)})
 	res = govHandler(ctx, newDepositMsg)
 	require.True(t, res.IsOK())
 
@@ -169,7 +169,8 @@ func TestTickPassedVotingPeriod(t *testing.T) {
 	require.False(t, activeQueue.Valid())
 	activeQueue.Close()
 
-	newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
+	proposalCoins := sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, staking.TokensFromTendermintPower(5))}
+	newProposalMsg := NewMsgSubmitProposal("Test", "test", ProposalTypeText, addrs[0], proposalCoins)
 
 	res := govHandler(ctx, newProposalMsg)
 	require.True(t, res.IsOK())
@@ -180,7 +181,7 @@ func TestTickPassedVotingPeriod(t *testing.T) {
 	newHeader.Time = ctx.BlockHeader().Time.Add(time.Duration(1) * time.Second)
 	ctx = ctx.WithBlockHeader(newHeader)
 
-	newDepositMsg := NewMsgDeposit(addrs[1], proposalID, sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)})
+	newDepositMsg := NewMsgDeposit(addrs[1], proposalID, proposalCoins)
 	res = govHandler(ctx, newDepositMsg)
 	require.True(t, res.IsOK())
 
diff --git a/x/gov/genesis.go b/x/gov/genesis.go
index a86085b2289f..36c699e19df5 100644
--- a/x/gov/genesis.go
+++ b/x/gov/genesis.go
@@ -5,7 +5,7 @@ import (
 	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	"github.com/cosmos/cosmos-sdk/x/staking"
 )
 
 // GenesisState - all staking state that must be provided at genesis
@@ -42,10 +42,11 @@ func NewGenesisState(startingProposalID uint64, dp DepositParams, vp VotingParam
 
 // get raw genesis raw message for testing
 func DefaultGenesisState() GenesisState {
+	minDepositTokens := staking.TokensFromTendermintPower(10)
 	return GenesisState{
 		StartingProposalID: 1,
 		DepositParams: DepositParams{
-			MinDeposit:       sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10)},
+			MinDeposit:       sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, minDepositTokens)},
 			MaxDepositPeriod: time.Duration(172800) * time.Second,
 		},
 		VotingParams: VotingParams{
diff --git a/x/gov/keeper_test.go b/x/gov/keeper_test.go
index f4308ef19cc0..8fc2460ca97e 100644
--- a/x/gov/keeper_test.go
+++ b/x/gov/keeper_test.go
@@ -9,7 +9,7 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	"github.com/cosmos/cosmos-sdk/x/staking"
 )
 
 func TestGetSetProposal(t *testing.T) {
@@ -70,15 +70,14 @@ func TestDeposits(t *testing.T) {
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
 	proposalID := proposal.GetProposalID()
 
-	fourSteak := sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 4)}
-	fiveSteak := sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 5)}
+	fourSteak := sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, staking.TokensFromTendermintPower(4))}
+	fiveSteak := sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, staking.TokensFromTendermintPower(5))}
 
 	addr0Initial := keeper.ck.GetCoins(ctx, addrs[0])
 	addr1Initial := keeper.ck.GetCoins(ctx, addrs[1])
 
-	// require.True(t, addr0Initial.IsEqual(sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 42)}))
-	require.Equal(t, sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 42)}, addr0Initial)
-
+	expTokens := staking.TokensFromTendermintPower(42)
+	require.Equal(t, sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, expTokens)}, addr0Initial)
 	require.True(t, proposal.GetTotalDeposit().IsEqual(sdk.Coins{}))
 
 	// Check no deposits at beginning
diff --git a/x/gov/msgs_test.go b/x/gov/msgs_test.go
index a9fa8839668d..682aecdce086 100644
--- a/x/gov/msgs_test.go
+++ b/x/gov/msgs_test.go
@@ -8,14 +8,14 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/mock"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	"github.com/cosmos/cosmos-sdk/x/staking"
 )
 
 var (
-	coinsPos         = sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 1000)}
+	coinsPos         = sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 1000)}
 	coinsZero        = sdk.Coins{}
 	coinsPosNotAtoms = sdk.Coins{sdk.NewInt64Coin("foo", 10000)}
-	coinsMulti       = sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 1000), sdk.NewInt64Coin("foo", 10000)}
+	coinsMulti       = sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, 1000), sdk.NewInt64Coin("foo", 10000)}
 )
 
 func init() {
diff --git a/x/gov/proposals.go b/x/gov/proposals.go
index e5dccfb02cf0..e11400f1cf92 100644
--- a/x/gov/proposals.go
+++ b/x/gov/proposals.go
@@ -362,6 +362,24 @@ type TallyResult struct {
 	NoWithVeto sdk.Dec `json:"no_with_veto"`
 }
 
+func NewTallyResult(yes, abstain, no, noWithVeto sdk.Dec) TallyResult {
+	return TallyResult{
+		Yes:        yes,
+		Abstain:    abstain,
+		No:         no,
+		NoWithVeto: noWithVeto,
+	}
+}
+
+func NewTallyResultFromMap(results map[VoteOption]sdk.Dec) TallyResult {
+	return TallyResult{
+		Yes:        results[OptionYes],
+		Abstain:    results[OptionAbstain],
+		No:         results[OptionNo],
+		NoWithVeto: results[OptionNoWithVeto],
+	}
+}
+
 // checks if two proposals are equal
 func EmptyTallyResult() TallyResult {
 	return TallyResult{
diff --git a/x/gov/simulation/msgs.go b/x/gov/simulation/msgs.go
index faca7ec8e9e6..7c078bdcf3b0 100644
--- a/x/gov/simulation/msgs.go
+++ b/x/gov/simulation/msgs.go
@@ -11,11 +11,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/gov"
 	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
-)
-
-const (
-	denom = stakingTypes.DefaultBondDenom
 )
 
 // SimulateSubmittingVotingAndSlashingForProposal simulates creating a msg Submit Proposal
@@ -183,7 +178,7 @@ func operationSimulateMsgVote(k gov.Keeper, acc simulation.Account, proposalID u
 func randomDeposit(r *rand.Rand) sdk.Coins {
 	// TODO Choose based on account balance and min deposit
 	amount := int64(r.Intn(20)) + 1
-	return sdk.Coins{sdk.NewInt64Coin(denom, amount)}
+	return sdk.Coins{sdk.NewInt64Coin(staking.DefaultBondDenom, amount)}
 }
 
 // Pick a random proposal ID
diff --git a/x/gov/tally.go b/x/gov/tally.go
index 7877511d4469..d6cac26f50b4 100644
--- a/x/gov/tally.go
+++ b/x/gov/tally.go
@@ -7,12 +7,24 @@ import (
 // validatorGovInfo used for tallying
 type validatorGovInfo struct {
 	Address         sdk.ValAddress // address of the validator operator
-	Power           sdk.Int        // Power of a Validator
+	BondedTokens    sdk.Int        // Power of a Validator
 	DelegatorShares sdk.Dec        // Total outstanding delegator shares
 	Minus           sdk.Dec        // Minus of validator, used to compute validator's voting power
 	Vote            VoteOption     // Vote of the validator
 }
 
+func newValidatorGovInfo(address sdk.ValAddress, bondedTokens sdk.Int, delegatorShares,
+	minus sdk.Dec, vote VoteOption) validatorGovInfo {
+
+	return validatorGovInfo{
+		Address:         address,
+		BondedTokens:    bondedTokens,
+		DelegatorShares: delegatorShares,
+		Minus:           minus,
+		Vote:            vote,
+	}
+}
+
 func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tallyResults TallyResult) {
 	results := make(map[VoteOption]sdk.Dec)
 	results[OptionYes] = sdk.ZeroDec()
@@ -24,13 +36,13 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
 	currValidators := make(map[string]validatorGovInfo)
 
 	keeper.vs.IterateBondedValidatorsByPower(ctx, func(index int64, validator sdk.Validator) (stop bool) {
-		currValidators[validator.GetOperator().String()] = validatorGovInfo{
-			Address:         validator.GetOperator(),
-			Power:           validator.GetPower(),
-			DelegatorShares: validator.GetDelegatorShares(),
-			Minus:           sdk.ZeroDec(),
-			Vote:            OptionEmpty,
-		}
+		currValidators[validator.GetOperator().String()] = newValidatorGovInfo(
+			validator.GetOperator(),
+			validator.GetBondedTokens(),
+			validator.GetDelegatorShares(),
+			sdk.ZeroDec(),
+			OptionEmpty,
+		)
 		return false
 	})
 
@@ -57,7 +69,7 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
 					currValidators[valAddrStr] = val
 
 					delegatorShare := delegation.GetShares().Quo(val.DelegatorShares)
-					votingPower := delegatorShare.MulInt(val.Power)
+					votingPower := delegatorShare.MulInt(val.BondedTokens)
 
 					results[vote.Option] = results[vote.Option].Add(votingPower)
 					totalVotingPower = totalVotingPower.Add(votingPower)
@@ -78,20 +90,14 @@ func tally(ctx sdk.Context, keeper Keeper, proposal Proposal) (passes bool, tall
 
 		sharesAfterMinus := val.DelegatorShares.Sub(val.Minus)
 		percentAfterMinus := sharesAfterMinus.Quo(val.DelegatorShares)
-		votingPower := percentAfterMinus.MulInt(val.Power)
+		votingPower := percentAfterMinus.MulInt(val.BondedTokens)
 
 		results[val.Vote] = results[val.Vote].Add(votingPower)
 		totalVotingPower = totalVotingPower.Add(votingPower)
 	}
 
 	tallyParams := keeper.GetTallyParams(ctx)
-
-	tallyResults = TallyResult{
-		Yes:        results[OptionYes],
-		Abstain:    results[OptionAbstain],
-		No:         results[OptionNo],
-		NoWithVeto: results[OptionNoWithVeto],
-	}
+	tallyResults = NewTallyResultFromMap(results)
 
 	// If there is no staked coins, the proposal fails
 	if keeper.vs.TotalPower(ctx).IsZero() {
diff --git a/x/gov/tally_test.go b/x/gov/tally_test.go
index 77a22996b0ad..f2dbe79608db 100644
--- a/x/gov/tally_test.go
+++ b/x/gov/tally_test.go
@@ -10,9 +10,7 @@ import (
 	"github.com/tendermint/tendermint/crypto/ed25519"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 var (
@@ -22,12 +20,15 @@ var (
 	testCommissionMsg = staking.NewCommissionMsg(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())
 )
 
-func createValidators(t *testing.T, stakingHandler sdk.Handler, ctx sdk.Context, addrs []sdk.ValAddress, coinAmt []int64) {
+func createValidators(t *testing.T, stakingHandler sdk.Handler, ctx sdk.Context, addrs []sdk.ValAddress, powerAmt []int64) {
 	require.True(t, len(addrs) <= len(pubkeys), "Not enough pubkeys specified at top of file.")
 
 	for i := 0; i < len(addrs); i++ {
+
+		valTokens := staking.TokensFromTendermintPower(powerAmt[i])
 		valCreateMsg := staking.NewMsgCreateValidator(
-			addrs[i], pubkeys[i], sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, coinAmt[i]), testDescription, testCommissionMsg,
+			addrs[i], pubkeys[i], sdk.NewCoin(staking.DefaultBondDenom, valTokens),
+			testDescription, testCommissionMsg,
 		)
 
 		res := stakingHandler(ctx, valCreateMsg)
@@ -317,7 +318,8 @@ func TestTallyDelgatorOverride(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{5, 6, 7})
 	staking.EndBlocker(ctx, sk)
 
-	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 30))
+	delTokens := staking.TokensFromTendermintPower(30)
+	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
 	stakingHandler(ctx, delegator1Msg)
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@@ -354,7 +356,8 @@ func TestTallyDelgatorInherit(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{5, 6, 7})
 	staking.EndBlocker(ctx, sk)
 
-	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 30))
+	delTokens := staking.TokensFromTendermintPower(30)
+	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
 	stakingHandler(ctx, delegator1Msg)
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@@ -389,9 +392,10 @@ func TestTallyDelgatorMultipleOverride(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{5, 6, 7})
 	staking.EndBlocker(ctx, sk)
 
-	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
+	delTokens := staking.TokensFromTendermintPower(10)
+	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
 	stakingHandler(ctx, delegator1Msg)
-	delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
+	delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
 	stakingHandler(ctx, delegator1Msg2)
 
 	proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText)
@@ -420,25 +424,29 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) {
 	ctx := mapp.BaseApp.NewContext(false, abci.Header{})
 	stakingHandler := staking.NewHandler(sk)
 
+	valTokens1 := staking.TokensFromTendermintPower(25)
 	val1CreateMsg := staking.NewMsgCreateValidator(
-		sdk.ValAddress(addrs[0]), ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 25), testDescription, testCommissionMsg,
+		sdk.ValAddress(addrs[0]), ed25519.GenPrivKey().PubKey(), sdk.NewCoin(staking.DefaultBondDenom, valTokens1), testDescription, testCommissionMsg,
 	)
 	stakingHandler(ctx, val1CreateMsg)
 
+	valTokens2 := staking.TokensFromTendermintPower(6)
 	val2CreateMsg := staking.NewMsgCreateValidator(
-		sdk.ValAddress(addrs[1]), ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 6), testDescription, testCommissionMsg,
+		sdk.ValAddress(addrs[1]), ed25519.GenPrivKey().PubKey(), sdk.NewCoin(staking.DefaultBondDenom, valTokens2), testDescription, testCommissionMsg,
 	)
 	stakingHandler(ctx, val2CreateMsg)
 
+	valTokens3 := staking.TokensFromTendermintPower(7)
 	val3CreateMsg := staking.NewMsgCreateValidator(
-		sdk.ValAddress(addrs[2]), ed25519.GenPrivKey().PubKey(), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 7), testDescription, testCommissionMsg,
+		sdk.ValAddress(addrs[2]), ed25519.GenPrivKey().PubKey(), sdk.NewCoin(staking.DefaultBondDenom, valTokens3), testDescription, testCommissionMsg,
 	)
 	stakingHandler(ctx, val3CreateMsg)
 
-	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
+	delTokens := staking.TokensFromTendermintPower(10)
+	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
 	stakingHandler(ctx, delegator1Msg)
 
-	delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
+	delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
 	stakingHandler(ctx, delegator1Msg2)
 
 	staking.EndBlocker(ctx, sk)
@@ -475,10 +483,11 @@ func TestTallyJailedValidator(t *testing.T) {
 	createValidators(t, stakingHandler, ctx, valAddrs, []int64{25, 6, 7})
 	staking.EndBlocker(ctx, sk)
 
-	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
+	delTokens := staking.TokensFromTendermintPower(10)
+	delegator1Msg := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[2]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
 	stakingHandler(ctx, delegator1Msg)
 
-	delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10))
+	delegator1Msg2 := staking.NewMsgDelegate(addrs[3], sdk.ValAddress(addrs[1]), sdk.NewCoin(staking.DefaultBondDenom, delTokens))
 	stakingHandler(ctx, delegator1Msg2)
 
 	val2, found := sk.GetValidator(ctx, sdk.ValAddress(addrs[1]))
diff --git a/x/gov/test_common.go b/x/gov/test_common.go
index 34a507c26395..ee3b9585064a 100644
--- a/x/gov/test_common.go
+++ b/x/gov/test_common.go
@@ -16,11 +16,14 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/mock"
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 // initialize the mock application for this module
-func getMockApp(t *testing.T, numGenAccs int, genState GenesisState, genAccs []auth.Account) (mapp *mock.App, keeper Keeper, sk staking.Keeper, addrs []sdk.AccAddress, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) {
+func getMockApp(t *testing.T, numGenAccs int, genState GenesisState, genAccs []auth.Account) (
+	mapp *mock.App, keeper Keeper, sk staking.Keeper, addrs []sdk.AccAddress,
+	pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) {
+
 	mapp = mock.NewApp()
 
 	staking.RegisterCodec(mapp.Cdc)
@@ -43,8 +46,10 @@ func getMockApp(t *testing.T, numGenAccs int, genState GenesisState, genAccs []a
 
 	require.NoError(t, mapp.CompleteSetup(keyStaking, tkeyStaking, keyGov))
 
+	valTokens := staking.TokensFromTendermintPower(42)
 	if genAccs == nil || len(genAccs) == 0 {
-		genAccs, addrs, pubKeys, privKeys = mock.CreateGenAccounts(numGenAccs, sdk.Coins{sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 42)})
+		genAccs, addrs, pubKeys, privKeys = mock.CreateGenAccounts(numGenAccs,
+			sdk.Coins{sdk.NewCoin(staking.DefaultBondDenom, valTokens)})
 	}
 
 	mock.SetGenesis(mapp, genAccs)
@@ -68,7 +73,8 @@ func getInitChainer(mapp *mock.App, keeper Keeper, stakingKeeper staking.Keeper,
 		mapp.InitChainer(ctx, req)
 
 		stakingGenesis := staking.DefaultGenesisState()
-		stakingGenesis.Pool.NotBondedTokens = sdk.NewInt(100000)
+		tokens := types.TokensFromTendermintPower(100000)
+		stakingGenesis.Pool.NotBondedTokens = tokens
 
 		validators, err := staking.InitGenesis(ctx, stakingKeeper, stakingGenesis)
 		if err != nil {
diff --git a/x/mint/params.go b/x/mint/params.go
index 45a66f7fc1de..62018397d677 100644
--- a/x/mint/params.go
+++ b/x/mint/params.go
@@ -3,9 +3,8 @@ package mint
 import (
 	"fmt"
 
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
-
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/staking"
 )
 
 // mint parameters
@@ -34,7 +33,7 @@ func NewParams(mintDenom string, inflationRateChange, inflationMax,
 // default minting module parameters
 func DefaultParams() Params {
 	return Params{
-		MintDenom:           stakingTypes.DefaultBondDenom,
+		MintDenom:           staking.DefaultBondDenom,
 		InflationRateChange: sdk.NewDecWithPrec(13, 2),
 		InflationMax:        sdk.NewDecWithPrec(20, 2),
 		InflationMin:        sdk.NewDecWithPrec(7, 2),
diff --git a/x/mock/app.go b/x/mock/app.go
index 902873ba1fba..117afa668f01 100644
--- a/x/mock/app.go
+++ b/x/mock/app.go
@@ -59,10 +59,10 @@ func NewApp() *App {
 		Cdc:              cdc,
 		KeyMain:          sdk.NewKVStoreKey(bam.MainStoreKey),
 		KeyAccount:       sdk.NewKVStoreKey(auth.StoreKey),
-		TotalCoinsSupply: sdk.Coins{},
 		KeyFeeCollection: sdk.NewKVStoreKey("fee"),
 		KeyParams:        sdk.NewKVStoreKey("params"),
 		TKeyParams:       sdk.NewTransientStoreKey("transient_params"),
+		TotalCoinsSupply: sdk.Coins{},
 	}
 
 	app.ParamsKeeper = params.NewKeeper(app.Cdc, app.KeyParams, app.TKeyParams)
@@ -135,6 +135,16 @@ type AddrKeys struct {
 	PrivKey crypto.PrivKey
 }
 
+func NewAddrKeys(address sdk.AccAddress, pubKey crypto.PubKey,
+	privKey crypto.PrivKey) AddrKeys {
+
+	return AddrKeys{
+		Address: address,
+		PubKey:  pubKey,
+		PrivKey: privKey,
+	}
+}
+
 // implement `Interface` in sort package.
 type AddrKeysSlice []AddrKeys
 
@@ -161,7 +171,9 @@ func (b AddrKeysSlice) Swap(i, j int) {
 
 // CreateGenAccounts generates genesis accounts loaded with coins, and returns
 // their addresses, pubkeys, and privkeys.
-func CreateGenAccounts(numAccs int, genCoins sdk.Coins) (genAccs []auth.Account, addrs []sdk.AccAddress, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) {
+func CreateGenAccounts(numAccs int, genCoins sdk.Coins) (genAccs []auth.Account,
+	addrs []sdk.AccAddress, pubKeys []crypto.PubKey, privKeys []crypto.PrivKey) {
+
 	addrKeysSlice := AddrKeysSlice{}
 
 	for i := 0; i < numAccs; i++ {
@@ -169,11 +181,7 @@ func CreateGenAccounts(numAccs int, genCoins sdk.Coins) (genAccs []auth.Account,
 		pubKey := privKey.PubKey()
 		addr := sdk.AccAddress(pubKey.Address())
 
-		addrKeysSlice = append(addrKeysSlice, AddrKeys{
-			Address: addr,
-			PubKey:  pubKey,
-			PrivKey: privKey,
-		})
+		addrKeysSlice = append(addrKeysSlice, NewAddrKeys(addr, pubKey, privKey))
 	}
 
 	sort.Sort(addrKeysSlice)
diff --git a/x/mock/test_utils.go b/x/mock/test_utils.go
index f2af216e135d..9032d1f3d6db 100644
--- a/x/mock/test_utils.go
+++ b/x/mock/test_utils.go
@@ -72,10 +72,10 @@ func CheckGenTx(
 // block commitment with the given transaction. A test assertion is made using
 // the parameter 'expPass' against the result. A corresponding result is
 // returned.
-func SignCheckDeliver(
-	t *testing.T, cdc *codec.Codec, app *baseapp.BaseApp, msgs []sdk.Msg,
-	accNums []uint64, seq []uint64, expSimPass, expPass bool, priv ...crypto.PrivKey,
-) sdk.Result {
+func SignCheckDeliver(t *testing.T, cdc *codec.Codec, app *baseapp.BaseApp,
+	msgs []sdk.Msg, accNums, seq []uint64, expSimPass, expPass bool,
+	priv ...crypto.PrivKey) sdk.Result {
+
 	tx := GenTx(msgs, accNums, seq, priv...)
 
 	txBytes, err := cdc.MarshalBinaryLengthPrefixed(tx)
diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go
index 20e538080955..6a77f44649b0 100644
--- a/x/slashing/app_test.go
+++ b/x/slashing/app_test.go
@@ -12,7 +12,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/mock"
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 var (
@@ -26,7 +25,7 @@ func getMockApp(t *testing.T) (*mock.App, staking.Keeper, Keeper) {
 	mapp := mock.NewApp()
 
 	RegisterCodec(mapp.Cdc)
-	stakingTypes.RegisterCodec(mapp.Cdc)
+	staking.RegisterCodec(mapp.Cdc)
 
 	keyStaking := sdk.NewKVStoreKey(staking.StoreKey)
 	tkeyStaking := sdk.NewTransientStoreKey(staking.TStoreKey)
@@ -62,7 +61,8 @@ func getInitChainer(mapp *mock.App, keeper staking.Keeper) sdk.InitChainer {
 	return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
 		mapp.InitChainer(ctx, req)
 		stakingGenesis := staking.DefaultGenesisState()
-		stakingGenesis.Pool.NotBondedTokens = sdk.NewInt(100000)
+		tokens := staking.TokensFromTendermintPower(100000)
+		stakingGenesis.Pool.NotBondedTokens = tokens
 		validators, err := staking.InitGenesis(ctx, keeper, stakingGenesis)
 		if err != nil {
 			panic(err)
@@ -93,8 +93,10 @@ func checkValidatorSigningInfo(t *testing.T, mapp *mock.App, keeper Keeper,
 func TestSlashingMsgs(t *testing.T) {
 	mapp, stakingKeeper, keeper := getMockApp(t)
 
-	genCoin := sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 42)
-	bondCoin := sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10)
+	genTokens := staking.TokensFromTendermintPower(42)
+	bondTokens := staking.TokensFromTendermintPower(10)
+	genCoin := sdk.NewCoin(staking.DefaultBondDenom, genTokens)
+	bondCoin := sdk.NewCoin(staking.DefaultBondDenom, bondTokens)
 
 	acc1 := &auth.BaseAccount{
 		Address: addr1,
@@ -116,7 +118,7 @@ func TestSlashingMsgs(t *testing.T) {
 	validator := checkValidator(t, mapp, stakingKeeper, addr1, true)
 	require.Equal(t, sdk.ValAddress(addr1), validator.OperatorAddr)
 	require.Equal(t, sdk.Bonded, validator.Status)
-	require.True(sdk.IntEq(t, sdk.NewInt(10), validator.BondedTokens()))
+	require.True(sdk.IntEq(t, bondTokens, validator.BondedTokens()))
 	unjailMsg := MsgUnjail{ValidatorAddr: sdk.ValAddress(validator.ConsPubKey.Address())}
 
 	// no signing info yet
diff --git a/x/slashing/handler_test.go b/x/slashing/handler_test.go
index a363a497be35..f57dead00c72 100644
--- a/x/slashing/handler_test.go
+++ b/x/slashing/handler_test.go
@@ -8,24 +8,25 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/staking"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 func TestCannotUnjailUnlessJailed(t *testing.T) {
 	// initial setup
 	ctx, ck, sk, _, keeper := createTestInput(t, DefaultParams())
 	slh := NewHandler(keeper)
-	amtInt := int64(100)
-	addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
+	amt := types.TokensFromTendermintPower(100)
+	addr, val := addrs[0], pks[0]
 	msg := NewTestMsgCreateValidator(addr, val, amt)
 	got := staking.NewHandler(sk)(ctx, msg)
-	require.True(t, got.IsOK())
+	require.True(t, got.IsOK(), "%v", got)
 	staking.EndBlocker(ctx, sk)
 
 	require.Equal(
 		t, ck.GetCoins(ctx, sdk.AccAddress(addr)),
 		sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
 	)
-	require.True(sdk.IntEq(t, amt, sk.Validator(ctx, addr).GetPower()))
+	require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens())
 
 	// assert non-jailed validator can't be unjailed
 	got = slh(ctx, NewMsgUnjail(addr))
@@ -42,8 +43,8 @@ func TestJailedValidatorDelegations(t *testing.T) {
 	stakingKeeper.SetParams(ctx, stakingParams)
 
 	// create a validator
-	amount := int64(10)
-	valPubKey, bondAmount := pks[0], sdk.NewInt(amount)
+	bondAmount := staking.TokensFromTendermintPower(10)
+	valPubKey := pks[0]
 	valAddr, consAddr := addrs[1], sdk.ConsAddress(addrs[0])
 
 	msgCreateVal := NewTestMsgCreateValidator(valAddr, valPubKey, bondAmount)
@@ -54,12 +55,7 @@ func TestJailedValidatorDelegations(t *testing.T) {
 	staking.EndBlocker(ctx, stakingKeeper)
 
 	// set dummy signing info
-	newInfo := ValidatorSigningInfo{
-		StartHeight:         int64(0),
-		IndexOffset:         int64(0),
-		JailedUntil:         time.Unix(0, 0),
-		MissedBlocksCounter: int64(0),
-	}
+	newInfo := NewValidatorSigningInfo(0, 0, time.Unix(0, 0), false, 0)
 	slashingKeeper.SetValidatorSigningInfo(ctx, consAddr, newInfo)
 
 	// delegate tokens to the validator
@@ -68,7 +64,7 @@ func TestJailedValidatorDelegations(t *testing.T) {
 	got = staking.NewHandler(stakingKeeper)(ctx, msgDelegate)
 	require.True(t, got.IsOK(), "expected delegation to be ok, got %v", got)
 
-	unbondShares := sdk.NewDec(10)
+	unbondShares := sdk.NewDecFromInt(bondAmount)
 
 	// unbond validator total self-delegations (which should jail the validator)
 	msgUndelegate := staking.NewMsgUndelegate(sdk.AccAddress(valAddr), valAddr, unbondShares)
diff --git a/x/slashing/keeper.go b/x/slashing/keeper.go
index aa0e1c5d0f91..bf7c5a18b1d1 100644
--- a/x/slashing/keeper.go
+++ b/x/slashing/keeper.go
@@ -9,7 +9,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/params"
-	staking "github.com/cosmos/cosmos-sdk/x/staking/types"
+	staking "github.com/cosmos/cosmos-sdk/x/staking"
 )
 
 // Keeper of the slashing store
@@ -49,7 +49,8 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, addr crypto.Address, infractio
 
 	// Reject evidence if the double is too old
 	if age > k.MaxEvidenceAge(ctx) {
-		logger.Info(fmt.Sprintf("Ignored double sign from %s at height %d, age of %d past max age of %d", pubkey.Address(), infractionHeight, age, k.MaxEvidenceAge(ctx)))
+		logger.Info(fmt.Sprintf("Ignored double sign from %s at height %d, age of %d past max age of %d",
+			pubkey.Address(), infractionHeight, age, k.MaxEvidenceAge(ctx)))
 		return
 	}
 
diff --git a/x/slashing/keeper_test.go b/x/slashing/keeper_test.go
index 9c4ead9d4727..f43dccac8c27 100644
--- a/x/slashing/keeper_test.go
+++ b/x/slashing/keeper_test.go
@@ -9,6 +9,7 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/staking"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 // Have to change these parameters for tests
@@ -30,8 +31,9 @@ func TestHandleDoubleSign(t *testing.T) {
 	ctx, ck, sk, _, keeper := createTestInput(t, keeperTestParams())
 	// validator added pre-genesis
 	ctx = ctx.WithBlockHeight(-1)
-	amtInt := int64(100)
-	operatorAddr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
+	power := int64(100)
+	amt := staking.TokensFromTendermintPower(power)
+	operatorAddr, val := addrs[0], pks[0]
 	got := staking.NewHandler(sk)(ctx, NewTestMsgCreateValidator(operatorAddr, val, amt))
 	require.True(t, got.IsOK())
 	staking.EndBlocker(ctx, sk)
@@ -39,15 +41,15 @@ func TestHandleDoubleSign(t *testing.T) {
 		t, ck.GetCoins(ctx, sdk.AccAddress(operatorAddr)),
 		sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
 	)
-	require.True(sdk.IntEq(t, amt, sk.Validator(ctx, operatorAddr).GetPower()))
+	require.Equal(t, amt, sk.Validator(ctx, operatorAddr).GetBondedTokens())
 
 	// handle a signature to set signing info
-	keeper.handleValidatorSignature(ctx, val.Address(), amtInt, true)
+	keeper.handleValidatorSignature(ctx, val.Address(), amt.Int64(), true)
 
 	oldTokens := sk.Validator(ctx, operatorAddr).GetTokens()
 
 	// double sign less than max age
-	keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), amtInt)
+	keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), power)
 
 	// should be jailed
 	require.True(t, sk.Validator(ctx, operatorAddr).GetJailed())
@@ -57,7 +59,7 @@ func TestHandleDoubleSign(t *testing.T) {
 	require.True(t, newTokens.LT(oldTokens))
 
 	// New evidence
-	keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), amtInt)
+	keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), power)
 
 	// tokens should be the same (capped slash)
 	require.True(t, sk.Validator(ctx, operatorAddr).GetTokens().Equal(newTokens))
@@ -87,8 +89,9 @@ func TestPastMaxEvidenceAge(t *testing.T) {
 	ctx, ck, sk, _, keeper := createTestInput(t, keeperTestParams())
 	// validator added pre-genesis
 	ctx = ctx.WithBlockHeight(-1)
-	amtInt := int64(100)
-	operatorAddr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
+	power := int64(100)
+	amt := staking.TokensFromTendermintPower(power)
+	operatorAddr, val := addrs[0], pks[0]
 	got := staking.NewHandler(sk)(ctx, NewTestMsgCreateValidator(operatorAddr, val, amt))
 	require.True(t, got.IsOK())
 	staking.EndBlocker(ctx, sk)
@@ -96,23 +99,23 @@ func TestPastMaxEvidenceAge(t *testing.T) {
 		t, ck.GetCoins(ctx, sdk.AccAddress(operatorAddr)),
 		sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
 	)
-	require.True(sdk.IntEq(t, amt, sk.Validator(ctx, operatorAddr).GetPower()))
+	require.Equal(t, amt, sk.Validator(ctx, operatorAddr).GetBondedTokens())
 
 	// handle a signature to set signing info
-	keeper.handleValidatorSignature(ctx, val.Address(), amtInt, true)
+	keeper.handleValidatorSignature(ctx, val.Address(), power, true)
 
 	ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(1, 0).Add(keeper.MaxEvidenceAge(ctx))})
 
-	oldPower := sk.Validator(ctx, operatorAddr).GetPower()
+	oldPower := sk.Validator(ctx, operatorAddr).GetTendermintPower()
 
 	// double sign past max age
-	keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), amtInt)
+	keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), power)
 
 	// should still be bonded
 	require.True(t, sk.Validator(ctx, operatorAddr).GetStatus() == sdk.Bonded)
 
 	// should still have same power
-	require.True(t, sk.Validator(ctx, operatorAddr).GetPower().Equal(oldPower))
+	require.Equal(t, oldPower, sk.Validator(ctx, operatorAddr).GetTendermintPower())
 }
 
 // Test a validator through uptime, downtime, revocation,
@@ -121,8 +124,9 @@ func TestHandleAbsentValidator(t *testing.T) {
 
 	// initial setup
 	ctx, ck, sk, _, keeper := createTestInput(t, keeperTestParams())
-	amtInt64 := int64(100)
-	addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt64)
+	power := int64(100)
+	amt := staking.TokensFromTendermintPower(power)
+	addr, val := addrs[0], pks[0]
 	sh := staking.NewHandler(sk)
 	slh := NewHandler(keeper)
 	got := sh(ctx, NewTestMsgCreateValidator(addr, val, amt))
@@ -133,7 +137,7 @@ func TestHandleAbsentValidator(t *testing.T) {
 		t, ck.GetCoins(ctx, sdk.AccAddress(addr)),
 		sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
 	)
-	require.True(sdk.IntEq(t, amt, sk.Validator(ctx, addr).GetPower()))
+	require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens())
 
 	// will exist since the validator has been bonded
 	info, found := keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
@@ -147,7 +151,7 @@ func TestHandleAbsentValidator(t *testing.T) {
 	// 1000 first blocks OK
 	for ; height < keeper.SignedBlocksWindow(ctx); height++ {
 		ctx = ctx.WithBlockHeight(height)
-		keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, true)
+		keeper.handleValidatorSignature(ctx, val.Address(), power, true)
 	}
 	info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
 	require.True(t, found)
@@ -157,7 +161,7 @@ func TestHandleAbsentValidator(t *testing.T) {
 	// 500 blocks missed
 	for ; height < keeper.SignedBlocksWindow(ctx)+(keeper.SignedBlocksWindow(ctx)-keeper.MinSignedPerWindow(ctx)); height++ {
 		ctx = ctx.WithBlockHeight(height)
-		keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
+		keeper.handleValidatorSignature(ctx, val.Address(), power, false)
 	}
 	info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
 	require.True(t, found)
@@ -172,7 +176,7 @@ func TestHandleAbsentValidator(t *testing.T) {
 
 	// 501st block missed
 	ctx = ctx.WithBlockHeight(height)
-	keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
+	keeper.handleValidatorSignature(ctx, val.Address(), power, false)
 	info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
 	require.True(t, found)
 	require.Equal(t, int64(0), info.StartHeight)
@@ -186,15 +190,15 @@ func TestHandleAbsentValidator(t *testing.T) {
 	validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
 	require.Equal(t, sdk.Unbonding, validator.GetStatus())
 
-	slashAmt := sdk.NewDec(amtInt64).Mul(keeper.SlashFractionDowntime(ctx)).RoundInt64()
+	slashAmt := sdk.NewDecFromInt(amt).Mul(keeper.SlashFractionDowntime(ctx)).RoundInt64()
 
 	// validator should have been slashed
-	require.Equal(t, amtInt64-slashAmt, validator.GetTokens().Int64())
+	require.Equal(t, amt.Int64()-slashAmt, validator.GetTokens().Int64())
 
 	// 502nd block *also* missed (since the LastCommit would have still included the just-unbonded validator)
 	height++
 	ctx = ctx.WithBlockHeight(height)
-	keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
+	keeper.handleValidatorSignature(ctx, val.Address(), power, false)
 	info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
 	require.True(t, found)
 	require.Equal(t, int64(0), info.StartHeight)
@@ -205,7 +209,7 @@ func TestHandleAbsentValidator(t *testing.T) {
 
 	// validator should not have been slashed any more, since it was already jailed
 	validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
-	require.Equal(t, amtInt64-slashAmt, validator.GetTokens().Int64())
+	require.Equal(t, amt.Int64()-slashAmt, validator.GetTokens().Int64())
 
 	// unrevocation should fail prior to jail expiration
 	got = slh(ctx, NewMsgUnjail(addr))
@@ -225,7 +229,7 @@ func TestHandleAbsentValidator(t *testing.T) {
 
 	// validator should have been slashed
 	pool = sk.GetPool(ctx)
-	require.Equal(t, amtInt64-slashAmt, pool.BondedTokens.Int64())
+	require.Equal(t, amt.Int64()-slashAmt, pool.BondedTokens.Int64())
 
 	// Validator start height should not have been changed
 	info, found = keeper.getValidatorSigningInfo(ctx, sdk.ConsAddress(val.Address()))
@@ -237,7 +241,7 @@ func TestHandleAbsentValidator(t *testing.T) {
 	// validator should not be immediately jailed again
 	height++
 	ctx = ctx.WithBlockHeight(height)
-	keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
+	keeper.handleValidatorSignature(ctx, val.Address(), power, false)
 	validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
 	require.Equal(t, sdk.Bonded, validator.GetStatus())
 
@@ -245,7 +249,7 @@ func TestHandleAbsentValidator(t *testing.T) {
 	nextHeight := height + keeper.MinSignedPerWindow(ctx) + 1
 	for ; height < nextHeight; height++ {
 		ctx = ctx.WithBlockHeight(height)
-		keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
+		keeper.handleValidatorSignature(ctx, val.Address(), power, false)
 	}
 
 	// end block
@@ -255,7 +259,7 @@ func TestHandleAbsentValidator(t *testing.T) {
 	nextHeight = height + keeper.MinSignedPerWindow(ctx) + 1
 	for ; height <= nextHeight; height++ {
 		ctx = ctx.WithBlockHeight(height)
-		keeper.handleValidatorSignature(ctx, val.Address(), amtInt64, false)
+		keeper.handleValidatorSignature(ctx, val.Address(), power, false)
 	}
 
 	// end block
@@ -271,22 +275,23 @@ func TestHandleAbsentValidator(t *testing.T) {
 func TestHandleNewValidator(t *testing.T) {
 	// initial setup
 	ctx, ck, sk, _, keeper := createTestInput(t, keeperTestParams())
-	addr, val, amt := addrs[0], pks[0], int64(100)
+	addr, val := addrs[0], pks[0]
+	amt := staking.TokensFromTendermintPower(100)
 	sh := staking.NewHandler(sk)
 
 	// 1000 first blocks not a validator
 	ctx = ctx.WithBlockHeight(keeper.SignedBlocksWindow(ctx) + 1)
 
 	// Validator created
-	got := sh(ctx, NewTestMsgCreateValidator(addr, val, sdk.NewInt(amt)))
+	got := sh(ctx, NewTestMsgCreateValidator(addr, val, amt))
 	require.True(t, got.IsOK())
 	staking.EndBlocker(ctx, sk)
 
 	require.Equal(
 		t, ck.GetCoins(ctx, sdk.AccAddress(addr)),
-		sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.SubRaw(amt))},
+		sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
 	)
-	require.Equal(t, amt, sk.Validator(ctx, addr).GetPower().Int64())
+	require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens())
 
 	// Now a validator, for two blocks
 	keeper.handleValidatorSignature(ctx, val.Address(), 100, true)
@@ -304,7 +309,8 @@ func TestHandleNewValidator(t *testing.T) {
 	validator, _ := sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
 	require.Equal(t, sdk.Bonded, validator.GetStatus())
 	pool := sk.GetPool(ctx)
-	require.Equal(t, int64(100), pool.BondedTokens.Int64())
+	expTokens := staking.TokensFromTendermintPower(100)
+	require.Equal(t, expTokens, pool.BondedTokens)
 }
 
 // Test a jailed validator being "down" twice
@@ -313,8 +319,9 @@ func TestHandleAlreadyJailed(t *testing.T) {
 
 	// initial setup
 	ctx, _, sk, _, keeper := createTestInput(t, DefaultParams())
-	amtInt := int64(100)
-	addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
+	power := int64(100)
+	amt := staking.TokensFromTendermintPower(power)
+	addr, val := addrs[0], pks[0]
 	sh := staking.NewHandler(sk)
 	got := sh(ctx, NewTestMsgCreateValidator(addr, val, amt))
 	require.True(t, got.IsOK())
@@ -324,13 +331,13 @@ func TestHandleAlreadyJailed(t *testing.T) {
 	height := int64(0)
 	for ; height < keeper.SignedBlocksWindow(ctx); height++ {
 		ctx = ctx.WithBlockHeight(height)
-		keeper.handleValidatorSignature(ctx, val.Address(), amtInt, true)
+		keeper.handleValidatorSignature(ctx, val.Address(), power, true)
 	}
 
 	// 501 blocks missed
 	for ; height < keeper.SignedBlocksWindow(ctx)+(keeper.SignedBlocksWindow(ctx)-keeper.MinSignedPerWindow(ctx))+1; height++ {
 		ctx = ctx.WithBlockHeight(height)
-		keeper.handleValidatorSignature(ctx, val.Address(), amtInt, false)
+		keeper.handleValidatorSignature(ctx, val.Address(), power, false)
 	}
 
 	// end block
@@ -341,15 +348,16 @@ func TestHandleAlreadyJailed(t *testing.T) {
 	require.Equal(t, sdk.Unbonding, validator.GetStatus())
 
 	// validator should have been slashed
-	require.Equal(t, amtInt-1, validator.GetTokens().Int64())
+	resultingTokens := amt.Sub(staking.TokensFromTendermintPower(1))
+	require.Equal(t, resultingTokens, validator.GetTokens())
 
 	// another block missed
 	ctx = ctx.WithBlockHeight(height)
-	keeper.handleValidatorSignature(ctx, val.Address(), amtInt, false)
+	keeper.handleValidatorSignature(ctx, val.Address(), power, false)
 
 	// validator should not have been slashed twice
 	validator, _ = sk.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(val))
-	require.Equal(t, amtInt-1, validator.GetTokens().Int64())
+	require.Equal(t, resultingTokens, validator.GetTokens())
 
 }
 
@@ -364,8 +372,9 @@ func TestValidatorDippingInAndOut(t *testing.T) {
 	params := sk.GetParams(ctx)
 	params.MaxValidators = 1
 	sk.SetParams(ctx, params)
-	amtInt := int64(100)
-	addr, val, amt := addrs[0], pks[0], sdk.NewInt(amtInt)
+	power := int64(100)
+	amt := staking.TokensFromTendermintPower(power)
+	addr, val := addrs[0], pks[0]
 	consAddr := sdk.ConsAddress(addr)
 	sh := staking.NewHandler(sk)
 	got := sh(ctx, NewTestMsgCreateValidator(addr, val, amt))
@@ -376,12 +385,12 @@ func TestValidatorDippingInAndOut(t *testing.T) {
 	height := int64(0)
 	for ; height < int64(100); height++ {
 		ctx = ctx.WithBlockHeight(height)
-		keeper.handleValidatorSignature(ctx, val.Address(), amtInt, true)
+		keeper.handleValidatorSignature(ctx, val.Address(), power, true)
 	}
 
 	// validator kicked out of validator set
-	newAmt := int64(101)
-	got = sh(ctx, NewTestMsgCreateValidator(addrs[1], pks[1], sdk.NewInt(newAmt)))
+	newAmt := staking.TokensFromTendermintPower(101)
+	got = sh(ctx, NewTestMsgCreateValidator(addrs[1], pks[1], newAmt))
 	require.True(t, got.IsOK())
 	validatorUpdates, _ := staking.EndBlocker(ctx, sk)
 	require.Equal(t, 2, len(validatorUpdates))
@@ -393,16 +402,17 @@ func TestValidatorDippingInAndOut(t *testing.T) {
 	ctx = ctx.WithBlockHeight(height)
 
 	// validator added back in
-	got = sh(ctx, newTestMsgDelegate(sdk.AccAddress(addrs[2]), addrs[0], sdk.NewInt(3)))
+	delTokens := types.TokensFromTendermintPower(3)
+	got = sh(ctx, newTestMsgDelegate(sdk.AccAddress(addrs[2]), addrs[0], delTokens))
 	require.True(t, got.IsOK())
 	validatorUpdates, _ = staking.EndBlocker(ctx, sk)
 	require.Equal(t, 2, len(validatorUpdates))
 	validator, _ = sk.GetValidator(ctx, addr)
 	require.Equal(t, sdk.Bonded, validator.Status)
-	newAmt = int64(103)
+	newPower := int64(103)
 
 	// validator misses a block
-	keeper.handleValidatorSignature(ctx, val.Address(), newAmt, false)
+	keeper.handleValidatorSignature(ctx, val.Address(), newPower, false)
 	height++
 
 	// shouldn't be jailed/kicked yet
@@ -413,7 +423,7 @@ func TestValidatorDippingInAndOut(t *testing.T) {
 	latest := height
 	for ; height < latest+500; height++ {
 		ctx = ctx.WithBlockHeight(height)
-		keeper.handleValidatorSignature(ctx, val.Address(), newAmt, false)
+		keeper.handleValidatorSignature(ctx, val.Address(), newPower, false)
 	}
 
 	// should now be jailed & kicked
@@ -438,7 +448,7 @@ func TestValidatorDippingInAndOut(t *testing.T) {
 
 	// validator rejoins and starts signing again
 	sk.Unjail(ctx, consAddr)
-	keeper.handleValidatorSignature(ctx, val.Address(), newAmt, true)
+	keeper.handleValidatorSignature(ctx, val.Address(), newPower, true)
 	height++
 
 	// validator should not be kicked since we reset counter/array when it was jailed
@@ -450,7 +460,7 @@ func TestValidatorDippingInAndOut(t *testing.T) {
 	latest = height
 	for ; height < latest+501; height++ {
 		ctx = ctx.WithBlockHeight(height)
-		keeper.handleValidatorSignature(ctx, val.Address(), newAmt, false)
+		keeper.handleValidatorSignature(ctx, val.Address(), newPower, false)
 	}
 
 	// validator should now be jailed & kicked
diff --git a/x/slashing/params.go b/x/slashing/params.go
index 1b500882c678..e5d68fbcd68a 100644
--- a/x/slashing/params.go
+++ b/x/slashing/params.go
@@ -81,11 +81,13 @@ func DefaultParams() Params {
 		// TODO Temporarily set to 10 minutes for testnets
 		DowntimeJailDuration: 60 * 10 * time.Second,
 
+		// CONTRACT must be less than 1
+		// TODO enforce this contract https://github.com/cosmos/cosmos-sdk/issues/3474
 		MinSignedPerWindow: sdk.NewDecWithPrec(5, 1),
 
-		SlashFractionDoubleSign: sdk.NewDec(1).Quo(sdk.NewDec(20)),
+		SlashFractionDoubleSign: sdk.NewDec(1).QuoInt64(20),
 
-		SlashFractionDowntime: sdk.NewDec(1).Quo(sdk.NewDec(100)),
+		SlashFractionDowntime: sdk.NewDec(1).QuoInt64(100),
 	}
 }
 
@@ -107,7 +109,10 @@ func (k Keeper) MinSignedPerWindow(ctx sdk.Context) int64 {
 	var minSignedPerWindow sdk.Dec
 	k.paramspace.Get(ctx, KeyMinSignedPerWindow, &minSignedPerWindow)
 	signedBlocksWindow := k.SignedBlocksWindow(ctx)
-	return sdk.NewDec(signedBlocksWindow).Mul(minSignedPerWindow).RoundInt64()
+
+	// NOTE: RoundInt64 will never panic as minSignedPerWindow is
+	//       less than 1.
+	return minSignedPerWindow.MulInt64(signedBlocksWindow).RoundInt64()
 }
 
 // Downtime unbond duration
diff --git a/x/slashing/signing_info.go b/x/slashing/signing_info.go
index 26c9501f549f..517304f1ae10 100644
--- a/x/slashing/signing_info.go
+++ b/x/slashing/signing_info.go
@@ -90,8 +90,19 @@ func (k Keeper) clearValidatorMissedBlockBitArray(ctx sdk.Context, address sdk.C
 	}
 }
 
+// Signing info for a validator
+type ValidatorSigningInfo struct {
+	StartHeight         int64     `json:"start_height"`          // height at which validator was first a candidate OR was unjailed
+	IndexOffset         int64     `json:"index_offset"`          // index offset into signed block bit array
+	JailedUntil         time.Time `json:"jailed_until"`          // timestamp validator cannot be unjailed until
+	Tombstoned          bool      `json:"tombstoned"`            // whether or not a validator has been tombstoned (killed out of validator set)
+	MissedBlocksCounter int64     `json:"missed_blocks_counter"` // missed blocks counter (to avoid scanning the array every time)
+}
+
 // Construct a new `ValidatorSigningInfo` struct
-func NewValidatorSigningInfo(startHeight int64, indexOffset int64, jailedUntil time.Time, tombstoned bool, missedBlocksCounter int64) ValidatorSigningInfo {
+func NewValidatorSigningInfo(startHeight, indexOffset int64, jailedUntil time.Time,
+	tombstoned bool, missedBlocksCounter int64) ValidatorSigningInfo {
+
 	return ValidatorSigningInfo{
 		StartHeight:         startHeight,
 		IndexOffset:         indexOffset,
@@ -101,15 +112,6 @@ func NewValidatorSigningInfo(startHeight int64, indexOffset int64, jailedUntil t
 	}
 }
 
-// Signing info for a validator
-type ValidatorSigningInfo struct {
-	StartHeight         int64     `json:"start_height"`          // height at which validator was first a candidate OR was unjailed
-	IndexOffset         int64     `json:"index_offset"`          // index offset into signed block bit array
-	JailedUntil         time.Time `json:"jailed_until"`          // timestamp validator cannot be unjailed until
-	Tombstoned          bool      `json:"tombstoned"`            // whether or not a validator has been tombstoned (killed out of validator set)
-	MissedBlocksCounter int64     `json:"missed_blocks_counter"` // missed blocks counter (to avoid scanning the array every time)
-}
-
 // Return human readable signing info
 func (i ValidatorSigningInfo) String() string {
 	return fmt.Sprintf(`Start Height:          %d
diff --git a/x/slashing/test_common.go b/x/slashing/test_common.go
index 4289618545b0..93d12d7716c4 100644
--- a/x/slashing/test_common.go
+++ b/x/slashing/test_common.go
@@ -21,7 +21,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/params"
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 // TODO remove dependencies on staking (should only refer to validator set type from sdk)
@@ -37,7 +36,7 @@ var (
 		sdk.ValAddress(pks[1].Address()),
 		sdk.ValAddress(pks[2].Address()),
 	}
-	initCoins = sdk.NewInt(200)
+	initCoins = staking.TokensFromTendermintPower(200)
 )
 
 func createTestCodec() *codec.Codec {
@@ -76,7 +75,7 @@ func createTestInput(t *testing.T, defaults Params) (sdk.Context, bank.Keeper, s
 	sk := staking.NewKeeper(cdc, keyStaking, tkeyStaking, ck, paramsKeeper.Subspace(staking.DefaultParamspace), staking.DefaultCodespace)
 	genesis := staking.DefaultGenesisState()
 
-	genesis.Pool.NotBondedTokens = sdk.NewInt(initCoins.MulRaw(int64(len(addrs))).Int64())
+	genesis.Pool.NotBondedTokens = initCoins.MulRaw(int64(len(addrs)))
 
 	_, err = staking.InitGenesis(ctx, sk, genesis)
 	require.Nil(t, err)
@@ -116,7 +115,7 @@ func testAddr(addr string) sdk.AccAddress {
 func NewTestMsgCreateValidator(address sdk.ValAddress, pubKey crypto.PubKey, amt sdk.Int) staking.MsgCreateValidator {
 	commission := staking.NewCommissionMsg(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())
 	return staking.NewMsgCreateValidator(
-		address, pubKey, sdk.NewCoin(stakingTypes.DefaultBondDenom, amt),
+		address, pubKey, sdk.NewCoin(staking.DefaultBondDenom, amt),
 		staking.Description{}, commission,
 	)
 }
diff --git a/x/slashing/tick_test.go b/x/slashing/tick_test.go
index 9ee6d03c0403..2476ec99bd34 100644
--- a/x/slashing/tick_test.go
+++ b/x/slashing/tick_test.go
@@ -10,11 +10,14 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/staking"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 func TestBeginBlocker(t *testing.T) {
 	ctx, ck, sk, _, keeper := createTestInput(t, DefaultParams())
-	addr, pk, amt := addrs[2], pks[2], sdk.NewInt(100)
+	power := int64(100)
+	amt := types.TokensFromTendermintPower(power)
+	addr, pk := addrs[2], pks[2]
 
 	// bond the validator
 	got := staking.NewHandler(sk)(ctx, NewTestMsgCreateValidator(addr, pk, amt))
@@ -24,7 +27,7 @@ func TestBeginBlocker(t *testing.T) {
 		t, ck.GetCoins(ctx, sdk.AccAddress(addr)),
 		sdk.Coins{sdk.NewCoin(sk.GetParams(ctx).BondDenom, initCoins.Sub(amt))},
 	)
-	require.True(sdk.IntEq(t, amt, sk.Validator(ctx, addr).GetPower()))
+	require.Equal(t, amt, sk.Validator(ctx, addr).GetBondedTokens())
 
 	val := abci.Validator{
 		Address: pk.Address(),
diff --git a/x/staking/app_test.go b/x/staking/app_test.go
index c7203c6e7fca..a160595c7032 100644
--- a/x/staking/app_test.go
+++ b/x/staking/app_test.go
@@ -10,7 +10,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/bank"
 	"github.com/cosmos/cosmos-sdk/x/mock"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 // getMockApp returns an initialized mock application for this module.
@@ -52,7 +51,8 @@ func getInitChainer(mapp *mock.App, keeper Keeper) sdk.InitChainer {
 		mapp.InitChainer(ctx, req)
 
 		stakingGenesis := DefaultGenesisState()
-		stakingGenesis.Pool.NotBondedTokens = sdk.NewInt(100000)
+		tokens := TokensFromTendermintPower(100000)
+		stakingGenesis.Pool.NotBondedTokens = tokens
 
 		validators, err := InitGenesis(ctx, keeper, stakingGenesis)
 		if err != nil {
@@ -97,8 +97,10 @@ func checkDelegation(
 func TestStakingMsgs(t *testing.T) {
 	mApp, keeper := getMockApp(t)
 
-	genCoin := sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 42)
-	bondCoin := sdk.NewInt64Coin(stakingTypes.DefaultBondDenom, 10)
+	genTokens := TokensFromTendermintPower(42)
+	bondTokens := TokensFromTendermintPower(10)
+	genCoin := sdk.NewCoin(DefaultBondDenom, genTokens)
+	bondCoin := sdk.NewCoin(DefaultBondDenom, bondTokens)
 
 	acc1 := &auth.BaseAccount{
 		Address: addr1,
@@ -127,7 +129,7 @@ func TestStakingMsgs(t *testing.T) {
 	validator := checkValidator(t, mApp, keeper, sdk.ValAddress(addr1), true)
 	require.Equal(t, sdk.ValAddress(addr1), validator.OperatorAddr)
 	require.Equal(t, sdk.Bonded, validator.Status)
-	require.True(sdk.IntEq(t, sdk.NewInt(10), validator.BondedTokens()))
+	require.True(sdk.IntEq(t, bondTokens, validator.BondedTokens()))
 
 	// addr1 create validator on behalf of addr2
 	createValidatorMsgOnBehalfOf := NewMsgCreateValidatorOnBehalfOf(
@@ -141,10 +143,10 @@ func TestStakingMsgs(t *testing.T) {
 	validator = checkValidator(t, mApp, keeper, sdk.ValAddress(addr2), true)
 	require.Equal(t, sdk.ValAddress(addr2), validator.OperatorAddr)
 	require.Equal(t, sdk.Bonded, validator.Status)
-	require.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
+	require.True(sdk.IntEq(t, bondTokens, validator.Tokens))
 
 	// check the bond that should have been created as well
-	checkDelegation(t, mApp, keeper, addr1, sdk.ValAddress(addr1), true, sdk.NewDec(10))
+	checkDelegation(t, mApp, keeper, addr1, sdk.ValAddress(addr1), true, sdk.NewDecFromInt(bondTokens))
 
 	// edit the validator
 	description = NewDescription("bar_moniker", "", "", "")
@@ -160,10 +162,10 @@ func TestStakingMsgs(t *testing.T) {
 
 	mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, []sdk.Msg{delegateMsg}, []uint64{0}, []uint64{1}, true, true, priv2)
 	mock.CheckBalance(t, mApp, addr2, sdk.Coins{genCoin.Minus(bondCoin)})
-	checkDelegation(t, mApp, keeper, addr2, sdk.ValAddress(addr1), true, sdk.NewDec(10))
+	checkDelegation(t, mApp, keeper, addr2, sdk.ValAddress(addr1), true, sdk.NewDecFromInt(bondTokens))
 
 	// begin unbonding
-	beginUnbondingMsg := NewMsgUndelegate(addr2, sdk.ValAddress(addr1), sdk.NewDec(10))
+	beginUnbondingMsg := NewMsgUndelegate(addr2, sdk.ValAddress(addr1), sdk.NewDecFromInt(bondTokens))
 	mock.SignCheckDeliver(t, mApp.Cdc, mApp.BaseApp, []sdk.Msg{beginUnbondingMsg}, []uint64{0}, []uint64{2}, true, true, priv2)
 
 	// delegation should exist anymore
diff --git a/x/staking/genesis.go b/x/staking/genesis.go
index 8fa52c07ac5c..40df1a2f4630 100644
--- a/x/staking/genesis.go
+++ b/x/staking/genesis.go
@@ -77,7 +77,7 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, data types.GenesisState) (res [
 				panic("expected validator, not found")
 			}
 			update := validator.ABCIValidatorUpdate()
-			update.Power = lv.Power.Int64() // keep the next-val-set offset, use the last power for the first block
+			update.Power = lv.Power // keep the next-val-set offset, use the last power for the first block
 			res = append(res, update)
 		}
 	} else {
@@ -107,7 +107,7 @@ func ExportGenesis(ctx sdk.Context, keeper Keeper) types.GenesisState {
 		return false
 	})
 	var lastValidatorPowers []types.LastValidatorPower
-	keeper.IterateLastValidatorPowers(ctx, func(addr sdk.ValAddress, power sdk.Int) (stop bool) {
+	keeper.IterateLastValidatorPowers(ctx, func(addr sdk.ValAddress, power int64) (stop bool) {
 		lastValidatorPowers = append(lastValidatorPowers, types.LastValidatorPower{addr, power})
 		return false
 	})
@@ -130,7 +130,7 @@ func WriteValidators(ctx sdk.Context, keeper Keeper) (vals []tmtypes.GenesisVali
 	keeper.IterateLastValidators(ctx, func(_ int64, validator sdk.Validator) (stop bool) {
 		vals = append(vals, tmtypes.GenesisValidator{
 			PubKey: validator.GetConsPubKey(),
-			Power:  validator.GetPower().Int64(),
+			Power:  validator.GetTendermintPower(),
 			Name:   validator.GetMoniker(),
 		})
 
diff --git a/x/staking/genesis_test.go b/x/staking/genesis_test.go
index ac9174651729..9a9a716fef86 100644
--- a/x/staking/genesis_test.go
+++ b/x/staking/genesis_test.go
@@ -20,7 +20,8 @@ func TestInitGenesis(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, 1000)
 
 	pool := keeper.GetPool(ctx)
-	pool.BondedTokens = sdk.NewInt(2)
+	pool.BondedTokens = TokensFromTendermintPower(2)
+	valTokens := TokensFromTendermintPower(1)
 
 	params := keeper.GetParams(ctx)
 	validators := make([]Validator, 2)
@@ -29,16 +30,16 @@ func TestInitGenesis(t *testing.T) {
 	// initialize the validators
 	validators[0].OperatorAddr = sdk.ValAddress(keep.Addrs[0])
 	validators[0].ConsPubKey = keep.PKs[0]
-	validators[0].Description = Description{Moniker: "hoop"}
+	validators[0].Description = NewDescription("hoop", "", "", "")
 	validators[0].Status = sdk.Bonded
-	validators[0].Tokens = sdk.OneInt()
-	validators[0].DelegatorShares = sdk.OneDec()
+	validators[0].Tokens = valTokens
+	validators[0].DelegatorShares = sdk.NewDecFromInt(valTokens)
 	validators[1].OperatorAddr = sdk.ValAddress(keep.Addrs[1])
 	validators[1].ConsPubKey = keep.PKs[1]
-	validators[1].Description = Description{Moniker: "bloop"}
+	validators[1].Description = NewDescription("bloop", "", "", "")
 	validators[1].Status = sdk.Bonded
-	validators[1].Tokens = sdk.OneInt()
-	validators[1].DelegatorShares = sdk.OneDec()
+	validators[1].Tokens = valTokens
+	validators[1].DelegatorShares = sdk.NewDecFromInt(valTokens)
 
 	genesisState := types.NewGenesisState(pool, params, validators, delegations)
 	vals, err := InitGenesis(ctx, keeper, genesisState)
@@ -75,23 +76,25 @@ func TestInitGenesisLargeValidatorSet(t *testing.T) {
 
 	// Assigning 2 to the first 100 vals, 1 to the rest
 	pool := keeper.GetPool(ctx)
-	pool.BondedTokens = sdk.NewInt(int64(200 + (size - 100)))
+	bondedTokens := TokensFromTendermintPower(int64(200 + (size - 100)))
+	pool.BondedTokens = bondedTokens
 
 	params := keeper.GetParams(ctx)
 	delegations := []Delegation{}
 	validators := make([]Validator, size)
 
 	for i := range validators {
-		validators[i] = NewValidator(sdk.ValAddress(keep.Addrs[i]), keep.PKs[i], Description{Moniker: fmt.Sprintf("#%d", i)})
+		validators[i] = NewValidator(sdk.ValAddress(keep.Addrs[i]),
+			keep.PKs[i], NewDescription(fmt.Sprintf("#%d", i), "", "", ""))
 
 		validators[i].Status = sdk.Bonded
+
+		tokens := TokensFromTendermintPower(1)
 		if i < 100 {
-			validators[i].Tokens = sdk.NewInt(2)
-			validators[i].DelegatorShares = sdk.NewDec(2)
-		} else {
-			validators[i].Tokens = sdk.OneInt()
-			validators[i].DelegatorShares = sdk.OneDec()
+			tokens = TokensFromTendermintPower(2)
 		}
+		validators[i].Tokens = tokens
+		validators[i].DelegatorShares = sdk.NewDecFromInt(tokens)
 	}
 
 	genesisState := types.NewGenesisState(pool, params, validators, delegations)
diff --git a/x/staking/handler_test.go b/x/staking/handler_test.go
index 3caecca44078..e9692e7fff53 100644
--- a/x/staking/handler_test.go
+++ b/x/staking/handler_test.go
@@ -31,8 +31,9 @@ func setInstantUnbondPeriod(keeper keep.Keeper, ctx sdk.Context) types.Params {
 func TestValidatorByPowerIndex(t *testing.T) {
 	validatorAddr, validatorAddr3 := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1])
 
-	initBond := int64(1000000)
-	ctx, _, keeper := keep.CreateTestInput(t, false, initBond)
+	initPower := int64(1000000)
+	initBond := TokensFromTendermintPower(initPower)
+	ctx, _, keeper := keep.CreateTestInput(t, false, initPower)
 	_ = setInstantUnbondPeriod(keeper, ctx)
 
 	// create validator
@@ -47,10 +48,8 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	// verify the self-delegation exists
 	bond, found := keeper.GetDelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr)
 	require.True(t, found)
-	gotBond := bond.Shares.RoundInt64()
-	require.Equal(t, initBond, gotBond,
-		"initBond: %v\ngotBond: %v\nbond: %v\n",
-		initBond, gotBond, bond)
+	gotBond := bond.Shares.RoundInt()
+	require.Equal(t, initBond, gotBond)
 
 	// verify that the by power index exists
 	validator, found := keeper.GetValidator(ctx, validatorAddr)
@@ -59,7 +58,7 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	require.True(t, keep.ValidatorByPowerIndexExists(ctx, keeper, power))
 
 	// create a second validator keep it bonded
-	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], int64(1000000))
+	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], initBond)
 	got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected create-validator to be ok, got %v", got)
 
@@ -69,13 +68,13 @@ func TestValidatorByPowerIndex(t *testing.T) {
 
 	// slash and jail the first validator
 	consAddr0 := sdk.ConsAddress(keep.PKs[0].Address())
-	keeper.Slash(ctx, consAddr0, 0, initBond, sdk.NewDecWithPrec(5, 1))
+	keeper.Slash(ctx, consAddr0, 0, initPower, sdk.NewDecWithPrec(5, 1))
 	keeper.Jail(ctx, consAddr0)
 	keeper.ApplyAndReturnValidatorSetUpdates(ctx)
 	validator, found = keeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
-	require.Equal(t, sdk.Unbonding, validator.Status)         // ensure is unbonding
-	require.Equal(t, int64(500000), validator.Tokens.Int64()) // ensure tokens slashed
+	require.Equal(t, sdk.Unbonding, validator.Status)      // ensure is unbonding
+	require.Equal(t, initBond.DivRaw(2), validator.Tokens) // ensure tokens slashed
 	keeper.Unjail(ctx, consAddr0)
 
 	// the old power record should have been deleted as the power changed
@@ -92,7 +91,7 @@ func TestValidatorByPowerIndex(t *testing.T) {
 	require.Equal(t, power2, power3)
 
 	// unbond self-delegation
-	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(1000000))
+	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDecFromInt(initBond))
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected msg to be ok, got %v", got)
 	var finishTime time.Time
@@ -114,7 +113,8 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) {
 	addr1, addr2 := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1])
 	pk1, pk2 := keep.PKs[0], keep.PKs[1]
 
-	msgCreateValidator1 := NewTestMsgCreateValidator(addr1, pk1, 10)
+	valTokens := types.TokensFromTendermintPower(10)
+	msgCreateValidator1 := NewTestMsgCreateValidator(addr1, pk1, valTokens)
 	got := handleMsgCreateValidator(ctx, msgCreateValidator1, keeper)
 	require.True(t, got.IsOK(), "%v", got)
 
@@ -125,22 +125,22 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) {
 	assert.Equal(t, sdk.Bonded, validator.Status)
 	assert.Equal(t, addr1, validator.OperatorAddr)
 	assert.Equal(t, pk1, validator.ConsPubKey)
-	assert.Equal(t, int64(10), validator.BondedTokens().Int64())
-	assert.Equal(t, sdk.NewDec(10), validator.DelegatorShares)
+	assert.Equal(t, valTokens, validator.BondedTokens())
+	assert.Equal(t, sdk.NewDecFromInt(valTokens), validator.DelegatorShares)
 	assert.Equal(t, Description{}, validator.Description)
 
 	// two validators can't have the same operator address
-	msgCreateValidator2 := NewTestMsgCreateValidator(addr1, pk2, 10)
+	msgCreateValidator2 := NewTestMsgCreateValidator(addr1, pk2, valTokens)
 	got = handleMsgCreateValidator(ctx, msgCreateValidator2, keeper)
 	require.False(t, got.IsOK(), "%v", got)
 
 	// two validators can't have the same pubkey
-	msgCreateValidator3 := NewTestMsgCreateValidator(addr2, pk1, 10)
+	msgCreateValidator3 := NewTestMsgCreateValidator(addr2, pk1, valTokens)
 	got = handleMsgCreateValidator(ctx, msgCreateValidator3, keeper)
 	require.False(t, got.IsOK(), "%v", got)
 
 	// must have different pubkey and operator
-	msgCreateValidator4 := NewTestMsgCreateValidator(addr2, pk2, 10)
+	msgCreateValidator4 := NewTestMsgCreateValidator(addr2, pk2, valTokens)
 	got = handleMsgCreateValidator(ctx, msgCreateValidator4, keeper)
 	require.True(t, got.IsOK(), "%v", got)
 
@@ -154,8 +154,8 @@ func TestDuplicatesMsgCreateValidator(t *testing.T) {
 	assert.Equal(t, sdk.Bonded, validator.Status)
 	assert.Equal(t, addr2, validator.OperatorAddr)
 	assert.Equal(t, pk2, validator.ConsPubKey)
-	assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
-	assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
+	assert.True(sdk.IntEq(t, valTokens, validator.Tokens))
+	assert.True(sdk.DecEq(t, sdk.NewDecFromInt(valTokens), validator.DelegatorShares))
 	assert.Equal(t, Description{}, validator.Description)
 }
 
@@ -166,7 +166,7 @@ func TestInvalidPubKeyTypeMsgCreateValidator(t *testing.T) {
 	invalidPk := secp256k1.GenPrivKey().PubKey()
 
 	// invalid pukKey type should not be allowed
-	msgCreateValidator := NewTestMsgCreateValidator(addr, invalidPk, 10)
+	msgCreateValidator := NewTestMsgCreateValidator(addr, invalidPk, sdk.NewInt(10))
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.False(t, got.IsOK(), "%v", got)
 
@@ -184,7 +184,8 @@ func TestDuplicatesMsgCreateValidatorOnBehalfOf(t *testing.T) {
 	validatorAddr := sdk.ValAddress(keep.Addrs[0])
 	delegatorAddr := keep.Addrs[1]
 	pk := keep.PKs[0]
-	msgCreateValidatorOnBehalfOf := NewTestMsgCreateValidatorOnBehalfOf(delegatorAddr, validatorAddr, pk, 10)
+	valTokens := types.TokensFromTendermintPower(10)
+	msgCreateValidatorOnBehalfOf := NewTestMsgCreateValidatorOnBehalfOf(delegatorAddr, validatorAddr, pk, valTokens)
 	got := handleMsgCreateValidator(ctx, msgCreateValidatorOnBehalfOf, keeper)
 	require.True(t, got.IsOK(), "%v", got)
 
@@ -198,8 +199,8 @@ func TestDuplicatesMsgCreateValidatorOnBehalfOf(t *testing.T) {
 	assert.Equal(t, sdk.Bonded, validator.Status)
 	assert.Equal(t, validatorAddr, validator.OperatorAddr)
 	assert.Equal(t, pk, validator.ConsPubKey)
-	assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
-	assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
+	assert.True(sdk.IntEq(t, valTokens, validator.Tokens))
+	assert.True(sdk.DecEq(t, sdk.NewDecFromInt(valTokens), validator.DelegatorShares))
 	assert.Equal(t, Description{}, validator.Description)
 
 	// one validator cannot be created twice even from different delegator
@@ -213,7 +214,7 @@ func TestLegacyValidatorDelegations(t *testing.T) {
 	ctx, _, keeper := keep.CreateTestInput(t, false, int64(1000))
 	setInstantUnbondPeriod(keeper, ctx)
 
-	bondAmount := int64(10)
+	bondAmount := TokensFromTendermintPower(10)
 	valAddr := sdk.ValAddress(keep.Addrs[0])
 	valConsPubKey, valConsAddr := keep.PKs[0], sdk.ConsAddress(keep.PKs[0].Address())
 	delAddr := keep.Addrs[1]
@@ -231,8 +232,8 @@ func TestLegacyValidatorDelegations(t *testing.T) {
 	validator, found := keeper.GetValidator(ctx, valAddr)
 	require.True(t, found)
 	require.Equal(t, sdk.Bonded, validator.Status)
-	require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt64())
-	require.Equal(t, bondAmount, validator.BondedTokens().Int64())
+	require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt())
+	require.Equal(t, bondAmount, validator.BondedTokens())
 
 	// delegate tokens to the validator
 	msgDelegate := NewTestMsgDelegate(delAddr, valAddr, bondAmount)
@@ -242,12 +243,12 @@ func TestLegacyValidatorDelegations(t *testing.T) {
 	// verify validator bonded shares
 	validator, found = keeper.GetValidator(ctx, valAddr)
 	require.True(t, found)
-	require.Equal(t, bondAmount*2, validator.DelegatorShares.RoundInt64())
-	require.Equal(t, bondAmount*2, validator.BondedTokens().Int64())
+	require.Equal(t, bondAmount.MulRaw(2), validator.DelegatorShares.RoundInt())
+	require.Equal(t, bondAmount.MulRaw(2), validator.BondedTokens())
 
 	// unbond validator total self-delegations (which should jail the validator)
-	unbondShares := sdk.NewDec(10)
-	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(valAddr), valAddr, unbondShares)
+	unbondShares := types.TokensFromTendermintPower(10)
+	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(valAddr), valAddr, sdk.NewDecFromInt(unbondShares))
 
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected begin unbonding validator msg to be ok, got %v", got)
@@ -261,13 +262,13 @@ func TestLegacyValidatorDelegations(t *testing.T) {
 	validator, found = keeper.GetValidator(ctx, valAddr)
 	require.True(t, found)
 	require.True(t, validator.Jailed)
-	require.Equal(t, int64(10), validator.Tokens.Int64())
+	require.Equal(t, bondAmount, validator.Tokens)
 
 	// verify delegation still exists
 	bond, found := keeper.GetDelegation(ctx, delAddr, valAddr)
 	require.True(t, found)
-	require.Equal(t, bondAmount, bond.Shares.RoundInt64())
-	require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt64())
+	require.Equal(t, bondAmount, bond.Shares.RoundInt())
+	require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt())
 
 	// verify a delegator cannot create a new delegation to the now jailed validator
 	msgDelegate = NewTestMsgDelegate(delAddr, valAddr, bondAmount)
@@ -282,8 +283,8 @@ func TestLegacyValidatorDelegations(t *testing.T) {
 	// verify validator bonded shares
 	validator, found = keeper.GetValidator(ctx, valAddr)
 	require.True(t, found)
-	require.Equal(t, bondAmount*2, validator.DelegatorShares.RoundInt64())
-	require.Equal(t, bondAmount*2, validator.Tokens.Int64())
+	require.Equal(t, bondAmount.MulRaw(2), validator.DelegatorShares.RoundInt())
+	require.Equal(t, bondAmount.MulRaw(2), validator.Tokens)
 
 	// unjail the validator now that is has non-zero self-delegated shares
 	keeper.Unjail(ctx, valConsAddr)
@@ -296,22 +297,23 @@ func TestLegacyValidatorDelegations(t *testing.T) {
 	// verify validator bonded shares
 	validator, found = keeper.GetValidator(ctx, valAddr)
 	require.True(t, found)
-	require.Equal(t, bondAmount*3, validator.DelegatorShares.RoundInt64())
-	require.Equal(t, bondAmount*3, validator.Tokens.Int64())
+	require.Equal(t, bondAmount.MulRaw(3), validator.DelegatorShares.RoundInt())
+	require.Equal(t, bondAmount.MulRaw(3), validator.Tokens)
 
 	// verify new delegation
 	bond, found = keeper.GetDelegation(ctx, delAddr, valAddr)
 	require.True(t, found)
-	require.Equal(t, bondAmount*2, bond.Shares.RoundInt64())
-	require.Equal(t, bondAmount*3, validator.DelegatorShares.RoundInt64())
+	require.Equal(t, bondAmount.MulRaw(2), bond.Shares.RoundInt())
+	require.Equal(t, bondAmount.MulRaw(3), validator.DelegatorShares.RoundInt())
 }
 
 func TestIncrementsMsgDelegate(t *testing.T) {
-	initBond := int64(1000)
-	ctx, accMapper, keeper := keep.CreateTestInput(t, false, initBond)
+	initPower := int64(1000)
+	initBond := TokensFromTendermintPower(initPower)
+	ctx, accMapper, keeper := keep.CreateTestInput(t, false, initPower)
 	params := keeper.GetParams(ctx)
 
-	bondAmount := int64(10)
+	bondAmount := TokensFromTendermintPower(10)
 	validatorAddr, delegatorAddr := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1]
 
 	// first create validator
@@ -325,25 +327,25 @@ func TestIncrementsMsgDelegate(t *testing.T) {
 	validator, found := keeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
 	require.Equal(t, sdk.Bonded, validator.Status)
-	require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt64())
-	require.Equal(t, bondAmount, validator.BondedTokens().Int64(), "validator: %v", validator)
+	require.Equal(t, bondAmount, validator.DelegatorShares.RoundInt())
+	require.Equal(t, bondAmount, validator.BondedTokens(), "validator: %v", validator)
 
 	_, found = keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
 	require.False(t, found)
 
 	bond, found := keeper.GetDelegation(ctx, sdk.AccAddress(validatorAddr), validatorAddr)
 	require.True(t, found)
-	require.Equal(t, bondAmount, bond.Shares.RoundInt64())
+	require.Equal(t, bondAmount, bond.Shares.RoundInt())
 
 	pool := keeper.GetPool(ctx)
 	exRate := validator.DelegatorShareExRate()
 	require.True(t, exRate.Equal(sdk.OneDec()), "expected exRate 1 got %v", exRate)
-	require.Equal(t, bondAmount, pool.BondedTokens.Int64())
+	require.Equal(t, bondAmount, pool.BondedTokens)
 
 	// just send the same msgbond multiple times
 	msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, bondAmount)
 
-	for i := 0; i < 5; i++ {
+	for i := int64(0); i < 5; i++ {
 		ctx = ctx.WithBlockHeight(int64(i))
 
 		got := handleMsgDelegate(ctx, msgDelegate, keeper)
@@ -358,12 +360,12 @@ func TestIncrementsMsgDelegate(t *testing.T) {
 		exRate := validator.DelegatorShareExRate()
 		require.True(t, exRate.Equal(sdk.OneDec()), "expected exRate 1 got %v, i = %v", exRate, i)
 
-		expBond := int64(i+1) * bondAmount
-		expDelegatorShares := int64(i+2) * bondAmount // (1 self delegation)
-		expDelegatorAcc := sdk.NewInt(initBond - expBond)
+		expBond := bondAmount.MulRaw(i + 1)
+		expDelegatorShares := bondAmount.MulRaw(i + 2) // (1 self delegation)
+		expDelegatorAcc := initBond.Sub(expBond)
 
-		gotBond := bond.Shares.RoundInt64()
-		gotDelegatorShares := validator.DelegatorShares.RoundInt64()
+		gotBond := bond.Shares.RoundInt()
+		gotDelegatorShares := validator.DelegatorShares.RoundInt()
 		gotDelegatorAcc := accMapper.GetAccount(ctx, delegatorAddr).GetCoins().AmountOf(params.BondDenom)
 
 		require.Equal(t, expBond, gotBond,
@@ -379,8 +381,9 @@ func TestIncrementsMsgDelegate(t *testing.T) {
 }
 
 func TestIncrementsMsgUnbond(t *testing.T) {
-	initBond := int64(1000)
-	ctx, accMapper, keeper := keep.CreateTestInput(t, false, initBond)
+	initPower := int64(1000)
+	initBond := TokensFromTendermintPower(initPower)
+	ctx, accMapper, keeper := keep.CreateTestInput(t, false, initPower)
 	params := setInstantUnbondPeriod(keeper, ctx)
 	denom := params.BondDenom
 
@@ -400,22 +403,22 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 
 	// balance should have been subtracted after delegation
 	amt2 := accMapper.GetAccount(ctx, delegatorAddr).GetCoins().AmountOf(denom)
-	require.Equal(t, amt1.Sub(sdk.NewInt(initBond)).Int64(), amt2.Int64(), "expected coins to be subtracted")
+	require.True(sdk.IntEq(t, amt1.Sub(initBond), amt2))
 
 	// apply TM updates
 	keeper.ApplyAndReturnValidatorSetUpdates(ctx)
 
 	validator, found := keeper.GetValidator(ctx, validatorAddr)
 	require.True(t, found)
-	require.Equal(t, initBond*2, validator.DelegatorShares.RoundInt64())
-	require.Equal(t, initBond*2, validator.BondedTokens().Int64())
+	require.Equal(t, initBond.MulRaw(2), validator.DelegatorShares.RoundInt())
+	require.Equal(t, initBond.MulRaw(2), validator.BondedTokens())
 
 	// just send the same msgUnbond multiple times
 	// TODO use decimals here
 	unbondShares := sdk.NewDec(10)
 	msgUndelegate := NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
-	numUnbonds := 5
-	for i := 0; i < numUnbonds; i++ {
+	numUnbonds := int64(5)
+	for i := int64(0); i < numUnbonds; i++ {
 
 		got := handleMsgUndelegate(ctx, msgUndelegate, keeper)
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
@@ -430,12 +433,12 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 		bond, found := keeper.GetDelegation(ctx, delegatorAddr, validatorAddr)
 		require.True(t, found)
 
-		expBond := initBond - int64(i+1)*unbondShares.RoundInt64()
-		expDelegatorShares := 2*initBond - int64(i+1)*unbondShares.RoundInt64()
-		expDelegatorAcc := sdk.NewInt(initBond - expBond)
+		expBond := initBond.Sub(unbondShares.MulInt64(i + 1).RoundInt())
+		expDelegatorShares := (initBond.MulRaw(2)).Sub(unbondShares.MulInt64(i + 1).RoundInt())
+		expDelegatorAcc := initBond.Sub(expBond)
 
-		gotBond := bond.Shares.RoundInt64()
-		gotDelegatorShares := validator.DelegatorShares.RoundInt64()
+		gotBond := bond.Shares.RoundInt()
+		gotDelegatorShares := validator.DelegatorShares.RoundInt()
 		gotDelegatorAcc := accMapper.GetAccount(ctx, delegatorAddr).GetCoins().AmountOf(params.BondDenom)
 
 		require.Equal(t, expBond, gotBond,
@@ -450,31 +453,31 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 	}
 
 	// these are more than we have bonded now
-	errorCases := []int64{
-		//1<<64 - 1, // more than int64
-		//1<<63 + 1, // more than int64
-		1<<63 - 1,
-		1 << 31,
+	errorCases := []sdk.Int{
+		//1<<64 - 1, // more than int64 power
+		//1<<63 + 1, // more than int64 power
+		types.TokensFromTendermintPower(1<<63 - 1),
+		types.TokensFromTendermintPower(1 << 31),
 		initBond,
 	}
-	for _, c := range errorCases {
-		unbondShares := sdk.NewDec(c)
+	for i, c := range errorCases {
+		unbondShares := sdk.NewDecFromInt(c)
 		msgUndelegate := NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
 		got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
-		require.False(t, got.IsOK(), "expected unbond msg to fail")
+		require.False(t, got.IsOK(), "expected unbond msg to fail, index: %v", i)
 	}
 
-	leftBonded := initBond - int64(numUnbonds)*unbondShares.RoundInt64()
+	leftBonded := initBond.Sub(unbondShares.MulInt64(numUnbonds).RoundInt())
 
 	// should be unable to unbond one more than we have
-	unbondShares = sdk.NewDec(leftBonded + 1)
+	unbondShares = sdk.NewDecFromInt(leftBonded.AddRaw(1))
 	msgUndelegate = NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.False(t, got.IsOK(),
 		"got: %v\nmsgUnbond: %v\nshares: %v\nleftBonded: %v\n", got, msgUndelegate, unbondShares.String(), leftBonded)
 
 	// should be able to unbond just what we have
-	unbondShares = sdk.NewDec(leftBonded)
+	unbondShares = sdk.NewDecFromInt(leftBonded)
 	msgUndelegate = NewMsgUndelegate(delegatorAddr, validatorAddr, unbondShares)
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(),
@@ -482,16 +485,27 @@ func TestIncrementsMsgUnbond(t *testing.T) {
 }
 
 func TestMultipleMsgCreateValidator(t *testing.T) {
-	initBond := int64(1000)
-	ctx, accMapper, keeper := keep.CreateTestInput(t, false, initBond)
+	initPower := int64(1000)
+	initTokens := types.TokensFromTendermintPower(initPower)
+	ctx, accMapper, keeper := keep.CreateTestInput(t, false, initPower)
 	params := setInstantUnbondPeriod(keeper, ctx)
 
-	validatorAddrs := []sdk.ValAddress{sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1]), sdk.ValAddress(keep.Addrs[2])}
-	delegatorAddrs := []sdk.AccAddress{keep.Addrs[3], keep.Addrs[4], keep.Addrs[5]}
+	validatorAddrs := []sdk.ValAddress{
+		sdk.ValAddress(keep.Addrs[0]),
+		sdk.ValAddress(keep.Addrs[1]),
+		sdk.ValAddress(keep.Addrs[2]),
+	}
+	delegatorAddrs := []sdk.AccAddress{
+		keep.Addrs[3],
+		keep.Addrs[4],
+		keep.Addrs[5],
+	}
 
 	// bond them all
 	for i, validatorAddr := range validatorAddrs {
-		msgCreateValidatorOnBehalfOf := NewTestMsgCreateValidatorOnBehalfOf(delegatorAddrs[i], validatorAddr, keep.PKs[i], 10)
+		valTokens := types.TokensFromTendermintPower(10)
+		msgCreateValidatorOnBehalfOf := NewTestMsgCreateValidatorOnBehalfOf(
+			delegatorAddrs[i], validatorAddr, keep.PKs[i], valTokens)
 		got := handleMsgCreateValidator(ctx, msgCreateValidatorOnBehalfOf, keeper)
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
 
@@ -499,10 +513,10 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
 		validators := keeper.GetValidators(ctx, 100)
 		require.Equal(t, (i + 1), len(validators))
 		val := validators[i]
-		balanceExpd := sdk.NewInt(initBond - 10)
+		balanceExpd := initTokens.Sub(valTokens)
 		balanceGot := accMapper.GetAccount(ctx, delegatorAddrs[i]).GetCoins().AmountOf(params.BondDenom)
 		require.Equal(t, i+1, len(validators), "expected %d validators got %d, validators: %v", i+1, len(validators), validators)
-		require.Equal(t, 10, int(val.DelegatorShares.RoundInt64()), "expected %d shares, got %d", 10, val.DelegatorShares)
+		require.Equal(t, valTokens, val.DelegatorShares.RoundInt(), "expected %d shares, got %d", 10, val.DelegatorShares)
 		require.Equal(t, balanceExpd, balanceGot, "expected account to have %d, got %d", balanceExpd, balanceGot)
 	}
 
@@ -510,7 +524,8 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
 	for i, validatorAddr := range validatorAddrs {
 		_, found := keeper.GetValidator(ctx, validatorAddr)
 		require.True(t, found)
-		msgUndelegate := NewMsgUndelegate(delegatorAddrs[i], validatorAddr, sdk.NewDec(10)) // remove delegation
+		unbondingTokens := types.TokensFromTendermintPower(10)
+		msgUndelegate := NewMsgUndelegate(delegatorAddrs[i], validatorAddr, sdk.NewDecFromInt(unbondingTokens)) // remove delegation
 		got := handleMsgUndelegate(ctx, msgUndelegate, keeper)
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
 		var finishTime time.Time
@@ -527,9 +542,8 @@ func TestMultipleMsgCreateValidator(t *testing.T) {
 		_, found = keeper.GetValidator(ctx, validatorAddr)
 		require.False(t, found)
 
-		expBalance := sdk.NewInt(initBond)
 		gotBalance := accMapper.GetAccount(ctx, delegatorAddrs[i]).GetCoins().AmountOf(params.BondDenom)
-		require.Equal(t, expBalance, gotBalance, "expected account to have %d, got %d", expBalance, gotBalance)
+		require.Equal(t, initTokens, gotBalance, "expected account to have %d, got %d", initTokens, gotBalance)
 	}
 }
 
@@ -539,13 +553,13 @@ func TestMultipleMsgDelegate(t *testing.T) {
 	_ = setInstantUnbondPeriod(keeper, ctx)
 
 	//first make a validator
-	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
+	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], sdk.NewInt(10))
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected msg to be ok, got %v", got)
 
 	// delegate multiple parties
 	for i, delegatorAddr := range delegatorAddrs {
-		msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, 10)
+		msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, sdk.NewInt(10))
 		got := handleMsgDelegate(ctx, msgDelegate, keeper)
 		require.True(t, got.IsOK(), "expected msg %d to be ok, got %v", i, got)
 
@@ -577,12 +591,12 @@ func TestJailValidator(t *testing.T) {
 	_ = setInstantUnbondPeriod(keeper, ctx)
 
 	// create the validator
-	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
+	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], sdk.NewInt(10))
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
 	// bond a delegator
-	msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, 10)
+	msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, sdk.NewInt(10))
 	got = handleMsgDelegate(ctx, msgDelegate, keeper)
 	require.True(t, got.IsOK(), "expected ok, got %v", got)
 
@@ -626,19 +640,22 @@ func TestValidatorQueue(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// create the validator
-	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
+	valTokens := types.TokensFromTendermintPower(10)
+	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], valTokens)
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
 	// bond a delegator
-	msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, 10)
+	delTokens := types.TokensFromTendermintPower(10)
+	msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, delTokens)
 	got = handleMsgDelegate(ctx, msgDelegate, keeper)
 	require.True(t, got.IsOK(), "expected ok, got %v", got)
 
 	EndBlocker(ctx, keeper)
 
 	// unbond the all self-delegation to put validator in unbonding state
-	msgUndelegateValidator := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(10))
+	msgUndelegateValidator := NewMsgUndelegate(sdk.AccAddress(validatorAddr),
+		validatorAddr, sdk.NewDecFromInt(delTokens))
 	got = handleMsgUndelegate(ctx, msgUndelegateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error: %v", got)
 	var finishTime time.Time
@@ -676,14 +693,17 @@ func TestUnbondingPeriod(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// create the validator
-	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
+	valTokens := types.TokensFromTendermintPower(10)
+	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], valTokens)
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
 	EndBlocker(ctx, keeper)
 
 	// begin unbonding
-	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr), validatorAddr, sdk.NewDec(10))
+	unbondingTokens := types.TokensFromTendermintPower(10)
+	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr),
+		validatorAddr, sdk.NewDecFromInt(unbondingTokens))
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error")
 	origHeader := ctx.BlockHeader()
@@ -714,12 +734,12 @@ func TestUnbondingFromUnbondingValidator(t *testing.T) {
 	validatorAddr, delegatorAddr := sdk.ValAddress(keep.Addrs[0]), keep.Addrs[1]
 
 	// create the validator
-	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
+	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], sdk.NewInt(10))
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
 	// bond a delegator
-	msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, 10)
+	msgDelegate := NewTestMsgDelegate(delegatorAddr, validatorAddr, sdk.NewInt(10))
 	got = handleMsgDelegate(ctx, msgDelegate, keeper)
 	require.True(t, got.IsOK(), "expected ok, got %v", got)
 
@@ -761,7 +781,7 @@ func TestRedelegationPeriod(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// create the validators
-	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
+	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], sdk.NewInt(10))
 
 	// initial balance
 	amt1 := AccMapper.GetAccount(ctx, sdk.AccAddress(validatorAddr)).GetCoins().AmountOf(denom)
@@ -773,7 +793,7 @@ func TestRedelegationPeriod(t *testing.T) {
 	amt2 := AccMapper.GetAccount(ctx, sdk.AccAddress(validatorAddr)).GetCoins().AmountOf(denom)
 	require.Equal(t, amt1.Sub(sdk.NewInt(10)).Int64(), amt2.Int64(), "expected coins to be subtracted")
 
-	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], 10)
+	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], sdk.NewInt(10))
 	got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
@@ -820,15 +840,15 @@ func TestTransitiveRedelegation(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// create the validators
-	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], 10)
+	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr, keep.PKs[0], sdk.NewInt(10))
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
-	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], 10)
+	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], sdk.NewInt(10))
 	got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
-	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], 10)
+	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], sdk.NewInt(10))
 	got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
@@ -861,11 +881,12 @@ func TestMultipleRedelegationAtSameTime(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// create the validators
-	msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], 10)
+	valTokens := types.TokensFromTendermintPower(10)
+	msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], valTokens)
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
-	msgCreateValidator = NewTestMsgCreateValidator(valAddr2, keep.PKs[1], 10)
+	msgCreateValidator = NewTestMsgCreateValidator(valAddr2, keep.PKs[1], valTokens)
 	got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
@@ -875,7 +896,7 @@ func TestMultipleRedelegationAtSameTime(t *testing.T) {
 	// begin a redelegate
 	selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
 	msgBeginRedelegate := NewMsgBeginRedelegate(selfDelAddr,
-		valAddr, valAddr2, sdk.NewDec(5))
+		valAddr, valAddr2, sdk.NewDecFromInt(valTokens.DivRaw(2)))
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
@@ -912,11 +933,12 @@ func TestMultipleRedelegationAtUniqueTimes(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// create the validators
-	msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], 10)
+	valTokens := types.TokensFromTendermintPower(10)
+	msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], valTokens)
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
-	msgCreateValidator = NewTestMsgCreateValidator(valAddr2, keep.PKs[1], 10)
+	msgCreateValidator = NewTestMsgCreateValidator(valAddr2, keep.PKs[1], valTokens)
 	got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
@@ -926,7 +948,7 @@ func TestMultipleRedelegationAtUniqueTimes(t *testing.T) {
 	// begin a redelegate
 	selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
 	msgBeginRedelegate := NewMsgBeginRedelegate(selfDelAddr,
-		valAddr, valAddr2, sdk.NewDec(5))
+		valAddr, valAddr2, sdk.NewDecFromInt(valTokens.DivRaw(2)))
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
@@ -964,7 +986,8 @@ func TestMultipleUnbondingDelegationAtSameTime(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// create the validator
-	msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], 10)
+	valTokens := types.TokensFromTendermintPower(10)
+	msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], valTokens)
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
@@ -973,7 +996,7 @@ func TestMultipleUnbondingDelegationAtSameTime(t *testing.T) {
 
 	// begin an unbonding delegation
 	selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
-	msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, sdk.NewDec(5))
+	msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, sdk.NewDecFromInt(valTokens.DivRaw(2)))
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
@@ -1009,7 +1032,8 @@ func TestMultipleUnbondingDelegationAtUniqueTimes(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// create the validator
-	msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], 10)
+	valTokens := types.TokensFromTendermintPower(10)
+	msgCreateValidator := NewTestMsgCreateValidator(valAddr, keep.PKs[0], valTokens)
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
@@ -1018,7 +1042,7 @@ func TestMultipleUnbondingDelegationAtUniqueTimes(t *testing.T) {
 
 	// begin an unbonding delegation
 	selfDelAddr := sdk.AccAddress(valAddr) // (the validator is it's own delegator)
-	msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, sdk.NewDec(5))
+	msgUndelegate := NewMsgUndelegate(selfDelAddr, valAddr, sdk.NewDecFromInt(valTokens.DivRaw(2)))
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error, %v", got)
 
@@ -1064,21 +1088,24 @@ func TestUnbondingWhenExcessValidators(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// add three validators
-	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr1, keep.PKs[0], 50)
+	valTokens1 := types.TokensFromTendermintPower(50)
+	msgCreateValidator := NewTestMsgCreateValidator(validatorAddr1, keep.PKs[0], valTokens1)
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 	// apply TM updates
 	keeper.ApplyAndReturnValidatorSetUpdates(ctx)
 	require.Equal(t, 1, len(keeper.GetLastValidators(ctx)))
 
-	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], 30)
+	valTokens2 := types.TokensFromTendermintPower(30)
+	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr2, keep.PKs[1], valTokens2)
 	got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 	// apply TM updates
 	keeper.ApplyAndReturnValidatorSetUpdates(ctx)
 	require.Equal(t, 2, len(keeper.GetLastValidators(ctx)))
 
-	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], 10)
+	valTokens3 := types.TokensFromTendermintPower(10)
+	msgCreateValidator = NewTestMsgCreateValidator(validatorAddr3, keep.PKs[2], valTokens3)
 	got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 	// apply TM updates
@@ -1086,7 +1113,7 @@ func TestUnbondingWhenExcessValidators(t *testing.T) {
 	require.Equal(t, 2, len(keeper.GetLastValidators(ctx)))
 
 	// unbond the valdator-2
-	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr2), validatorAddr2, sdk.NewDec(30))
+	msgUndelegate := NewMsgUndelegate(sdk.AccAddress(validatorAddr2), validatorAddr2, sdk.NewDecFromInt(valTokens2))
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgUndelegate")
 
@@ -1108,16 +1135,17 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	valA, valB, del := sdk.ValAddress(keep.Addrs[0]), sdk.ValAddress(keep.Addrs[1]), keep.Addrs[2]
 	consAddr0 := sdk.ConsAddress(keep.PKs[0].Address())
 
-	msgCreateValidator := NewTestMsgCreateValidator(valA, keep.PKs[0], 10)
+	valTokens := types.TokensFromTendermintPower(10)
+	msgCreateValidator := NewTestMsgCreateValidator(valA, keep.PKs[0], valTokens)
 	got := handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
-	msgCreateValidator = NewTestMsgCreateValidator(valB, keep.PKs[1], 10)
+	msgCreateValidator = NewTestMsgCreateValidator(valB, keep.PKs[1], valTokens)
 	got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgCreateValidator")
 
 	// delegate 10 stake
-	msgDelegate := NewTestMsgDelegate(del, valA, 10)
+	msgDelegate := NewTestMsgDelegate(del, valA, valTokens)
 	got = handleMsgDelegate(ctx, msgDelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgDelegate")
 
@@ -1129,19 +1157,21 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	ctx = ctx.WithBlockHeight(1)
 
 	// begin unbonding 4 stake
-	msgUndelegate := NewMsgUndelegate(del, valA, sdk.NewDec(4))
+	ubdTokens := types.TokensFromTendermintPower(4)
+	msgUndelegate := NewMsgUndelegate(del, valA, sdk.NewDecFromInt(ubdTokens))
 	got = handleMsgUndelegate(ctx, msgUndelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgUndelegate")
 
 	// begin redelegate 6 stake
-	msgBeginRedelegate := NewMsgBeginRedelegate(del, valA, valB, sdk.NewDec(6))
+	rdTokens := types.TokensFromTendermintPower(6)
+	msgBeginRedelegate := NewMsgBeginRedelegate(del, valA, valB, sdk.NewDecFromInt(rdTokens))
 	got = handleMsgBeginRedelegate(ctx, msgBeginRedelegate, keeper)
 	require.True(t, got.IsOK(), "expected no error on runMsgBeginRedelegate")
 
 	// destination delegation should have 6 shares
 	delegation, found := keeper.GetDelegation(ctx, del, valB)
 	require.True(t, found)
-	require.Equal(t, sdk.NewDec(6), delegation.Shares)
+	require.Equal(t, sdk.NewDecFromInt(rdTokens), delegation.Shares)
 
 	// must apply validator updates
 	updates = keeper.ApplyAndReturnValidatorSetUpdates(ctx)
@@ -1154,23 +1184,23 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	ubd, found := keeper.GetUnbondingDelegation(ctx, del, valA)
 	require.True(t, found)
 	require.Len(t, ubd.Entries, 1)
-	require.Equal(t, int64(2), ubd.Entries[0].Balance.Amount.Int64())
+	require.Equal(t, ubdTokens.DivRaw(2), ubd.Entries[0].Balance.Amount)
 
 	// redelegation should have been slashed by half
 	redelegation, found := keeper.GetRedelegation(ctx, del, valA, valB)
 	require.True(t, found)
 	require.Len(t, redelegation.Entries, 1)
-	require.Equal(t, int64(3), redelegation.Entries[0].Balance.Amount.Int64())
+	require.Equal(t, rdTokens.DivRaw(2), redelegation.Entries[0].Balance.Amount)
 
 	// destination delegation should have been slashed by half
 	delegation, found = keeper.GetDelegation(ctx, del, valB)
 	require.True(t, found)
-	require.Equal(t, sdk.NewDec(3), delegation.Shares)
+	require.Equal(t, sdk.NewDecFromInt(rdTokens.DivRaw(2)), delegation.Shares)
 
 	// validator power should have been reduced by half
 	validator, found := keeper.GetValidator(ctx, valA)
 	require.True(t, found)
-	require.Equal(t, int64(5), validator.GetPower().Int64())
+	require.Equal(t, valTokens.DivRaw(2), validator.GetBondedTokens())
 
 	// slash the validator for an infraction committed after the unbonding and redelegation begin
 	ctx = ctx.WithBlockHeight(3)
@@ -1180,18 +1210,18 @@ func TestBondUnbondRedelegateSlashTwice(t *testing.T) {
 	ubd, found = keeper.GetUnbondingDelegation(ctx, del, valA)
 	require.True(t, found)
 	require.Len(t, ubd.Entries, 1)
-	require.Equal(t, int64(2), ubd.Entries[0].Balance.Amount.Int64())
+	require.Equal(t, ubdTokens.DivRaw(2), ubd.Entries[0].Balance.Amount)
 
 	// redelegation should be unchanged
 	redelegation, found = keeper.GetRedelegation(ctx, del, valA, valB)
 	require.True(t, found)
 	require.Len(t, redelegation.Entries, 1)
-	require.Equal(t, int64(3), redelegation.Entries[0].Balance.Amount.Int64())
+	require.Equal(t, rdTokens.DivRaw(2), redelegation.Entries[0].Balance.Amount)
 
 	// destination delegation should be unchanged
 	delegation, found = keeper.GetDelegation(ctx, del, valB)
 	require.True(t, found)
-	require.Equal(t, sdk.NewDec(3), delegation.Shares)
+	require.Equal(t, sdk.NewDecFromInt(rdTokens.DivRaw(2)), delegation.Shares)
 
 	// end blocker
 	EndBlocker(ctx, keeper)
diff --git a/x/staking/keeper/delegation_test.go b/x/staking/keeper/delegation_test.go
index 590e728267e6..10e34a81e816 100644
--- a/x/staking/keeper/delegation_test.go
+++ b/x/staking/keeper/delegation_test.go
@@ -1,7 +1,6 @@
 package keeper
 
 import (
-	"fmt"
 	"testing"
 	"time"
 
@@ -32,11 +31,7 @@ func TestDelegation(t *testing.T) {
 
 	// first add a validators[0] to delegate too
 
-	bond1to1 := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[0],
-		Shares:        sdk.NewDec(9),
-	}
+	bond1to1 := types.NewDelegation(addrDels[0], addrVals[0], sdk.NewDec(9))
 
 	// check the empty keeper first
 	_, found := keeper.GetDelegation(ctx, addrDels[0], addrVals[0])
@@ -56,11 +51,11 @@ func TestDelegation(t *testing.T) {
 	require.True(t, bond1to1.Equal(resBond))
 
 	// add some more records
-	bond1to2 := types.Delegation{addrDels[0], addrVals[1], sdk.NewDec(9)}
-	bond1to3 := types.Delegation{addrDels[0], addrVals[2], sdk.NewDec(9)}
-	bond2to1 := types.Delegation{addrDels[1], addrVals[0], sdk.NewDec(9)}
-	bond2to2 := types.Delegation{addrDels[1], addrVals[1], sdk.NewDec(9)}
-	bond2to3 := types.Delegation{addrDels[1], addrVals[2], sdk.NewDec(9)}
+	bond1to2 := types.NewDelegation(addrDels[0], addrVals[1], sdk.NewDec(9))
+	bond1to3 := types.NewDelegation(addrDels[0], addrVals[2], sdk.NewDec(9))
+	bond2to1 := types.NewDelegation(addrDels[1], addrVals[0], sdk.NewDec(9))
+	bond2to2 := types.NewDelegation(addrDels[1], addrVals[1], sdk.NewDec(9))
+	bond2to3 := types.NewDelegation(addrDels[1], addrVals[2], sdk.NewDec(9))
 	keeper.SetDelegation(ctx, bond1to2)
 	keeper.SetDelegation(ctx, bond1to3)
 	keeper.SetDelegation(ctx, bond2to1)
@@ -176,29 +171,27 @@ func TestUnbondingDelegation(t *testing.T) {
 func TestUnbondDelegation(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 0)
 	pool := keeper.GetPool(ctx)
-	pool.NotBondedTokens = sdk.NewInt(10)
+	startTokens := types.TokensFromTendermintPower(10)
+	pool.NotBondedTokens = startTokens
 
 	//create a validator and a delegator to that validator
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
-	validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	validator, pool, issuedShares := validator.AddTokensFromDel(pool, startTokens)
+	require.Equal(t, startTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 
 	pool = keeper.GetPool(ctx)
-	require.Equal(t, int64(10), pool.BondedTokens.Int64())
-	require.Equal(t, int64(10), validator.BondedTokens().Int64())
+	require.Equal(t, startTokens, pool.BondedTokens)
+	require.Equal(t, startTokens, validator.BondedTokens())
 
-	delegation := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, delegation)
 
-	amount, err := keeper.unbond(ctx, addrDels[0], addrVals[0], sdk.NewDec(6))
+	bondTokens := types.TokensFromTendermintPower(6)
+	amount, err := keeper.unbond(ctx, addrDels[0], addrVals[0], sdk.NewDecFromInt(bondTokens))
 	require.NoError(t, err)
-	require.Equal(t, int64(6), amount.Int64()) // shares to be added to an unbonding delegation
+	require.Equal(t, bondTokens, amount) // shares to be added to an unbonding delegation
 
 	delegation, found := keeper.GetDelegation(ctx, addrDels[0], addrVals[0])
 	require.True(t, found)
@@ -206,33 +199,31 @@ func TestUnbondDelegation(t *testing.T) {
 	require.True(t, found)
 	pool = keeper.GetPool(ctx)
 
-	require.Equal(t, int64(4), delegation.Shares.RoundInt64())
-	require.Equal(t, int64(4), validator.BondedTokens().Int64())
-	require.Equal(t, int64(6), pool.NotBondedTokens.Int64(), "%v", pool)
-	require.Equal(t, int64(4), pool.BondedTokens.Int64())
+	remainingTokens := startTokens.Sub(bondTokens)
+	require.Equal(t, remainingTokens, delegation.Shares.RoundInt())
+	require.Equal(t, remainingTokens, validator.BondedTokens())
+	require.Equal(t, bondTokens, pool.NotBondedTokens, "%v", pool)
+	require.Equal(t, remainingTokens, pool.BondedTokens)
 }
 
 func TestUnbondingDelegationsMaxEntries(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 0)
 	pool := keeper.GetPool(ctx)
-	pool.NotBondedTokens = sdk.NewInt(10)
+	startTokens := types.TokensFromTendermintPower(10)
+	pool.NotBondedTokens = startTokens
 
 	// create a validator and a delegator to that validator
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
-	validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	validator, pool, issuedShares := validator.AddTokensFromDel(pool, startTokens)
+	require.Equal(t, startTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 
 	pool = keeper.GetPool(ctx)
-	require.Equal(t, int64(10), pool.BondedTokens.Int64())
-	require.Equal(t, int64(10), validator.BondedTokens().Int64())
+	require.Equal(t, startTokens, pool.BondedTokens)
+	require.Equal(t, startTokens, validator.BondedTokens())
 
-	delegation := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, delegation)
 
 	maxEntries := keeper.MaxEntries(ctx)
@@ -262,41 +253,35 @@ func TestUnbondingDelegationsMaxEntries(t *testing.T) {
 // test removing all self delegation from a validator which should
 // shift it from the bonded to unbonded state
 func TestUndelegateSelfDelegation(t *testing.T) {
-
 	ctx, _, keeper := CreateTestInput(t, false, 0)
 	pool := keeper.GetPool(ctx)
-	pool.NotBondedTokens = sdk.NewInt(20)
+	startTokens := types.TokensFromTendermintPower(20)
+	pool.NotBondedTokens = startTokens
 
 	//create a validator with a self-delegation
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
-	validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	valTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
-	selfDelegation := types.Delegation{
-		DelegatorAddr: sdk.AccAddress(addrVals[0].Bytes()),
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	selfDelegation := types.NewDelegation(sdk.AccAddress(addrVals[0].Bytes()), addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, selfDelegation)
 
 	// create a second delegation to this validator
 	keeper.DeleteValidatorByPowerIndex(ctx, validator)
-	validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	delTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
+	require.Equal(t, delTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
-	delegation := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, delegation)
 
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
+	_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens))
 	require.NoError(t, err)
 
 	// end block
@@ -305,42 +290,37 @@ func TestUndelegateSelfDelegation(t *testing.T) {
 
 	validator, found := keeper.GetValidator(ctx, addrVals[0])
 	require.True(t, found)
-	require.Equal(t, int64(10), validator.Tokens.Int64())
+	require.Equal(t, delTokens, validator.Tokens)
 	require.Equal(t, sdk.Unbonding, validator.Status)
 }
 
 func TestUndelegateFromUnbondingValidator(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 0)
 	pool := keeper.GetPool(ctx)
-	pool.NotBondedTokens = sdk.NewInt(20)
+	startTokens := types.TokensFromTendermintPower(20)
+	pool.NotBondedTokens = startTokens
 
 	//create a validator with a self-delegation
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
 
-	validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	valTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
-	selfDelegation := types.Delegation{
-		DelegatorAddr: sdk.AccAddress(addrVals[0].Bytes()),
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	selfDelegation := types.NewDelegation(sdk.AccAddress(addrVals[0].Bytes()), addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, selfDelegation)
 
 	// create a second delegation to this validator
 	keeper.DeleteValidatorByPowerIndex(ctx, validator)
-	validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	delTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
+	require.Equal(t, delTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
-	delegation := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, delegation)
 
 	header := ctx.BlockHeader()
@@ -352,7 +332,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.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
+	_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens))
 	require.NoError(t, err)
 
 	// end block
@@ -389,43 +369,38 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) {
 func TestUndelegateFromUnbondedValidator(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 0)
 	pool := keeper.GetPool(ctx)
-	pool.NotBondedTokens = sdk.NewInt(20)
+	startTokens := types.TokensFromTendermintPower(20)
+	pool.NotBondedTokens = startTokens
 
 	//create a validator with a self-delegation
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
 
-	validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	valTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	selfDelegation := types.Delegation{
-		DelegatorAddr: val0AccAddr,
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, selfDelegation)
 
 	// create a second delegation to this validator
 	keeper.DeleteValidatorByPowerIndex(ctx, validator)
-	validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	delTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
+	require.Equal(t, delTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
-	delegation := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, delegation)
 
 	ctx = ctx.WithBlockHeight(10)
 	ctx = ctx.WithBlockTime(time.Unix(333, 0))
 
 	// unbond the all self-delegation to put validator in unbonding state
-	_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
+	_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens))
 	require.NoError(t, err)
 
 	// end block
@@ -448,7 +423,8 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
 	require.Equal(t, validator.Status, sdk.Unbonded)
 
 	// unbond some of the other delegation's shares
-	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(6))
+	unbondTokens := types.TokensFromTendermintPower(6)
+	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDecFromInt(unbondTokens))
 	require.NoError(t, err)
 
 	// no ubd should have been found, coins should have been returned direcly to account
@@ -456,55 +432,50 @@ func TestUndelegateFromUnbondedValidator(t *testing.T) {
 	require.False(t, found, "%v", ubd)
 
 	// unbond rest of the other delegation's shares
-	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(4))
+	remainingTokens := delTokens.Sub(unbondTokens)
+	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDecFromInt(remainingTokens))
 	require.NoError(t, err)
 
 	//  now validator should now be deleted from state
 	validator, found = keeper.GetValidator(ctx, addrVals[0])
-	fmt.Println(validator)
-	require.False(t, found)
+	require.False(t, found, "%v", validator)
 }
 
 func TestUnbondingAllDelegationFromValidator(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 0)
 	pool := keeper.GetPool(ctx)
-	pool.NotBondedTokens = sdk.NewInt(20)
+	startTokens := types.TokensFromTendermintPower(20)
+	pool.NotBondedTokens = startTokens
 
 	//create a validator with a self-delegation
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
 
-	validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	valTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	selfDelegation := types.Delegation{
-		DelegatorAddr: val0AccAddr,
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, selfDelegation)
 
 	// create a second delegation to this validator
 	keeper.DeleteValidatorByPowerIndex(ctx, validator)
-	validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	delTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
+	require.Equal(t, delTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
-	delegation := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, delegation)
 
 	ctx = ctx.WithBlockHeight(10)
 	ctx = ctx.WithBlockTime(time.Unix(333, 0))
 
 	// unbond the all self-delegation to put validator in unbonding state
-	_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
+	_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens))
 	require.NoError(t, err)
 
 	// end block
@@ -512,7 +483,7 @@ func TestUnbondingAllDelegationFromValidator(t *testing.T) {
 	require.Equal(t, 1, len(updates))
 
 	// unbond all the remaining delegation
-	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDec(10))
+	_, err = keeper.Undelegate(ctx, addrDels[0], addrVals[0], sdk.NewDecFromInt(delTokens))
 	require.NoError(t, err)
 
 	// validator should still be in state and still be in unbonding state
@@ -618,21 +589,19 @@ func TestRedelegation(t *testing.T) {
 func TestRedelegateToSameValidator(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 0)
 	pool := keeper.GetPool(ctx)
-	pool.NotBondedTokens = sdk.NewInt(30)
+	startTokens := types.TokensFromTendermintPower(30)
+	pool.NotBondedTokens = startTokens
 
 	// create a validator with a self-delegation
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
-	validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	valTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	selfDelegation := types.Delegation{
-		DelegatorAddr: val0AccAddr,
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, selfDelegation)
 
 	_, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[0], sdk.NewDec(5))
@@ -643,28 +612,26 @@ func TestRedelegateToSameValidator(t *testing.T) {
 func TestRedelegationMaxEntries(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 0)
 	pool := keeper.GetPool(ctx)
-	pool.NotBondedTokens = sdk.NewInt(20)
+	startTokens := types.TokensFromTendermintPower(20)
+	pool.NotBondedTokens = startTokens
 
 	// create a validator with a self-delegation
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
-	validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	valTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	selfDelegation := types.Delegation{
-		DelegatorAddr: val0AccAddr,
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, selfDelegation)
 
 	// create a second validator
 	validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
-	validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
-	pool.BondedTokens = pool.BondedTokens.Add(sdk.NewInt(10))
+	validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
+	pool.BondedTokens = pool.BondedTokens.Add(valTokens)
 	keeper.SetPool(ctx, pool)
 	validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
 	require.Equal(t, sdk.Bonded, validator2.Status)
@@ -696,46 +663,42 @@ func TestRedelegationMaxEntries(t *testing.T) {
 func TestRedelegateSelfDelegation(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 0)
 	pool := keeper.GetPool(ctx)
-	pool.NotBondedTokens = sdk.NewInt(30)
+	startTokens := types.TokensFromTendermintPower(30)
+	pool.NotBondedTokens = startTokens
 
 	//create a validator with a self-delegation
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
-	validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	valTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	selfDelegation := types.Delegation{
-		DelegatorAddr: val0AccAddr,
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, selfDelegation)
 
 	// create a second validator
 	validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
-	validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
-	pool.BondedTokens = pool.BondedTokens.Add(sdk.NewInt(10))
+	validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
+	pool.BondedTokens = pool.BondedTokens.Add(valTokens)
 	keeper.SetPool(ctx, pool)
 	validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
 	require.Equal(t, sdk.Bonded, validator2.Status)
 
-	// create a second delegation to this validator
-	validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	// create a second delegation to validator 1
+	delTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
+	require.Equal(t, delTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
-	delegation := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+
+	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
 	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.NewDecFromInt(delTokens))
 	require.NoError(t, err)
 
 	// end block
@@ -744,49 +707,44 @@ func TestRedelegateSelfDelegation(t *testing.T) {
 
 	validator, found := keeper.GetValidator(ctx, addrVals[0])
 	require.True(t, found)
-	require.Equal(t, int64(10), validator.Tokens.Int64())
+	require.Equal(t, valTokens, validator.Tokens)
 	require.Equal(t, sdk.Unbonding, validator.Status)
 }
 
 func TestRedelegateFromUnbondingValidator(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 0)
 	pool := keeper.GetPool(ctx)
-	pool.NotBondedTokens = sdk.NewInt(30)
+	startTokens := types.TokensFromTendermintPower(30)
+	pool.NotBondedTokens = startTokens
 
 	//create a validator with a self-delegation
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
 
-	validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	valTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	selfDelegation := types.Delegation{
-		DelegatorAddr: val0AccAddr,
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, selfDelegation)
 
 	// create a second delegation to this validator
 	keeper.DeleteValidatorByPowerIndex(ctx, validator)
-	validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	delTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
+	require.Equal(t, delTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
-	delegation := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, delegation)
 
 	// create a second validator
 	validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
-	validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
 
@@ -798,7 +756,7 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 	ctx = ctx.WithBlockHeader(header)
 
 	// unbond the all self-delegation to put validator in unbonding state
-	_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
+	_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(delTokens))
 	require.NoError(t, err)
 
 	// end block
@@ -820,14 +778,15 @@ 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))
+	redelegateTokens := types.TokensFromTendermintPower(6)
+	_, err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], sdk.NewDecFromInt(redelegateTokens))
 	require.NoError(t, err)
 
 	// retrieve the unbonding delegation
 	ubd, found := keeper.GetRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1])
 	require.True(t, found)
 	require.Len(t, ubd.Entries, 1)
-	require.True(t, ubd.Entries[0].Balance.IsEqual(sdk.NewInt64Coin(params.BondDenom, 6)))
+	require.True(t, ubd.Entries[0].Balance.IsEqual(sdk.NewCoin(params.BondDenom, redelegateTokens)))
 	assert.Equal(t, blockHeight, ubd.Entries[0].CreationHeight)
 	assert.True(t, blockTime.Add(params.UnbondingTime).Equal(ubd.Entries[0].CompletionTime))
 }
@@ -835,42 +794,37 @@ func TestRedelegateFromUnbondingValidator(t *testing.T) {
 func TestRedelegateFromUnbondedValidator(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 0)
 	pool := keeper.GetPool(ctx)
-	pool.NotBondedTokens = sdk.NewInt(30)
+	startTokens := types.TokensFromTendermintPower(30)
+	pool.NotBondedTokens = startTokens
 
 	//create a validator with a self-delegation
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
 
-	validator, pool, issuedShares := validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	valTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares := validator.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
 	val0AccAddr := sdk.AccAddress(addrVals[0].Bytes())
-	selfDelegation := types.Delegation{
-		DelegatorAddr: val0AccAddr,
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	selfDelegation := types.NewDelegation(val0AccAddr, addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, selfDelegation)
 
 	// create a second delegation to this validator
 	keeper.DeleteValidatorByPowerIndex(ctx, validator)
-	validator, pool, issuedShares = validator.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	delTokens := types.TokensFromTendermintPower(10)
+	validator, pool, issuedShares = validator.AddTokensFromDel(pool, delTokens)
+	require.Equal(t, delTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
 	pool = keeper.GetPool(ctx)
-	delegation := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[0],
-		Shares:        issuedShares,
-	}
+	delegation := types.NewDelegation(addrDels[0], addrVals[0], issuedShares)
 	keeper.SetDelegation(ctx, delegation)
 
 	// create a second validator
 	validator2 := types.NewValidator(addrVals[1], PKs[1], types.Description{})
-	validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, sdk.NewInt(10))
-	require.Equal(t, int64(10), issuedShares.RoundInt64())
+	validator2, pool, issuedShares = validator2.AddTokensFromDel(pool, valTokens)
+	require.Equal(t, valTokens, issuedShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	validator2 = TestingUpdateValidator(keeper, ctx, validator2, true)
 	require.Equal(t, sdk.Bonded, validator2.Status)
@@ -879,7 +833,7 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 	ctx = ctx.WithBlockTime(time.Unix(333, 0))
 
 	// unbond the all self-delegation to put validator in unbonding state
-	_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDec(10))
+	_, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(delTokens))
 	require.NoError(t, err)
 
 	// end block
@@ -896,7 +850,8 @@ func TestRedelegateFromUnbondedValidator(t *testing.T) {
 	keeper.unbondingToUnbonded(ctx, validator)
 
 	// redelegate some of the delegation's shares
-	_, err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], sdk.NewDec(6))
+	redelegationTokens := types.TokensFromTendermintPower(6)
+	_, err = keeper.BeginRedelegation(ctx, addrDels[0], addrVals[0], addrVals[1], sdk.NewDecFromInt(redelegationTokens))
 	require.NoError(t, err)
 
 	// no red should have been found
diff --git a/x/staking/keeper/keeper.go b/x/staking/keeper/keeper.go
index 81b79bf02450..73f71a8bfec3 100644
--- a/x/staking/keeper/keeper.go
+++ b/x/staking/keeper/keeper.go
@@ -114,20 +114,22 @@ func (k Keeper) GetLastValidatorPower(ctx sdk.Context, operator sdk.ValAddress)
 }
 
 // Set the last validator power.
-func (k Keeper) SetLastValidatorPower(ctx sdk.Context, operator sdk.ValAddress, power sdk.Int) {
+func (k Keeper) SetLastValidatorPower(ctx sdk.Context, operator sdk.ValAddress, power int64) {
 	store := ctx.KVStore(k.storeKey)
 	bz := k.cdc.MustMarshalBinaryLengthPrefixed(power)
 	store.Set(GetLastValidatorPowerKey(operator), bz)
 }
 
 // Iterate over last validator powers.
-func (k Keeper) IterateLastValidatorPowers(ctx sdk.Context, handler func(operator sdk.ValAddress, power sdk.Int) (stop bool)) {
+func (k Keeper) IterateLastValidatorPowers(ctx sdk.Context,
+	handler func(operator sdk.ValAddress, power int64) (stop bool)) {
+
 	store := ctx.KVStore(k.storeKey)
 	iter := sdk.KVStorePrefixIterator(store, LastValidatorPowerKey)
 	defer iter.Close()
 	for ; iter.Valid(); iter.Next() {
 		addr := sdk.ValAddress(iter.Key()[len(LastValidatorPowerKey):])
-		var power sdk.Int
+		var power int64
 		k.cdc.MustUnmarshalBinaryLengthPrefixed(iter.Value(), &power)
 		if handler(addr, power) {
 			break
diff --git a/x/staking/keeper/slash.go b/x/staking/keeper/slash.go
index 3ca7ffcad5bc..100f32674146 100644
--- a/x/staking/keeper/slash.go
+++ b/x/staking/keeper/slash.go
@@ -29,7 +29,8 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh
 	}
 
 	// Amount of slashing = slash slashFactor * power at time of infraction
-	slashAmountDec := sdk.NewDec(power).Mul(slashFactor)
+	amount := types.TokensFromTendermintPower(power)
+	slashAmountDec := sdk.NewDecFromInt(amount).Mul(slashFactor)
 	slashAmount := slashAmountDec.TruncateInt()
 
 	// ref https://github.com/cosmos/cosmos-sdk/issues/1348
diff --git a/x/staking/keeper/slash_test.go b/x/staking/keeper/slash_test.go
index 3dc5e1364eb3..fb5beb15d83c 100644
--- a/x/staking/keeper/slash_test.go
+++ b/x/staking/keeper/slash_test.go
@@ -14,20 +14,21 @@ import (
 
 // TODO integrate with test_common.go helper (CreateTestInput)
 // setup helper function - creates two validators
-func setupHelper(t *testing.T, amt int64) (sdk.Context, Keeper, types.Params) {
+func setupHelper(t *testing.T, power int64) (sdk.Context, Keeper, types.Params) {
 
 	// setup
-	ctx, _, keeper := CreateTestInput(t, false, amt)
+	ctx, _, keeper := CreateTestInput(t, false, power)
 	params := keeper.GetParams(ctx)
 	pool := keeper.GetPool(ctx)
-	numVals := 3
-	pool.NotBondedTokens = sdk.NewInt(amt * int64(numVals))
+	numVals := int64(3)
+	amt := types.TokensFromTendermintPower(power)
+	pool.NotBondedTokens = amt.MulRaw(numVals)
 
 	// add numVals validators
-	for i := 0; i < numVals; i++ {
+	for i := int64(0); i < numVals; i++ {
 		validator := types.NewValidator(addrVals[i], PKs[i], types.Description{})
-		validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(amt))
-		pool.BondedTokens = pool.BondedTokens.Add(sdk.NewInt(amt))
+		validator, pool, _ = validator.AddTokensFromDel(pool, amt)
+		pool.BondedTokens = pool.BondedTokens.Add(amt)
 		keeper.SetPool(ctx, pool)
 		validator = TestingUpdateValidator(keeper, ctx, validator, true)
 		keeper.SetValidatorByConsAddr(ctx, validator)
@@ -120,11 +121,7 @@ func TestSlashRedelegation(t *testing.T) {
 	keeper.SetRedelegation(ctx, rd)
 
 	// set the associated delegation
-	del := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[1],
-		Shares:        sdk.NewDec(10),
-	}
+	del := types.NewDelegation(addrDels[0], addrVals[1], sdk.NewDec(10))
 	keeper.SetDelegation(ctx, del)
 
 	// started redelegating prior to the current height, stake didn't contribute to infraction
@@ -204,9 +201,9 @@ func TestSlashAtNegativeHeight(t *testing.T) {
 
 	validator = keeper.mustGetValidator(ctx, validator.OperatorAddr)
 	// power decreased
-	require.True(sdk.IntEq(t, sdk.NewInt(5), validator.GetPower()))
+	require.Equal(t, int64(5), validator.GetTendermintPower())
 	// pool bonded shares decreased
-	require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(5), oldPool.BondedTokens.Sub(newPool.BondedTokens))
 }
 
 // tests Slash at the current height
@@ -231,9 +228,9 @@ func TestSlashValidatorAtCurrentHeight(t *testing.T) {
 
 	validator = keeper.mustGetValidator(ctx, validator.OperatorAddr)
 	// power decreased
-	require.True(sdk.IntEq(t, sdk.NewInt(5), validator.GetPower()))
+	require.Equal(t, int64(5), validator.GetTendermintPower())
 	// pool bonded shares decreased
-	require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(5), oldPool.BondedTokens.Sub(newPool.BondedTokens))
 }
 
 // tests Slash at a previous height with an unbonding delegation
@@ -244,8 +241,9 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 
 	// set an unbonding delegation with expiration timestamp beyond which the
 	// unbonding delegation shouldn't be slashed
+	ubdTokens := types.TokensFromTendermintPower(4)
 	ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
-		time.Unix(0, 0), sdk.NewInt64Coin(params.BondDenom, 4))
+		time.Unix(0, 0), sdk.NewCoin(params.BondDenom, ubdTokens))
 	keeper.SetUnbondingDelegation(ctx, ubd)
 
 	// slash validator for the first time
@@ -264,11 +262,11 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	require.True(t, found)
 	require.Len(t, ubd.Entries, 1)
 	// balance decreased
-	require.Equal(t, sdk.NewInt(2), ubd.Entries[0].Balance.Amount)
+	require.Equal(t, types.TokensFromTendermintPower(2), ubd.Entries[0].Balance.Amount)
 	// read updated pool
 	newPool := keeper.GetPool(ctx)
 	// bonded tokens burned
-	require.Equal(t, int64(3), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(3), oldPool.BondedTokens.Sub(newPool.BondedTokens))
 	// read updated validator
 	validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
@@ -276,7 +274,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// was still bonded at the time of discovery and was slashed by half, 4 stake
 	// bonded at the time of discovery hadn't been bonded at the time of infraction
 	// and wasn't slashed
-	require.True(sdk.IntEq(t, sdk.NewInt(7), validator.GetPower()))
+	require.Equal(t, int64(7), validator.GetTendermintPower())
 
 	// slash validator again
 	ctx = ctx.WithBlockHeight(13)
@@ -289,12 +287,12 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// read updated pool
 	newPool = keeper.GetPool(ctx)
 	// bonded tokens burned again
-	require.Equal(t, int64(6), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(6), oldPool.BondedTokens.Sub(newPool.BondedTokens))
 	// read updated validator
 	validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
 	// power decreased by 3 again
-	require.True(sdk.IntEq(t, sdk.NewInt(4), validator.GetPower()))
+	require.Equal(t, int64(4), validator.GetTendermintPower())
 
 	// slash validator again
 	// all originally bonded stake has been slashed, so this will have no effect
@@ -310,12 +308,12 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// read updated pool
 	newPool = keeper.GetPool(ctx)
 	// bonded tokens burned again
-	require.Equal(t, int64(9), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(9), oldPool.BondedTokens.Sub(newPool.BondedTokens))
 	// read updated validator
 	validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
 	// power decreased by 3 again
-	require.True(sdk.IntEq(t, sdk.NewInt(1), validator.GetPower()))
+	require.Equal(t, int64(1), validator.GetTendermintPower())
 
 	// slash validator again
 	// all originally bonded stake has been slashed, so this will have no effect
@@ -331,7 +329,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
 	// read updated pool
 	newPool = keeper.GetPool(ctx)
 	// just 1 bonded token burned again since that's all the validator now has
-	require.Equal(t, int64(10), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(10), oldPool.BondedTokens.Sub(newPool.BondedTokens))
 	// apply TM updates
 	keeper.ApplyAndReturnValidatorSetUpdates(ctx)
 	// read updated validator
@@ -348,22 +346,19 @@ func TestSlashWithRedelegation(t *testing.T) {
 	fraction := sdk.NewDecWithPrec(5, 1)
 
 	// set a redelegation
+	rdTokens := types.TokensFromTendermintPower(6)
 	rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
-		time.Unix(0, 0), sdk.NewInt64Coin(params.BondDenom, 6), sdk.NewDec(6),
-		sdk.NewDec(6))
+		time.Unix(0, 0), sdk.NewCoin(params.BondDenom, rdTokens), sdk.NewDecFromInt(rdTokens),
+		sdk.NewDecFromInt(rdTokens))
 	keeper.SetRedelegation(ctx, rd)
 
 	// set the associated delegation
-	del := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[1],
-		Shares:        sdk.NewDec(6),
-	}
+	del := types.NewDelegation(addrDels[0], addrVals[1], sdk.NewDecFromInt(rdTokens))
 	keeper.SetDelegation(ctx, del)
 
 	// update bonded tokens
 	pool := keeper.GetPool(ctx)
-	pool.BondedTokens = pool.BondedTokens.Add(sdk.NewInt(6))
+	pool.BondedTokens = pool.BondedTokens.Add(rdTokens)
 	keeper.SetPool(ctx, pool)
 
 	// slash validator
@@ -378,11 +373,11 @@ func TestSlashWithRedelegation(t *testing.T) {
 	require.True(t, found)
 	require.Len(t, rd.Entries, 1)
 	// balance decreased
-	require.Equal(t, sdk.NewInt(3), rd.Entries[0].Balance.Amount)
+	require.Equal(t, types.TokensFromTendermintPower(3), rd.Entries[0].Balance.Amount)
 	// read updated pool
 	newPool := keeper.GetPool(ctx)
 	// bonded tokens burned
-	require.Equal(t, int64(5), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(5), oldPool.BondedTokens.Sub(newPool.BondedTokens))
 	// read updated validator
 	validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
@@ -390,7 +385,7 @@ func TestSlashWithRedelegation(t *testing.T) {
 	// was still bonded at the time of discovery and was slashed by half, 4 stake
 	// bonded at the time of discovery hadn't been bonded at the time of infraction
 	// and wasn't slashed
-	require.True(sdk.IntEq(t, sdk.NewInt(8), validator.GetPower()))
+	require.Equal(t, int64(8), validator.GetTendermintPower())
 
 	// slash the validator again
 	ctx = ctx.WithBlockHeight(12)
@@ -407,12 +402,12 @@ func TestSlashWithRedelegation(t *testing.T) {
 	// read updated pool
 	newPool = keeper.GetPool(ctx)
 	// seven bonded tokens burned
-	require.Equal(t, int64(12), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(12), oldPool.BondedTokens.Sub(newPool.BondedTokens))
 	// read updated validator
 	validator, found = keeper.GetValidatorByConsAddr(ctx, consAddr)
 	require.True(t, found)
 	// power decreased by 4
-	require.True(sdk.IntEq(t, sdk.NewInt(4), validator.GetPower()))
+	require.Equal(t, int64(4), validator.GetTendermintPower())
 
 	// slash the validator again, by 100%
 	ctx = ctx.WithBlockHeight(12)
@@ -429,7 +424,7 @@ func TestSlashWithRedelegation(t *testing.T) {
 	// read updated pool
 	newPool = keeper.GetPool(ctx)
 	// four more bonded tokens burned
-	require.Equal(t, int64(16), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(16), oldPool.BondedTokens.Sub(newPool.BondedTokens))
 	// apply TM updates
 	keeper.ApplyAndReturnValidatorSetUpdates(ctx)
 	// read updated validator
@@ -454,7 +449,7 @@ func TestSlashWithRedelegation(t *testing.T) {
 	// read updated pool
 	newPool = keeper.GetPool(ctx)
 	// no more bonded tokens burned
-	require.Equal(t, int64(16), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(16), oldPool.BondedTokens.Sub(newPool.BondedTokens))
 	// read updated validator
 	// power still zero, still in unbonding period
 	validator, _ = keeper.GetValidatorByConsAddr(ctx, consAddr)
@@ -468,23 +463,21 @@ func TestSlashBoth(t *testing.T) {
 
 	// set a redelegation with expiration timestamp beyond which the
 	// redelegation shouldn't be slashed
+	rdATokens := types.TokensFromTendermintPower(6)
 	rdA := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 11,
-		time.Unix(0, 0), sdk.NewInt64Coin(params.BondDenom, 6), sdk.NewDec(6),
-		sdk.NewDec(6))
+		time.Unix(0, 0), sdk.NewCoin(params.BondDenom, rdATokens),
+		sdk.NewDecFromInt(rdATokens), sdk.NewDecFromInt(rdATokens))
 	keeper.SetRedelegation(ctx, rdA)
 
 	// set the associated delegation
-	delA := types.Delegation{
-		DelegatorAddr: addrDels[0],
-		ValidatorAddr: addrVals[1],
-		Shares:        sdk.NewDec(6),
-	}
+	delA := types.NewDelegation(addrDels[0], addrVals[1], sdk.NewDecFromInt(rdATokens))
 	keeper.SetDelegation(ctx, delA)
 
 	// set an unbonding delegation with expiration timestamp (beyond which the
 	// unbonding delegation shouldn't be slashed)
+	ubdATokens := types.TokensFromTendermintPower(4)
 	ubdA := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
-		time.Unix(0, 0), sdk.NewInt64Coin(params.BondDenom, 4))
+		time.Unix(0, 0), sdk.NewCoin(params.BondDenom, ubdATokens))
 	keeper.SetUnbondingDelegation(ctx, ubdA)
 
 	// slash validator
@@ -500,16 +493,16 @@ func TestSlashBoth(t *testing.T) {
 	require.True(t, found)
 	require.Len(t, rdA.Entries, 1)
 	// balance decreased
-	require.Equal(t, sdk.NewInt(3), rdA.Entries[0].Balance.Amount)
+	require.Equal(t, types.TokensFromTendermintPower(3), rdA.Entries[0].Balance.Amount)
 	// read updated pool
 	newPool := keeper.GetPool(ctx)
 	// not-bonded tokens burned
-	require.Equal(t, int64(2), oldPool.NotBondedTokens.Sub(newPool.NotBondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(2), oldPool.NotBondedTokens.Sub(newPool.NotBondedTokens))
 	// bonded tokens burned
-	require.Equal(t, int64(3), oldPool.BondedTokens.Sub(newPool.BondedTokens).Int64())
+	require.Equal(t, types.TokensFromTendermintPower(3), oldPool.BondedTokens.Sub(newPool.BondedTokens))
 	// read updated validator
 	validator, found = keeper.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(PKs[0]))
 	require.True(t, found)
 	// power not decreased, all stake was bonded since
-	require.True(sdk.IntEq(t, sdk.NewInt(10), validator.GetPower()))
+	require.Equal(t, int64(10), validator.GetTendermintPower())
 }
diff --git a/x/staking/keeper/test_common.go b/x/staking/keeper/test_common.go
index aa95c885ca45..d01f307b7b67 100644
--- a/x/staking/keeper/test_common.go
+++ b/x/staking/keeper/test_common.go
@@ -75,7 +75,10 @@ func MakeTestCodec() *codec.Codec {
 }
 
 // hogpodge of all sorts of input required for testing
-func CreateTestInput(t *testing.T, isCheckTx bool, initCoins int64) (sdk.Context, auth.AccountKeeper, Keeper) {
+// init power is converted to an amount of tokens
+func CreateTestInput(t *testing.T, isCheckTx bool, initPower int64) (sdk.Context, auth.AccountKeeper, Keeper) {
+
+	initCoins := types.TokensFromTendermintPower(initPower)
 
 	keyStaking := sdk.NewKVStoreKey(types.StoreKey)
 	tkeyStaking := sdk.NewTransientStoreKey(types.TStoreKey)
@@ -126,10 +129,10 @@ func CreateTestInput(t *testing.T, isCheckTx bool, initCoins int64) (sdk.Context
 	for _, addr := range Addrs {
 		pool := keeper.GetPool(ctx)
 		_, _, err := ck.AddCoins(ctx, addr, sdk.Coins{
-			{keeper.BondDenom(ctx), sdk.NewInt(initCoins)},
+			{keeper.BondDenom(ctx), initCoins},
 		})
 		require.Nil(t, err)
-		pool.NotBondedTokens = pool.NotBondedTokens.Add(sdk.NewInt(initCoins))
+		pool.NotBondedTokens = pool.NotBondedTokens.Add(initCoins)
 		keeper.SetPool(ctx, pool)
 	}
 
diff --git a/x/staking/keeper/val_state_change.go b/x/staking/keeper/val_state_change.go
index 70ddb656bfb5..f6399abb8bec 100644
--- a/x/staking/keeper/val_state_change.go
+++ b/x/staking/keeper/val_state_change.go
@@ -50,7 +50,7 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
 
 		// if we get to a zero-power validator (which we don't bond),
 		// there are no more possible bonded validators
-		if validator.Tokens.IsZero() {
+		if validator.PotentialTendermintPower() == 0 {
 			break
 		}
 
@@ -72,8 +72,8 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
 		oldPowerBytes, found := last[valAddrBytes]
 
 		// calculate the new power bytes
-		newPower := validator.BondedTokens().Int64()
-		newPowerBytes := k.cdc.MustMarshalBinaryLengthPrefixed(sdk.NewInt(newPower))
+		newPower := validator.TendermintPower()
+		newPowerBytes := k.cdc.MustMarshalBinaryLengthPrefixed(newPower)
 		// update the validator set if power has changed
 		if !found || !bytes.Equal(oldPowerBytes, newPowerBytes) {
 			updates = append(updates, validator.ABCIValidatorUpdate())
@@ -85,7 +85,7 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab
 			}
 
 			// set validator power on lookup index.
-			k.SetLastValidatorPower(ctx, valAddr, sdk.NewInt(newPower))
+			k.SetLastValidatorPower(ctx, valAddr, newPower)
 		}
 
 		// validator still in the validator set, so delete from the copy
diff --git a/x/staking/keeper/validator.go b/x/staking/keeper/validator.go
index d218ca966c75..8e6330cff39b 100644
--- a/x/staking/keeper/validator.go
+++ b/x/staking/keeper/validator.go
@@ -18,6 +18,13 @@ type cachedValidator struct {
 	marshalled string // marshalled amino bytes for the validator object (not operator address)
 }
 
+func newCachedValidator(val types.Validator, marshalled string) cachedValidator {
+	return cachedValidator{
+		val:        val,
+		marshalled: marshalled,
+	}
+}
+
 // get a single validator
 func (k Keeper) GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator types.Validator, found bool) {
 	store := ctx.KVStore(k.storeKey)
@@ -37,8 +44,8 @@ func (k Keeper) GetValidator(ctx sdk.Context, addr sdk.ValAddress) (validator ty
 
 	// amino bytes weren't found in cache, so amino unmarshal and add it to the cache
 	validator = types.MustUnmarshalValidator(k.cdc, value)
-	cachedVal := cachedValidator{validator, strValue}
-	k.validatorCache[strValue] = cachedValidator{validator, strValue}
+	cachedVal := newCachedValidator(validator, strValue)
+	k.validatorCache[strValue] = newCachedValidator(validator, strValue)
 	k.validatorCacheList.PushBack(cachedVal)
 
 	// if the cache is too big, pop off the last element from it
diff --git a/x/staking/keeper/validator_test.go b/x/staking/keeper/validator_test.go
index 9f605312ae9d..13b7a0836d19 100644
--- a/x/staking/keeper/validator_test.go
+++ b/x/staking/keeper/validator_test.go
@@ -22,13 +22,14 @@ func TestSetValidator(t *testing.T) {
 
 	valPubKey := PKs[0]
 	valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
+	valTokens := types.TokensFromTendermintPower(10)
 
 	// test how the validator is set from a purely unbonbed pool
 	validator := types.NewValidator(valAddr, valPubKey, types.Description{})
-	validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(10))
+	validator, pool, _ = validator.AddTokensFromDel(pool, valTokens)
 	require.Equal(t, sdk.Unbonded, validator.Status)
-	assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
-	assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
+	assert.Equal(t, valTokens, validator.Tokens)
+	assert.Equal(t, valTokens, validator.DelegatorShares.RoundInt())
 	keeper.SetPool(ctx, pool)
 	keeper.SetValidator(ctx, validator)
 	keeper.SetValidatorByPowerIndex(ctx, validator)
@@ -42,8 +43,8 @@ func TestSetValidator(t *testing.T) {
 
 	// after the save the validator should be bonded
 	require.Equal(t, sdk.Bonded, validator.Status)
-	assert.True(sdk.IntEq(t, sdk.NewInt(10), validator.Tokens))
-	assert.True(sdk.DecEq(t, sdk.NewDec(10), validator.DelegatorShares))
+	assert.Equal(t, valTokens, validator.Tokens)
+	assert.Equal(t, valTokens, validator.DelegatorShares.RoundInt())
 
 	// Check each store for being saved
 	resVal, found := keeper.GetValidator(ctx, valAddr)
@@ -123,8 +124,8 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// create a random pool
-	pool.NotBondedTokens = sdk.NewInt(10000)
-	pool.BondedTokens = sdk.NewInt(1234)
+	pool.NotBondedTokens = types.TokensFromTendermintPower(10000)
+	pool.BondedTokens = types.TokensFromTendermintPower(1234)
 	keeper.SetPool(ctx, pool)
 
 	validators := make([]types.Validator, numVals)
@@ -132,7 +133,8 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
 		moniker := fmt.Sprintf("val#%d", int64(i))
 		val := types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{Moniker: moniker})
 		val.BondHeight = int64(i)
-		val, pool, _ = val.AddTokensFromDel(pool, sdk.NewInt(int64((i+1)*10)))
+		delTokens := types.TokensFromTendermintPower(int64((i + 1) * 10))
+		val, pool, _ = val.AddTokensFromDel(pool, delTokens)
 
 		keeper.SetPool(ctx, pool)
 		val = TestingUpdateValidator(keeper, ctx, val, true)
@@ -144,7 +146,8 @@ func TestUpdateBondedValidatorsDecreaseCliff(t *testing.T) {
 	// remove enough tokens to kick out the validator below the current cliff
 	// validator and next in line cliff validator
 	keeper.DeleteValidatorByPowerIndex(ctx, nextCliffVal)
-	nextCliffVal, pool, _ = nextCliffVal.RemoveDelShares(pool, sdk.NewDec(21))
+	shares := types.TokensFromTendermintPower(21)
+	nextCliffVal, pool, _ = nextCliffVal.RemoveDelShares(pool, sdk.NewDecFromInt(shares))
 	keeper.SetPool(ctx, pool)
 	nextCliffVal = TestingUpdateValidator(keeper, ctx, nextCliffVal, true)
 
@@ -173,13 +176,14 @@ func TestSlashToZeroPowerRemoved(t *testing.T) {
 
 	// add a validator
 	validator := types.NewValidator(addrVals[0], PKs[0], types.Description{})
-	validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(100))
+	valTokens := types.TokensFromTendermintPower(100)
+	validator, pool, _ = validator.AddTokensFromDel(pool, valTokens)
 	require.Equal(t, sdk.Unbonded, validator.Status)
-	require.Equal(t, int64(100), validator.Tokens.Int64())
+	require.Equal(t, valTokens, validator.Tokens)
 	keeper.SetPool(ctx, pool)
 	keeper.SetValidatorByConsAddr(ctx, validator)
 	validator = TestingUpdateValidator(keeper, ctx, validator, true)
-	require.Equal(t, int64(100), validator.Tokens.Int64(), "\nvalidator %v\npool %v", validator, pool)
+	require.Equal(t, valTokens, validator.Tokens, "\nvalidator %v\npool %v", validator, pool)
 
 	// slash the validator by 100%
 	consAddr0 := sdk.ConsAddress(PKs[0].Address())
@@ -198,17 +202,18 @@ func TestValidatorBasics(t *testing.T) {
 
 	//construct the validators
 	var validators [3]types.Validator
-	amts := []int64{9, 8, 7}
-	for i, amt := range amts {
+	powers := []int64{9, 8, 7}
+	for i, power := range powers {
 		validators[i] = types.NewValidator(addrVals[i], PKs[i], types.Description{})
 		validators[i].Status = sdk.Unbonded
 		validators[i].Tokens = sdk.ZeroInt()
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 		keeper.SetPool(ctx, pool)
 	}
-	assert.True(sdk.IntEq(t, sdk.NewInt(9), validators[0].Tokens))
-	assert.True(sdk.IntEq(t, sdk.NewInt(8), validators[1].Tokens))
-	assert.True(sdk.IntEq(t, sdk.NewInt(7), validators[2].Tokens))
+	assert.Equal(t, types.TokensFromTendermintPower(9), validators[0].Tokens)
+	assert.Equal(t, types.TokensFromTendermintPower(8), validators[1].Tokens)
+	assert.Equal(t, types.TokensFromTendermintPower(7), validators[2].Tokens)
 
 	// check the empty keeper first
 	_, found := keeper.GetValidator(ctx, addrVals[0])
@@ -241,15 +246,15 @@ func TestValidatorBasics(t *testing.T) {
 	require.Equal(t, 1, len(resVals))
 	assert.True(ValEq(t, validators[0], resVals[0]))
 	assert.Equal(t, sdk.Bonded, validators[0].Status)
-	assert.True(sdk.IntEq(t, sdk.NewInt(9), validators[0].BondedTokens()))
+	assert.True(sdk.IntEq(t, types.TokensFromTendermintPower(9), validators[0].BondedTokens()))
 
 	pool = keeper.GetPool(ctx)
 	assert.True(sdk.IntEq(t, pool.BondedTokens, validators[0].BondedTokens()))
 
 	// modify a records, save, and retrieve
 	validators[0].Status = sdk.Bonded
-	validators[0].Tokens = sdk.NewInt(10)
-	validators[0].DelegatorShares = sdk.NewDec(10)
+	validators[0].Tokens = types.TokensFromTendermintPower(10)
+	validators[0].DelegatorShares = sdk.NewDecFromInt(validators[0].Tokens)
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true)
 	resVal, found = keeper.GetValidator(ctx, addrVals[0])
 	require.True(t, found)
@@ -437,18 +442,19 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// initialize some validators into the state
-	amts := []int64{0, 100, 400, 400}
+	powers := []int64{0, 100, 400, 400}
 	var validators [4]types.Validator
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 		moniker := fmt.Sprintf("val#%d", int64(i))
 		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{Moniker: moniker})
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 		keeper.SetPool(ctx, pool)
 		validators[i] = TestingUpdateValidator(keeper, ctx, validators[i], true)
 	}
 
-	for i := range amts {
+	for i := range powers {
 		validators[i], found = keeper.GetValidator(ctx, validators[i].OperatorAddr)
 		require.True(t, found)
 	}
@@ -459,7 +465,8 @@ func TestGetValidatorsEdgeCases(t *testing.T) {
 
 	pool := keeper.GetPool(ctx)
 	keeper.DeleteValidatorByPowerIndex(ctx, validators[0])
-	validators[0], pool, _ = validators[0].AddTokensFromDel(pool, sdk.NewInt(500))
+	delTokens := types.TokensFromTendermintPower(500)
+	validators[0], pool, _ = validators[0].AddTokensFromDel(pool, delTokens)
 	keeper.SetPool(ctx, pool)
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true)
 	resValidators = keeper.GetBondedValidatorsByPower(ctx)
@@ -524,9 +531,12 @@ func TestValidatorBondHeight(t *testing.T) {
 	validators[1] = types.NewValidator(sdk.ValAddress(Addrs[1]), PKs[1], types.Description{})
 	validators[2] = types.NewValidator(sdk.ValAddress(Addrs[2]), PKs[2], types.Description{})
 
-	validators[0], pool, _ = validators[0].AddTokensFromDel(pool, sdk.NewInt(200))
-	validators[1], pool, _ = validators[1].AddTokensFromDel(pool, sdk.NewInt(100))
-	validators[2], pool, _ = validators[2].AddTokensFromDel(pool, sdk.NewInt(100))
+	tokens0 := types.TokensFromTendermintPower(200)
+	tokens1 := types.TokensFromTendermintPower(100)
+	tokens2 := types.TokensFromTendermintPower(100)
+	validators[0], pool, _ = validators[0].AddTokensFromDel(pool, tokens0)
+	validators[1], pool, _ = validators[1].AddTokensFromDel(pool, tokens1)
+	validators[2], pool, _ = validators[2].AddTokensFromDel(pool, tokens2)
 	keeper.SetPool(ctx, pool)
 
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true)
@@ -546,8 +556,9 @@ func TestValidatorBondHeight(t *testing.T) {
 	assert.True(ValEq(t, validators[1], resValidators[1]))
 	keeper.DeleteValidatorByPowerIndex(ctx, validators[1])
 	keeper.DeleteValidatorByPowerIndex(ctx, validators[2])
-	validators[1], pool, _ = validators[1].AddTokensFromDel(pool, sdk.NewInt(50))
-	validators[2], pool, _ = validators[2].AddTokensFromDel(pool, sdk.NewInt(50))
+	delTokens := types.TokensFromTendermintPower(50)
+	validators[1], pool, _ = validators[1].AddTokensFromDel(pool, delTokens)
+	validators[2], pool, _ = validators[2].AddTokensFromDel(pool, delTokens)
 	keeper.SetPool(ctx, pool)
 	validators[2] = TestingUpdateValidator(keeper, ctx, validators[2], true)
 	resValidators = keeper.GetBondedValidatorsByPower(ctx)
@@ -565,16 +576,17 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
 	keeper.SetParams(ctx, params)
 
 	// initialize some validators into the state
-	amts := []int64{0, 100, 400, 400, 200}
+	powers := []int64{0, 100, 400, 400, 200}
 	var validators [5]types.Validator
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 		keeper.SetPool(ctx, pool)
 		TestingUpdateValidator(keeper, ctx, validators[i], true)
 	}
-	for i := range amts {
+	for i := range powers {
 		var found bool
 		validators[i], found = keeper.GetValidator(ctx, validators[i].OperatorAddr)
 		require.True(t, found)
@@ -591,7 +603,8 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
 
 	// test a swap in voting power
 	pool := keeper.GetPool(ctx)
-	validators[0], pool, _ = validators[0].AddTokensFromDel(pool, sdk.NewInt(600))
+	tokens := types.TokensFromTendermintPower(600)
+	validators[0], pool, _ = validators[0].AddTokensFromDel(pool, tokens)
 	keeper.SetPool(ctx, pool)
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], true)
 	resValidators = keeper.GetBondedValidatorsByPower(ctx)
@@ -603,16 +616,17 @@ func TestFullValidatorSetPowerChange(t *testing.T) {
 func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 1000)
 
-	amts := []int64{10, 20}
+	powers := []int64{10, 20}
 	var validators [2]types.Validator
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 
 		valPubKey := PKs[i+1]
 		valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
 
 		validators[i] = types.NewValidator(valAddr, valPubKey, types.Description{})
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 		keeper.SetPool(ctx, pool)
 	}
 
@@ -635,12 +649,14 @@ func TestApplyAndReturnValidatorSetUpdatesAllNone(t *testing.T) {
 func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 1000)
 
-	amts := []int64{10, 20}
+	powers := []int64{10, 20}
 	var validators [2]types.Validator
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 		keeper.SetPool(ctx, pool)
 	}
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
@@ -657,12 +673,14 @@ func TestApplyAndReturnValidatorSetUpdatesIdentical(t *testing.T) {
 func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 1000)
 
-	amts := []int64{10, 20}
+	powers := []int64{10, 20}
 	var validators [2]types.Validator
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 		keeper.SetPool(ctx, pool)
 	}
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
@@ -672,7 +690,7 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
 	// test single value change
 	//  tendermintUpdate set: {} -> {c1'}
 	validators[0].Status = sdk.Bonded
-	validators[0].Tokens = sdk.NewInt(600)
+	validators[0].Tokens = types.TokensFromTendermintPower(600)
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
 
 	updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
@@ -684,12 +702,14 @@ func TestApplyAndReturnValidatorSetUpdatesSingleValueChange(t *testing.T) {
 func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 1000)
 
-	amts := []int64{10, 20}
+	powers := []int64{10, 20}
 	var validators [2]types.Validator
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 		keeper.SetPool(ctx, pool)
 	}
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
@@ -699,8 +719,10 @@ func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
 	// test multiple value change
 	//  tendermintUpdate set: {c1, c3} -> {c1', c3'}
 	pool := keeper.GetPool(ctx)
-	validators[0], pool, _ = validators[0].AddTokensFromDel(pool, sdk.NewInt(190))
-	validators[1], pool, _ = validators[1].AddTokensFromDel(pool, sdk.NewInt(80))
+	delTokens1 := types.TokensFromTendermintPower(190)
+	delTokens2 := types.TokensFromTendermintPower(80)
+	validators[0], pool, _ = validators[0].AddTokensFromDel(pool, delTokens1)
+	validators[1], pool, _ = validators[1].AddTokensFromDel(pool, delTokens2)
 	keeper.SetPool(ctx, pool)
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
 	validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false)
@@ -714,14 +736,17 @@ func TestApplyAndReturnValidatorSetUpdatesMultipleValueChange(t *testing.T) {
 func TestApplyAndReturnValidatorSetUpdatesInserted(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 1000)
 
-	amts := []int64{10, 20, 5, 15, 25}
+	powers := []int64{10, 20, 5, 15, 25}
 	var validators [5]types.Validator
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 		keeper.SetPool(ctx, pool)
 	}
+
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
 	validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false)
 	require.Equal(t, 2, len(keeper.ApplyAndReturnValidatorSetUpdates(ctx)))
@@ -760,12 +785,14 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
 	params.MaxValidators = 2
 	keeper.SetParams(ctx, params)
 
-	amts := []int64{10, 20, 5}
+	powers := []int64{10, 20, 5}
 	var validators [5]types.Validator
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 		keeper.SetPool(ctx, pool)
 	}
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
@@ -783,7 +810,8 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
 	require.Equal(t, 0, len(keeper.ApplyAndReturnValidatorSetUpdates(ctx)))
 
 	pool := keeper.GetPool(ctx)
-	validators[2], pool, _ = validators[2].AddTokensFromDel(pool, sdk.NewInt(10))
+	tokens := types.TokensFromTendermintPower(10)
+	validators[2], pool, _ = validators[2].AddTokensFromDel(pool, tokens)
 	keeper.SetPool(ctx, pool)
 	keeper.SetValidator(ctx, validators[2])
 	keeper.SetValidatorByPowerIndex(ctx, validators[2])
@@ -797,12 +825,14 @@ func TestApplyAndReturnValidatorSetUpdatesWithCliffValidator(t *testing.T) {
 func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
 	ctx, _, keeper := CreateTestInput(t, false, 1000)
 
-	amts := []int64{100, 100}
+	powers := []int64{100, 100}
 	var validators [2]types.Validator
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 		validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 		keeper.SetPool(ctx, pool)
 	}
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
@@ -810,21 +840,23 @@ func TestApplyAndReturnValidatorSetUpdatesPowerDecrease(t *testing.T) {
 	require.Equal(t, 2, len(keeper.ApplyAndReturnValidatorSetUpdates(ctx)))
 
 	// check initial power
-	require.Equal(t, int64(100), validators[0].GetPower().Int64())
-	require.Equal(t, int64(100), validators[1].GetPower().Int64())
+	require.Equal(t, int64(100), validators[0].GetTendermintPower())
+	require.Equal(t, int64(100), validators[1].GetTendermintPower())
 
 	// test multiple value change
 	//  tendermintUpdate set: {c1, c3} -> {c1', c3'}
 	pool := keeper.GetPool(ctx)
-	validators[0], pool, _ = validators[0].RemoveDelShares(pool, sdk.NewDec(20))
-	validators[1], pool, _ = validators[1].RemoveDelShares(pool, sdk.NewDec(30))
+	delTokens1 := types.TokensFromTendermintPower(20)
+	delTokens2 := types.TokensFromTendermintPower(30)
+	validators[0], pool, _ = validators[0].RemoveDelShares(pool, sdk.NewDecFromInt(delTokens1))
+	validators[1], pool, _ = validators[1].RemoveDelShares(pool, sdk.NewDecFromInt(delTokens2))
 	keeper.SetPool(ctx, pool)
 	validators[0] = TestingUpdateValidator(keeper, ctx, validators[0], false)
 	validators[1] = TestingUpdateValidator(keeper, ctx, validators[1], false)
 
 	// power has changed
-	require.Equal(t, int64(80), validators[0].GetPower().Int64())
-	require.Equal(t, int64(70), validators[1].GetPower().Int64())
+	require.Equal(t, int64(80), validators[0].GetTendermintPower())
+	require.Equal(t, int64(70), validators[1].GetTendermintPower())
 
 	// Tendermint updates should reflect power change
 	updates := keeper.ApplyAndReturnValidatorSetUpdates(ctx)
@@ -840,17 +872,18 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 
 	keeper.SetParams(ctx, params)
 
-	amts := []int64{100, 100}
+	powers := []int64{100, 100}
 	var validators [2]types.Validator
 
 	// initialize some validators into the state
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 		valPubKey := PKs[i+1]
 		valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
 
 		validators[i] = types.NewValidator(valAddr, valPubKey, types.Description{})
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 
 		keeper.SetPool(ctx, pool)
 		keeper.SetValidator(ctx, validators[i])
@@ -868,10 +901,11 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	require.Equal(t, 0, len(keeper.ApplyAndReturnValidatorSetUpdates(ctx)))
 
 	// update initial validator set
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 		keeper.DeleteValidatorByPowerIndex(ctx, validators[i])
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 
 		keeper.SetPool(ctx, pool)
 		keeper.SetValidator(ctx, validators[i])
@@ -900,7 +934,8 @@ func TestApplyAndReturnValidatorSetUpdatesNewValidator(t *testing.T) {
 	valAddr = sdk.ValAddress(valPubKey.Address().Bytes())
 
 	validator = types.NewValidator(valAddr, valPubKey, types.Description{})
-	validator, pool, _ = validator.AddTokensFromDel(pool, sdk.NewInt(500))
+	tokens := types.TokensFromTendermintPower(500)
+	validator, pool, _ = validator.AddTokensFromDel(pool, tokens)
 	keeper.SetValidator(ctx, validator)
 	keeper.SetValidatorByPowerIndex(ctx, validator)
 	keeper.SetPool(ctx, pool)
@@ -923,18 +958,19 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 
 	keeper.SetParams(ctx, params)
 
-	amts := []int64{100, 200, 300}
+	powers := []int64{100, 200, 300}
 	var validators [3]types.Validator
 
 	// initialize some validators into the state
-	for i, amt := range amts {
+	for i, power := range powers {
 		pool := keeper.GetPool(ctx)
 		moniker := fmt.Sprintf("%d", i)
 		valPubKey := PKs[i+1]
 		valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
 
 		validators[i] = types.NewValidator(valAddr, valPubKey, types.Description{Moniker: moniker})
-		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, sdk.NewInt(amt))
+		tokens := types.TokensFromTendermintPower(power)
+		validators[i], pool, _ = validators[i].AddTokensFromDel(pool, tokens)
 		keeper.SetPool(ctx, pool)
 		keeper.SetValidator(ctx, validators[i])
 		keeper.SetValidatorByPowerIndex(ctx, validators[i])
@@ -959,7 +995,8 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 	require.True(t, found)
 
 	keeper.DeleteValidatorByPowerIndex(ctx, validators[0])
-	validators[0], pool, _ = validators[0].AddTokensFromDel(pool, sdk.NewInt(1))
+	tokens := types.TokensFromTendermintPower(1)
+	validators[0], pool, _ = validators[0].AddTokensFromDel(pool, tokens)
 	keeper.SetPool(ctx, pool)
 	keeper.SetValidator(ctx, validators[0])
 	keeper.SetValidatorByPowerIndex(ctx, validators[0])
@@ -984,7 +1021,8 @@ func TestApplyAndReturnValidatorSetUpdatesBondTransition(t *testing.T) {
 	require.Equal(t, 0, len(updates))
 
 	keeper.DeleteValidatorByPowerIndex(ctx, validators[1])
-	validators[1], pool, _ = validators[1].AddTokensFromDel(pool, sdk.NewInt(250))
+	tokens = types.TokensFromTendermintPower(250)
+	validators[1], pool, _ = validators[1].AddTokensFromDel(pool, tokens)
 	keeper.SetPool(ctx, pool)
 	keeper.SetValidator(ctx, validators[1])
 	keeper.SetValidatorByPowerIndex(ctx, validators[1])
diff --git a/x/staking/querier/querier_test.go b/x/staking/querier/querier_test.go
index 3793e119a429..58dfc5c6ca8e 100644
--- a/x/staking/querier/querier_test.go
+++ b/x/staking/querier/querier_test.go
@@ -177,7 +177,8 @@ func TestQueryDelegation(t *testing.T) {
 	keeper.SetValidator(ctx, val2)
 	keeper.SetValidatorByPowerIndex(ctx, val2)
 
-	keeper.Delegate(ctx, addrAcc2, sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(20)), val1, true)
+	delTokens := types.TokensFromTendermintPower(20)
+	keeper.Delegate(ctx, addrAcc2, sdk.NewCoin(types.DefaultBondDenom, delTokens), val1, true)
 
 	// apply TM updates
 	keeper.ApplyAndReturnValidatorSetUpdates(ctx)
@@ -296,7 +297,8 @@ func TestQueryDelegation(t *testing.T) {
 	require.Equal(t, delegationsRes[0], delegation)
 
 	// Query unbonging delegation
-	_, err = keeper.Undelegate(ctx, addrAcc2, val1.OperatorAddr, sdk.NewDec(10))
+	unbondingTokens := types.TokensFromTendermintPower(10)
+	_, err = keeper.Undelegate(ctx, addrAcc2, val1.OperatorAddr, sdk.NewDecFromInt(unbondingTokens))
 	require.Nil(t, err)
 
 	queryBondParams = NewQueryBondsParams(addrAcc2, addrVal1)
@@ -348,7 +350,9 @@ func TestQueryDelegation(t *testing.T) {
 	require.NotNil(t, err)
 
 	// Query redelegation
-	_, err = keeper.BeginRedelegation(ctx, addrAcc2, val1.OperatorAddr, val2.OperatorAddr, sdk.NewDec(10))
+	redelegationTokens := types.TokensFromTendermintPower(10)
+	_, err = keeper.BeginRedelegation(ctx, addrAcc2, val1.OperatorAddr,
+		val2.OperatorAddr, sdk.NewDecFromInt(redelegationTokens))
 	require.Nil(t, err)
 	redel, found := keeper.GetRedelegation(ctx, addrAcc2, val1.OperatorAddr, val2.OperatorAddr)
 	require.True(t, found)
@@ -381,10 +385,12 @@ func TestQueryRedelegations(t *testing.T) {
 	keeper.SetValidator(ctx, val1)
 	keeper.SetValidator(ctx, val2)
 
-	keeper.Delegate(ctx, addrAcc2, sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(100)), val1, true)
+	delAmount := types.TokensFromTendermintPower(100)
+	keeper.Delegate(ctx, addrAcc2, sdk.NewCoin(types.DefaultBondDenom, delAmount), val1, true)
 	_ = keeper.ApplyAndReturnValidatorSetUpdates(ctx)
 
-	keeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), sdk.NewDec(20))
+	rdAmount := types.TokensFromTendermintPower(20)
+	keeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), sdk.NewDecFromInt(rdAmount))
 	keeper.ApplyAndReturnValidatorSetUpdates(ctx)
 
 	redelegation, found := keeper.GetRedelegation(ctx, addrAcc2, val1.OperatorAddr, val2.OperatorAddr)
diff --git a/x/staking/simulation/invariants.go b/x/staking/simulation/invariants.go
index a5759483eb9e..28cce38a40e1 100644
--- a/x/staking/simulation/invariants.go
+++ b/x/staking/simulation/invariants.go
@@ -11,7 +11,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/mock/simulation"
 	"github.com/cosmos/cosmos-sdk/x/staking"
 	"github.com/cosmos/cosmos-sdk/x/staking/keeper"
-	stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 // AllInvariants runs all invariants of the staking module.
@@ -55,7 +54,7 @@ func SupplyInvariants(ck bank.Keeper, k staking.Keeper,
 		loose := sdk.ZeroDec()
 		bonded := sdk.ZeroDec()
 		am.IterateAccounts(ctx, func(acc auth.Account) bool {
-			loose = loose.Add(sdk.NewDecFromInt(acc.GetCoins().AmountOf(stakingTypes.DefaultBondDenom)))
+			loose = loose.Add(sdk.NewDecFromInt(acc.GetCoins().AmountOf(staking.DefaultBondDenom)))
 			return false
 		})
 		k.IterateUnbondingDelegations(ctx, func(_ int64, ubd staking.UnbondingDelegation) bool {
@@ -67,7 +66,7 @@ func SupplyInvariants(ck bank.Keeper, k staking.Keeper,
 		k.IterateValidators(ctx, func(_ int64, validator sdk.Validator) bool {
 			switch validator.GetStatus() {
 			case sdk.Bonded:
-				bonded = bonded.Add(sdk.NewDecFromInt(validator.GetPower()))
+				bonded = bonded.Add(sdk.NewDecFromInt(validator.GetBondedTokens()))
 			case sdk.Unbonding, sdk.Unbonded:
 				loose = loose.Add(sdk.NewDecFromInt(validator.GetTokens()))
 			}
@@ -77,13 +76,13 @@ func SupplyInvariants(ck bank.Keeper, k staking.Keeper,
 		feePool := d.GetFeePool(ctx)
 
 		// add outstanding fees
-		loose = loose.Add(sdk.NewDecFromInt(f.GetCollectedFees(ctx).AmountOf(stakingTypes.DefaultBondDenom)))
+		loose = loose.Add(sdk.NewDecFromInt(f.GetCollectedFees(ctx).AmountOf(staking.DefaultBondDenom)))
 
 		// add community pool
-		loose = loose.Add(feePool.CommunityPool.AmountOf(stakingTypes.DefaultBondDenom))
+		loose = loose.Add(feePool.CommunityPool.AmountOf(staking.DefaultBondDenom))
 
 		// add yet-to-be-withdrawn
-		loose = loose.Add(d.GetOutstandingRewards(ctx).AmountOf(stakingTypes.DefaultBondDenom))
+		loose = loose.Add(d.GetOutstandingRewards(ctx).AmountOf(staking.DefaultBondDenom))
 
 		// Not-bonded tokens should equal coin supply plus unbonding delegations
 		// plus tokens on unbonded validators
@@ -119,7 +118,8 @@ func NonNegativePowerInvariant(k staking.Keeper) simulation.Invariant {
 
 			if !bytes.Equal(iterator.Key(), powerKey) {
 				return fmt.Errorf("power store invariance:\n\tvalidator.Power: %v"+
-					"\n\tkey should be: %v\n\tkey in store: %v", validator.GetPower(), powerKey, iterator.Key())
+					"\n\tkey should be: %v\n\tkey in store: %v",
+					validator.GetTendermintPower(), powerKey, iterator.Key())
 			}
 
 			if validator.Tokens.IsNegative() {
diff --git a/x/staking/staking.go b/x/staking/staking.go
index 53d37fd06cfc..3544c2d2c1c2 100644
--- a/x/staking/staking.go
+++ b/x/staking/staking.go
@@ -14,6 +14,7 @@ type (
 	Validators              = types.Validators
 	Description             = types.Description
 	Commission              = types.Commission
+	CommissionMsg           = types.CommissionMsg
 	Delegation              = types.Delegation
 	Delegations             = types.Delegations
 	UnbondingDelegation     = types.UnbondingDelegation
@@ -82,6 +83,10 @@ var (
 	DefaultGenesisState   = types.DefaultGenesisState
 	RegisterCodec         = types.RegisterCodec
 
+	ValidatorUpdateDelay      = types.ValidatorUpdateDelay
+	TokensToTendermintPower   = types.TokensToTendermintPower
+	TokensFromTendermintPower = types.TokensFromTendermintPower
+
 	NewMsgCreateValidator           = types.NewMsgCreateValidator
 	NewMsgCreateValidatorOnBehalfOf = types.NewMsgCreateValidatorOnBehalfOf
 	NewMsgEditValidator             = types.NewMsgEditValidator
diff --git a/x/staking/test_common.go b/x/staking/test_common.go
index d13aab892561..ad9d1ef795f6 100644
--- a/x/staking/test_common.go
+++ b/x/staking/test_common.go
@@ -26,28 +26,30 @@ var (
 	commissionMsg = NewCommissionMsg(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())
 )
 
-func NewTestMsgCreateValidator(address sdk.ValAddress, pubKey crypto.PubKey, amt int64) MsgCreateValidator {
+func NewTestMsgCreateValidator(address sdk.ValAddress, pubKey crypto.PubKey, amt sdk.Int) MsgCreateValidator {
 	return types.NewMsgCreateValidator(
-		address, pubKey, sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(amt)), Description{}, commissionMsg,
+		address, pubKey, sdk.NewCoin(types.DefaultBondDenom, amt), Description{}, commissionMsg,
 	)
 }
 
 func NewTestMsgCreateValidatorWithCommission(address sdk.ValAddress, pubKey crypto.PubKey,
-	amt int64, commissionRate sdk.Dec) MsgCreateValidator {
+	amt sdk.Int, commissionRate sdk.Dec) MsgCreateValidator {
 
 	commission := NewCommissionMsg(commissionRate, sdk.OneDec(), sdk.ZeroDec())
 
 	return types.NewMsgCreateValidator(
-		address, pubKey, sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(amt)), Description{}, commission,
+		address, pubKey, sdk.NewCoin(types.DefaultBondDenom, amt), Description{}, commission,
 	)
 }
 
-func NewTestMsgDelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, amt int64) MsgDelegate {
-	amount := sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(amt))
+func NewTestMsgDelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, amt sdk.Int) MsgDelegate {
+	amount := sdk.NewCoin(types.DefaultBondDenom, amt)
 	return NewMsgDelegate(delAddr, valAddr, amount)
 }
 
-func NewTestMsgCreateValidatorOnBehalfOf(delAddr sdk.AccAddress, valAddr sdk.ValAddress, valPubKey crypto.PubKey, amt int64) MsgCreateValidator {
-	amount := sdk.NewCoin(types.DefaultBondDenom, sdk.NewInt(amt))
+func NewTestMsgCreateValidatorOnBehalfOf(delAddr sdk.AccAddress, valAddr sdk.ValAddress,
+	valPubKey crypto.PubKey, amt sdk.Int) MsgCreateValidator {
+
+	amount := sdk.NewCoin(types.DefaultBondDenom, amt)
 	return NewMsgCreateValidatorOnBehalfOf(delAddr, valAddr, valPubKey, amount, Description{}, commissionMsg)
 }
diff --git a/x/staking/types/commission.go b/x/staking/types/commission.go
index 730bb6741394..4baeea799c6b 100644
--- a/x/staking/types/commission.go
+++ b/x/staking/types/commission.go
@@ -7,23 +7,21 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-type (
-	// Commission defines a commission parameters for a given validator.
-	Commission struct {
-		Rate          sdk.Dec   `json:"rate"`            // the commission rate charged to delegators
-		MaxRate       sdk.Dec   `json:"max_rate"`        // maximum commission rate which this validator can ever charge
-		MaxChangeRate sdk.Dec   `json:"max_change_rate"` // maximum daily increase of the validator commission
-		UpdateTime    time.Time `json:"update_time"`     // the last time the commission rate was changed
-	}
+// Commission defines a commission parameters for a given validator.
+type Commission struct {
+	Rate          sdk.Dec   `json:"rate"`            // the commission rate charged to delegators
+	MaxRate       sdk.Dec   `json:"max_rate"`        // maximum commission rate which this validator can ever charge
+	MaxChangeRate sdk.Dec   `json:"max_change_rate"` // maximum daily increase of the validator commission
+	UpdateTime    time.Time `json:"update_time"`     // the last time the commission rate was changed
+}
 
-	// CommissionMsg defines a commission message to be used for creating a
-	// validator.
-	CommissionMsg struct {
-		Rate          sdk.Dec `json:"rate"`            // the commission rate charged to delegators
-		MaxRate       sdk.Dec `json:"max_rate"`        // maximum commission rate which validator can ever charge
-		MaxChangeRate sdk.Dec `json:"max_change_rate"` // maximum daily increase of the validator commission
-	}
-)
+// CommissionMsg defines a commission message to be used for creating a
+// validator.
+type CommissionMsg struct {
+	Rate          sdk.Dec `json:"rate"`            // the commission rate charged to delegators
+	MaxRate       sdk.Dec `json:"max_rate"`        // maximum commission rate which validator can ever charge
+	MaxChangeRate sdk.Dec `json:"max_change_rate"` // maximum daily increase of the validator commission
+}
 
 // NewCommissionMsg returns an initialized validator commission message.
 func NewCommissionMsg(rate, maxRate, maxChangeRate sdk.Dec) CommissionMsg {
diff --git a/x/staking/types/genesis.go b/x/staking/types/genesis.go
index 12c73278137b..fdc9b9677b7b 100644
--- a/x/staking/types/genesis.go
+++ b/x/staking/types/genesis.go
@@ -20,7 +20,7 @@ type GenesisState struct {
 // Last validator power, needed for validator set update logic
 type LastValidatorPower struct {
 	Address sdk.ValAddress
-	Power   sdk.Int
+	Power   int64
 }
 
 func NewGenesisState(pool Pool, params Params, validators []Validator, bonds []Delegation) GenesisState {
diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go
index ea8dafe2bed1..03f253d2cd71 100644
--- a/x/staking/types/validator.go
+++ b/x/staking/types/validator.go
@@ -3,6 +3,7 @@ package types
 import (
 	"bytes"
 	"fmt"
+	"math/big"
 	"strings"
 	"time"
 
@@ -264,7 +265,7 @@ func (d Description) EnsureLength() (Description, sdk.Error) {
 func (v Validator) ABCIValidatorUpdate() abci.ValidatorUpdate {
 	return abci.ValidatorUpdate{
 		PubKey: tmtypes.TM2PB.PubKey(v.ConsPubKey),
-		Power:  v.BondedTokens().Int64(),
+		Power:  v.TendermintPower(),
 	}
 }
 
@@ -400,7 +401,7 @@ func (v Validator) DelegatorShareExRate() sdk.Dec {
 	return sdk.NewDecFromInt(v.Tokens).Quo(v.DelegatorShares)
 }
 
-// Get the bonded tokens which the validator holds
+// get the bonded tokens which the validator holds
 func (v Validator) BondedTokens() sdk.Int {
 	if v.Status == sdk.Bonded {
 		return v.Tokens
@@ -408,6 +409,34 @@ func (v Validator) BondedTokens() sdk.Int {
 	return sdk.ZeroInt()
 }
 
+// get the Tendermint Power
+// a reduction of 10^9 from validator tokens is applied
+func (v Validator) TendermintPower() int64 {
+	if v.Status == sdk.Bonded {
+		return v.PotentialTendermintPower()
+	}
+	return 0
+}
+
+var powerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(6), nil))
+
+// potential Tendermint power
+func (v Validator) PotentialTendermintPower() int64 {
+	return (v.Tokens.Div(powerReduction)).Int64()
+}
+
+// utility functions
+
+// TokensToTendermintPower - convert input tokens to potential tendermint power
+func TokensToTendermintPower(tokens sdk.Int) int64 {
+	return (tokens.Div(powerReduction)).Int64()
+}
+
+// TokensFromTendermintPower - convert input power to tokens
+func TokensFromTendermintPower(power int64) sdk.Int {
+	return sdk.NewInt(power).Mul(powerReduction)
+}
+
 //______________________________________________________________________
 
 // ensure fulfills the sdk validator types
@@ -420,8 +449,9 @@ func (v Validator) GetStatus() sdk.BondStatus        { return v.Status }
 func (v Validator) GetOperator() sdk.ValAddress      { return v.OperatorAddr }
 func (v Validator) GetConsPubKey() crypto.PubKey     { return v.ConsPubKey }
 func (v Validator) GetConsAddr() sdk.ConsAddress     { return sdk.ConsAddress(v.ConsPubKey.Address()) }
-func (v Validator) GetPower() sdk.Int                { return v.BondedTokens() }
 func (v Validator) GetTokens() sdk.Int               { return v.Tokens }
+func (v Validator) GetBondedTokens() sdk.Int         { return v.BondedTokens() }
+func (v Validator) GetTendermintPower() int64        { return v.TendermintPower() }
 func (v Validator) GetCommission() sdk.Dec           { return v.Commission.Rate }
 func (v Validator) GetDelegatorShares() sdk.Dec      { return v.DelegatorShares }
 func (v Validator) GetBondHeight() int64             { return v.BondHeight }