certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge PR #3561: Don't store denominations in staking

This commit is contained in:
Christopher Goes 2019-02-08 22:28:53 +01:00 committed by Jack Zampolin
parent 9348750eb4
commit 6ee9c97a5e
14 changed files with 63 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
PENDING.md
View File

@ -30,9 +30,10 @@ BREAKING CHANGES
* [\#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
* [\#3514](https://github.com/cosmos/cosmos-sdk/pull/3514) Various clean ups:
- Replace all GetKeyBase* functions family in favor of NewKeyBaseFromDir and NewKeyBaseFromHomeFlag.
- Replace all GetKeyBase\* functions family in favor of NewKeyBaseFromDir and NewKeyBaseFromHomeFlag.
- Remove Get prefix from all TxBuilder's getters.
* [\#3522](https://github.com/cosmos/cosmos-sdk/pull/3522) Get rid of double negatives: Coins.IsNotNegative() -> Coins.IsAnyNegative().
* \#3561 Don't unnecessarily store denominations in staking
* Tendermint

6
client/lcd/lcd_test.go
View File

@ -651,7 +651,7 @@ func TestBonding(t *testing.T) {
ubd := getUnbondingDelegation(t, port, addr, operAddrs[0])
require.Len(t, ubd.Entries, 1)
require.Equal(t, delTokens.DivRaw(2), ubd.Entries[0].Balance.Amount)
require.Equal(t, delTokens.DivRaw(2), ubd.Entries[0].Balance)
// test redelegation
rdTokens := staking.TokensFromTendermintPower(30)
@ -691,7 +691,7 @@ func TestBonding(t *testing.T) {
delegatorUbds := getDelegatorUnbondingDelegations(t, port, addr)
require.Len(t, delegatorUbds, 1)
require.Len(t, delegatorUbds[0].Entries, 1)
require.Equal(t, rdTokens, delegatorUbds[0].Entries[0].Balance.Amount)
require.Equal(t, rdTokens, delegatorUbds[0].Entries[0].Balance)
delegatorReds := getRedelegations(t, port, addr, nil, nil)
require.Len(t, delegatorReds, 1)
@ -700,7 +700,7 @@ func TestBonding(t *testing.T) {
validatorUbds := getValidatorUnbondingDelegations(t, port, operAddrs[0])
require.Len(t, validatorUbds, 1)
require.Len(t, validatorUbds[0].Entries, 1)
require.Equal(t, rdTokens, validatorUbds[0].Entries[0].Balance.Amount)
require.Equal(t, rdTokens, validatorUbds[0].Entries[0].Balance)
validatorReds := getRedelegations(t, port, nil, operAddrs[0], nil)
require.Len(t, validatorReds, 1)

2
cmd/gaia/cli_test/cli_test.go
View File

@ -375,7 +375,7 @@ func TestGaiaCLICreateValidator(t *testing.T) {
validatorUbds := f.QueryStakingUnbondingDelegationsFrom(barVal)
require.Len(t, validatorUbds, 1)
require.Len(t, validatorUbds[0].Entries, 1)
require.Equal(t, remainingTokens.String(), validatorUbds[0].Entries[0].Balance.Amount.String())
require.Equal(t, remainingTokens.String(), validatorUbds[0].Entries[0].Balance.String())
f.Cleanup()
}

4
x/staking/handler.go
View File

@ -137,7 +137,7 @@ func handleMsgCreateValidator(ctx sdk.Context, msg types.MsgCreateValidator, k k
// move coins from the msg.Address account to a (self-delegation) delegator account
// the validator account and global shares are updated within here
_, err = k.Delegate(ctx, msg.DelegatorAddr, msg.Value, validator, true)
_, err = k.Delegate(ctx, msg.DelegatorAddr, msg.Value.Amount, validator, true)
if err != nil {
return err.Result()
}
@ -213,7 +213,7 @@ func handleMsgDelegate(ctx sdk.Context, msg types.MsgDelegate, k keeper.Keeper)
return ErrBadDenom(k.Codespace()).Result()
}
_, err := k.Delegate(ctx, msg.DelegatorAddr, msg.Value, validator, true)
_, err := k.Delegate(ctx, msg.DelegatorAddr, msg.Value.Amount, validator, true)
if err != nil {
return err.Result()
}

4
x/staking/handler_test.go
View File

@ -1239,7 +1239,7 @@ 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, ubdTokens.DivRaw(2), ubd.Entries[0].Balance.Amount)
require.Equal(t, ubdTokens.DivRaw(2), ubd.Entries[0].Balance)
// redelegation should have been slashed by half
redelegation, found := keeper.GetRedelegation(ctx, del, valA, valB)
@ -1264,7 +1264,7 @@ 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, ubdTokens.DivRaw(2), ubd.Entries[0].Balance.Amount)
require.Equal(t, ubdTokens.DivRaw(2), ubd.Entries[0].Balance)
// redelegation should be unchanged
redelegation, found = keeper.GetRedelegation(ctx, del, valA, valB)

20
x/staking/keeper/delegation.go
View File

@ -184,7 +184,7 @@ func (k Keeper) RemoveUnbondingDelegation(ctx sdk.Context, ubd types.UnbondingDe
// the given addresses. It creates the unbonding delegation if it does not exist
func (k Keeper) SetUnbondingDelegationEntry(ctx sdk.Context,
delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress,
creationHeight int64, minTime time.Time, balance sdk.Coin) types.UnbondingDelegation {
creationHeight int64, minTime time.Time, balance sdk.Int) types.UnbondingDelegation {
ubd, found := k.GetUnbondingDelegation(ctx, delegatorAddr, validatorAddr)
if found {
@ -344,7 +344,7 @@ func (k Keeper) SetRedelegation(ctx sdk.Context, red types.Redelegation) {
func (k Keeper) SetRedelegationEntry(ctx sdk.Context,
delegatorAddr sdk.AccAddress, validatorSrcAddr,
validatorDstAddr sdk.ValAddress, creationHeight int64,
minTime time.Time, balance sdk.Coin,
minTime time.Time, balance sdk.Int,
sharesSrc, sharesDst sdk.Dec) types.Redelegation {
red, found := k.GetRedelegation(ctx, delegatorAddr, validatorSrcAddr, validatorDstAddr)
@ -444,7 +444,7 @@ func (k Keeper) DequeueAllMatureRedelegationQueue(ctx sdk.Context, currTime time
}
// Perform a delegation, set/update everything necessary within the store.
func (k Keeper) Delegate(ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.Coin,
func (k Keeper) Delegate(ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.Int,
validator types.Validator, subtractAccount bool) (newShares sdk.Dec, err sdk.Error) {
// In some situations, the exchange rate becomes invalid, e.g. if
@ -472,13 +472,13 @@ func (k Keeper) Delegate(ctx sdk.Context, delAddr sdk.AccAddress, bondAmt sdk.Co
}
if subtractAccount {
_, err := k.bankKeeper.DelegateCoins(ctx, delegation.DelegatorAddr, sdk.Coins{bondAmt})
_, err := k.bankKeeper.DelegateCoins(ctx, delegation.DelegatorAddr, sdk.Coins{sdk.NewCoin(k.GetParams(ctx).BondDenom, bondAmt)})
if err != nil {
return sdk.Dec{}, err
}
}
validator, newShares = k.AddValidatorTokensAndShares(ctx, validator, bondAmt.Amount)
validator, newShares = k.AddValidatorTokensAndShares(ctx, validator, bondAmt)
// Update delegation
delegation.Shares = delegation.Shares.Add(newShares)
@ -604,7 +604,7 @@ func (k Keeper) Undelegate(ctx sdk.Context, delAddr sdk.AccAddress,
}
ubd := k.SetUnbondingDelegationEntry(ctx, delAddr,
valAddr, height, completionTime, balance)
valAddr, height, completionTime, returnAmount)
k.InsertUBDQueue(ctx, ubd, completionTime)
return completionTime, nil
@ -631,7 +631,7 @@ func (k Keeper) CompleteUnbonding(ctx sdk.Context, delAddr sdk.AccAddress,
// track undelegation only when remaining or truncated shares are non-zero
if !entry.Balance.IsZero() {
_, err := k.bankKeeper.UndelegateCoins(ctx, ubd.DelegatorAddr, sdk.Coins{entry.Balance})
_, err := k.bankKeeper.UndelegateCoins(ctx, ubd.DelegatorAddr, sdk.Coins{sdk.NewCoin(k.GetParams(ctx).BondDenom, entry.Balance)})
if err != nil {
return err
}
@ -675,14 +675,12 @@ func (k Keeper) BeginRedelegation(ctx sdk.Context, delAddr sdk.AccAddress,
if returnAmount.IsZero() {
return time.Time{}, types.ErrVerySmallRedelegation(k.Codespace())
}
returnCoin := sdk.NewCoin(k.BondDenom(ctx), returnAmount)
dstValidator, found := k.GetValidator(ctx, valDstAddr)
if !found {
return time.Time{}, types.ErrBadRedelegationDst(k.Codespace())
}
sharesCreated, err := k.Delegate(ctx, delAddr, returnCoin, dstValidator, false)
sharesCreated, err := k.Delegate(ctx, delAddr, returnAmount, dstValidator, false)
if err != nil {
return time.Time{}, err
}
@ -695,7 +693,7 @@ func (k Keeper) BeginRedelegation(ctx sdk.Context, delAddr sdk.AccAddress,
}
red := k.SetRedelegationEntry(ctx, delAddr, valSrcAddr, valDstAddr,
height, completionTime, returnCoin, sharesAmount, sharesCreated)
height, completionTime, returnAmount, sharesAmount, sharesCreated)
k.InsertRedelegationQueue(ctx, red, completionTime)
return completionTime, nil
}

10
x/staking/keeper/delegation_test.go
View File

@ -133,7 +133,7 @@ func TestUnbondingDelegation(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 0,
time.Unix(0, 0), sdk.NewInt64Coin(types.DefaultBondDenom, 5))
time.Unix(0, 0), sdk.NewInt(5))
// set and retrieve a record
keeper.SetUnbondingDelegation(ctx, ubd)
@ -142,7 +142,7 @@ func TestUnbondingDelegation(t *testing.T) {
require.True(t, ubd.Equal(resUnbond))
// modify a records, save, and retrieve
ubd.Entries[0].Balance = sdk.NewInt64Coin(types.DefaultBondDenom, 21)
ubd.Entries[0].Balance = sdk.NewInt(21)
keeper.SetUnbondingDelegation(ctx, ubd)
resUnbonds := keeper.GetUnbondingDelegations(ctx, addrDels[0], 5)
@ -366,7 +366,7 @@ func TestUndelegateFromUnbondingValidator(t *testing.T) {
ubd, found := keeper.GetUnbondingDelegation(ctx, addrDels[0], addrVals[0])
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.Equal(sdk.NewInt(6)))
assert.Equal(t, blockHeight, ubd.Entries[0].CreationHeight)
assert.True(t, blockTime.Add(params.UnbondingTime).Equal(ubd.Entries[0].CompletionTime))
}
@ -510,7 +510,7 @@ func TestGetRedelegationsFromValidator(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0,
time.Unix(0, 0), sdk.NewInt64Coin(types.DefaultBondDenom, 5),
time.Unix(0, 0), sdk.NewInt(5),
sdk.NewDec(5))
// set and retrieve a record
@ -534,7 +534,7 @@ func TestRedelegation(t *testing.T) {
ctx, _, keeper := CreateTestInput(t, false, 0)
rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0,
time.Unix(0, 0), sdk.NewInt64Coin(types.DefaultBondDenom, 5),
time.Unix(0, 0), sdk.NewInt(5),
sdk.NewDec(5))
// test shouldn't have and redelegations

8
x/staking/keeper/slash.go
View File

@ -178,7 +178,7 @@ func (k Keeper) slashUnbondingDelegation(ctx sdk.Context, unbondingDelegation ty
}
// Calculate slash amount proportional to stake contributing to infraction
slashAmountDec := slashFactor.MulInt(entry.InitialBalance.Amount)
slashAmountDec := slashFactor.MulInt(entry.InitialBalance)
slashAmount := slashAmountDec.TruncateInt()
totalSlashAmount = totalSlashAmount.Add(slashAmount)
@ -186,13 +186,13 @@ func (k Keeper) slashUnbondingDelegation(ctx sdk.Context, unbondingDelegation ty
// Possible since the unbonding delegation may already
// have been slashed, and slash amounts are calculated
// according to stake held at time of infraction
unbondingSlashAmount := sdk.MinInt(slashAmount, entry.Balance.Amount)
unbondingSlashAmount := sdk.MinInt(slashAmount, entry.Balance)
// Update unbonding delegation if necessary
if unbondingSlashAmount.IsZero() {
continue
}
entry.Balance.Amount = entry.Balance.Amount.Sub(unbondingSlashAmount)
entry.Balance = entry.Balance.Sub(unbondingSlashAmount)
unbondingDelegation.Entries[i] = entry
k.SetUnbondingDelegation(ctx, unbondingDelegation)
pool := k.GetPool(ctx)
@ -232,7 +232,7 @@ func (k Keeper) slashRedelegation(ctx sdk.Context, validator types.Validator, re
}
// Calculate slash amount proportional to stake contributing to infraction
slashAmountDec := slashFactor.MulInt(entry.InitialBalance.Amount)
slashAmountDec := slashFactor.MulInt(entry.InitialBalance)
slashAmount := slashAmountDec.TruncateInt()
totalSlashAmount = totalSlashAmount.Add(slashAmount)

36
x/staking/keeper/slash_test.go
View File

@ -68,13 +68,13 @@ func TestRevocation(t *testing.T) {
// tests slashUnbondingDelegation
func TestSlashUnbondingDelegation(t *testing.T) {
ctx, keeper, params := setupHelper(t, 10)
ctx, keeper, _ := setupHelper(t, 10)
fraction := sdk.NewDecWithPrec(5, 1)
// set an unbonding delegation with expiration timestamp (beyond which the
// unbonding delegation shouldn't be slashed)
ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 0,
time.Unix(5, 0), sdk.NewInt64Coin(params.BondDenom, 10))
time.Unix(5, 0), sdk.NewInt(10))
keeper.SetUnbondingDelegation(ctx, ubd)
@ -99,23 +99,23 @@ func TestSlashUnbondingDelegation(t *testing.T) {
require.Len(t, ubd.Entries, 1)
// initial balance unchanged
require.Equal(t, sdk.NewInt64Coin(params.BondDenom, 10), ubd.Entries[0].InitialBalance)
require.Equal(t, sdk.NewInt(10), ubd.Entries[0].InitialBalance)
// balance decreased
require.Equal(t, sdk.NewInt64Coin(params.BondDenom, 5), ubd.Entries[0].Balance)
require.Equal(t, sdk.NewInt(5), ubd.Entries[0].Balance)
newPool := keeper.GetPool(ctx)
require.Equal(t, int64(5), oldPool.NotBondedTokens.Sub(newPool.NotBondedTokens).Int64())
}
// tests slashRedelegation
func TestSlashRedelegation(t *testing.T) {
ctx, keeper, params := setupHelper(t, 10)
ctx, keeper, _ := setupHelper(t, 10)
fraction := sdk.NewDecWithPrec(5, 1)
// set a redelegation with an expiration timestamp beyond which the
// redelegation shouldn't be slashed
rd := types.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0,
time.Unix(5, 0), sdk.NewInt64Coin(params.BondDenom, 10), sdk.NewDec(10))
time.Unix(5, 0), sdk.NewInt(10), sdk.NewDec(10))
keeper.SetRedelegation(ctx, rd)
@ -154,7 +154,7 @@ func TestSlashRedelegation(t *testing.T) {
require.Equal(t, 1, len(updates))
// initialbalance unchanged
require.Equal(t, sdk.NewInt64Coin(params.BondDenom, 10), rd.Entries[0].InitialBalance)
require.Equal(t, sdk.NewInt(10), rd.Entries[0].InitialBalance)
// shares decreased
del, found = keeper.GetDelegation(ctx, addrDels[0], addrVals[1])
@ -231,7 +231,7 @@ func TestSlashValidatorAtCurrentHeight(t *testing.T) {
// tests Slash at a previous height with an unbonding delegation
func TestSlashWithUnbondingDelegation(t *testing.T) {
ctx, keeper, params := setupHelper(t, 10)
ctx, keeper, _ := setupHelper(t, 10)
consAddr := sdk.ConsAddress(PKs[0].Address())
fraction := sdk.NewDecWithPrec(5, 1)
@ -239,7 +239,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// unbonding delegation shouldn't be slashed
ubdTokens := types.TokensFromTendermintPower(4)
ubd := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
time.Unix(0, 0), sdk.NewCoin(params.BondDenom, ubdTokens))
time.Unix(0, 0), ubdTokens)
keeper.SetUnbondingDelegation(ctx, ubd)
// slash validator for the first time
@ -258,7 +258,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
require.True(t, found)
require.Len(t, ubd.Entries, 1)
// balance decreased
require.Equal(t, types.TokensFromTendermintPower(2), ubd.Entries[0].Balance.Amount)
require.Equal(t, types.TokensFromTendermintPower(2), ubd.Entries[0].Balance)
// read updated pool
newPool := keeper.GetPool(ctx)
// bonded tokens burned
@ -279,7 +279,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
require.True(t, found)
require.Len(t, ubd.Entries, 1)
// balance decreased again
require.Equal(t, sdk.NewInt(0), ubd.Entries[0].Balance.Amount)
require.Equal(t, sdk.NewInt(0), ubd.Entries[0].Balance)
// read updated pool
newPool = keeper.GetPool(ctx)
// bonded tokens burned again
@ -300,7 +300,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
require.True(t, found)
require.Len(t, ubd.Entries, 1)
// balance unchanged
require.Equal(t, sdk.NewInt(0), ubd.Entries[0].Balance.Amount)
require.Equal(t, sdk.NewInt(0), ubd.Entries[0].Balance)
// read updated pool
newPool = keeper.GetPool(ctx)
// bonded tokens burned again
@ -321,7 +321,7 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
require.True(t, found)
require.Len(t, ubd.Entries, 1)
// balance unchanged
require.Equal(t, sdk.NewInt(0), ubd.Entries[0].Balance.Amount)
require.Equal(t, sdk.NewInt(0), ubd.Entries[0].Balance)
// read updated pool
newPool = keeper.GetPool(ctx)
// just 1 bonded token burned again since that's all the validator now has
@ -337,14 +337,14 @@ func TestSlashWithUnbondingDelegation(t *testing.T) {
// tests Slash at a previous height with a redelegation
func TestSlashWithRedelegation(t *testing.T) {
ctx, keeper, params := setupHelper(t, 10)
ctx, keeper, _ := setupHelper(t, 10)
consAddr := sdk.ConsAddress(PKs[0].Address())
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.NewCoin(params.BondDenom, rdTokens), sdk.NewDecFromInt(rdTokens))
time.Unix(0, 0), rdTokens, sdk.NewDecFromInt(rdTokens))
keeper.SetRedelegation(ctx, rd)
// set the associated delegation
@ -445,14 +445,14 @@ func TestSlashWithRedelegation(t *testing.T) {
// tests Slash at a previous height with both an unbonding delegation and a redelegation
func TestSlashBoth(t *testing.T) {
ctx, keeper, params := setupHelper(t, 10)
ctx, keeper, _ := setupHelper(t, 10)
fraction := sdk.NewDecWithPrec(5, 1)
// 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.NewCoin(params.BondDenom, rdATokens),
time.Unix(0, 0), rdATokens,
sdk.NewDecFromInt(rdATokens))
keeper.SetRedelegation(ctx, rdA)
@ -464,7 +464,7 @@ func TestSlashBoth(t *testing.T) {
// unbonding delegation shouldn't be slashed)
ubdATokens := types.TokensFromTendermintPower(4)
ubdA := types.NewUnbondingDelegation(addrDels[0], addrVals[0], 11,
time.Unix(0, 0), sdk.NewCoin(params.BondDenom, ubdATokens))
time.Unix(0, 0), ubdATokens)
keeper.SetUnbondingDelegation(ctx, ubdA)
// slash validator

4
x/staking/querier/querier_test.go
View File

@ -178,7 +178,7 @@ func TestQueryDelegation(t *testing.T) {
keeper.SetValidatorByPowerIndex(ctx, val2)
delTokens := types.TokensFromTendermintPower(20)
keeper.Delegate(ctx, addrAcc2, sdk.NewCoin(types.DefaultBondDenom, delTokens), val1, true)
keeper.Delegate(ctx, addrAcc2, delTokens, val1, true)
// apply TM updates
keeper.ApplyAndReturnValidatorSetUpdates(ctx)
@ -386,7 +386,7 @@ func TestQueryRedelegations(t *testing.T) {
keeper.SetValidator(ctx, val2)
delAmount := types.TokensFromTendermintPower(100)
keeper.Delegate(ctx, addrAcc2, sdk.NewCoin(types.DefaultBondDenom, delAmount), val1, true)
keeper.Delegate(ctx, addrAcc2, delAmount, val1, true)
_ = keeper.ApplyAndReturnValidatorSetUpdates(ctx)
rdAmount := types.TokensFromTendermintPower(20)

2
x/staking/simulation/invariants.go
View File

@ -59,7 +59,7 @@ func SupplyInvariants(ck bank.Keeper, k staking.Keeper,
})
k.IterateUnbondingDelegations(ctx, func(_ int64, ubd staking.UnbondingDelegation) bool {
for _, entry := range ubd.Entries {
loose = loose.Add(sdk.NewDecFromInt(entry.Balance.Amount))
loose = loose.Add(sdk.NewDecFromInt(entry.Balance))
}
return false
})

19
x/staking/types/delegation.go
View File

@ -113,8 +113,8 @@ type UnbondingDelegation struct {
type UnbondingDelegationEntry struct {
CreationHeight int64 `json:"creation_height"` // height which the unbonding took place
CompletionTime time.Time `json:"completion_time"` // time at which the unbonding delegation will complete
InitialBalance sdk.Coin `json:"initial_balance"` // atoms initially scheduled to receive at completion
Balance sdk.Coin `json:"balance"` // atoms to receive at completion
InitialBalance sdk.Int `json:"initial_balance"` // atoms initially scheduled to receive at completion
Balance sdk.Int `json:"balance"` // atoms to receive at completion
}
// IsMature - is the current entry mature
@ -125,7 +125,7 @@ func (e UnbondingDelegationEntry) IsMature(currentTime time.Time) bool {
// NewUnbondingDelegation - create a new unbonding delegation object
func NewUnbondingDelegation(delegatorAddr sdk.AccAddress,
validatorAddr sdk.ValAddress, creationHeight int64, minTime time.Time,
balance sdk.Coin) UnbondingDelegation {
balance sdk.Int) UnbondingDelegation {
entry := NewUnbondingDelegationEntry(creationHeight, minTime, balance)
return UnbondingDelegation{
@ -137,7 +137,7 @@ func NewUnbondingDelegation(delegatorAddr sdk.AccAddress,
// NewUnbondingDelegation - create a new unbonding delegation object
func NewUnbondingDelegationEntry(creationHeight int64, completionTime time.Time,
balance sdk.Coin) UnbondingDelegationEntry {
balance sdk.Int) UnbondingDelegationEntry {
return UnbondingDelegationEntry{
CreationHeight: creationHeight,
@ -149,7 +149,7 @@ func NewUnbondingDelegationEntry(creationHeight int64, completionTime time.Time,
// AddEntry - append entry to the unbonding delegation
func (d *UnbondingDelegation) AddEntry(creationHeight int64,
minTime time.Time, balance sdk.Coin) {
minTime time.Time, balance sdk.Int) {
entry := NewUnbondingDelegationEntry(creationHeight, minTime, balance)
d.Entries = append(d.Entries, entry)
@ -225,18 +225,17 @@ type Redelegation struct {
}
// RedelegationEntry - entry to a Redelegation
// TODO: Why do we need to store the initial balance as `sdk.Coin` instead of just the amount
type RedelegationEntry struct {
CreationHeight int64 `json:"creation_height"` // height at which the redelegation took place
CompletionTime time.Time `json:"completion_time"` // time at which the redelegation will complete
InitialBalance sdk.Coin `json:"initial_balance"` // initial balance when redelegation started
InitialBalance sdk.Int `json:"initial_balance"` // initial balance when redelegation started
SharesDst sdk.Dec `json:"shares_dst"` // amount of destination-validator shares created by redelegation
}
// NewRedelegation - create a new redelegation object
func NewRedelegation(delegatorAddr sdk.AccAddress, validatorSrcAddr,
validatorDstAddr sdk.ValAddress, creationHeight int64,
minTime time.Time, balance sdk.Coin,
minTime time.Time, balance sdk.Int,
sharesDst sdk.Dec) Redelegation {
entry := NewRedelegationEntry(creationHeight,
@ -252,7 +251,7 @@ func NewRedelegation(delegatorAddr sdk.AccAddress, validatorSrcAddr,
// NewRedelegation - create a new redelegation object
func NewRedelegationEntry(creationHeight int64,
completionTime time.Time, balance sdk.Coin,
completionTime time.Time, balance sdk.Int,
sharesDst sdk.Dec) RedelegationEntry {
return RedelegationEntry{
@ -270,7 +269,7 @@ func (e RedelegationEntry) IsMature(currentTime time.Time) bool {
// AddEntry - append entry to the unbonding delegation
func (d *Redelegation) AddEntry(creationHeight int64,
minTime time.Time, balance sdk.Coin,
minTime time.Time, balance sdk.Int,
sharesDst sdk.Dec) {
entry := NewRedelegationEntry(creationHeight, minTime, balance, sharesDst)

10
x/staking/types/delegation_test.go
View File

@ -30,7 +30,7 @@ func TestDelegationString(t *testing.T) {
func TestUnbondingDelegationEqual(t *testing.T) {
ubd1 := NewUnbondingDelegation(sdk.AccAddress(addr1), addr2, 0,
time.Unix(0, 0), sdk.NewInt64Coin(DefaultBondDenom, 0))
time.Unix(0, 0), sdk.NewInt(0))
ubd2 := ubd1
ok := ubd1.Equal(ubd2)
@ -45,17 +45,17 @@ func TestUnbondingDelegationEqual(t *testing.T) {
func TestUnbondingDelegationString(t *testing.T) {
ubd := NewUnbondingDelegation(sdk.AccAddress(addr1), addr2, 0,
time.Unix(0, 0), sdk.NewInt64Coin(DefaultBondDenom, 0))
time.Unix(0, 0), sdk.NewInt(0))
require.NotEmpty(t, ubd.String())
}
func TestRedelegationEqual(t *testing.T) {
r1 := NewRedelegation(sdk.AccAddress(addr1), addr2, addr3, 0,
time.Unix(0, 0), sdk.NewInt64Coin(DefaultBondDenom, 0),
time.Unix(0, 0), sdk.NewInt(0),
sdk.NewDec(0))
r2 := NewRedelegation(sdk.AccAddress(addr1), addr2, addr3, 0,
time.Unix(0, 0), sdk.NewInt64Coin(DefaultBondDenom, 0),
time.Unix(0, 0), sdk.NewInt(0),
sdk.NewDec(0))
ok := r1.Equal(r2)
@ -70,7 +70,7 @@ func TestRedelegationEqual(t *testing.T) {
func TestRedelegationString(t *testing.T) {
r := NewRedelegation(sdk.AccAddress(addr1), addr2, addr3, 0,
time.Unix(0, 0), sdk.NewInt64Coin(DefaultBondDenom, 0),
time.Unix(0, 0), sdk.NewInt(0),
sdk.NewDec(10))
require.NotEmpty(t, r.String())

2
x/staking/types/msg.go
View File

@ -21,7 +21,6 @@ var (
//______________________________________________________________________
// MsgCreateValidator - struct for bonding transactions
// TODO: Why does this need to contain a denomination in `Value`
type MsgCreateValidator struct {
Description Description `json:"description"`
Commission CommissionMsg `json:"commission"`
@ -209,7 +208,6 @@ func (msg MsgEditValidator) ValidateBasic() sdk.Error {
}
// MsgDelegate - struct for bonding transactions
// TODO: Why do we need to store the denomination in `Value`
type MsgDelegate struct {
DelegatorAddr sdk.AccAddress `json:"delegator_addr"`
ValidatorAddr sdk.ValAddress `json:"validator_addr"`