fix: fix the cancel unbond

CHANGELOG.md

@@ -81,6 +81,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * (x/staking) [#12409](https://github.com/cosmos/cosmos-sdk/pull/12409) Migrate `x/staking` to self-managed parameters and deprecate it's usage of `x/params`.
 * (x/bank) [#11859](https://github.com/cosmos/cosmos-sdk/pull/11859) Move the SendEnabled information out of the Params and into the state store directly.
 * (x/gov) [#12771](https://github.com/cosmos/cosmos-sdk/pull/12771) Initial deposit requirement for proposals at submission time.
+* (x/staking) [#12967](https://github.com/cosmos/cosmos-sdk/pull/12967) `unbond` now creates only one unbonding delegation entry when multiple unbondings exist at a single height (e.g. through multiple messages in a transaction).
 
 ### API Breaking Changes
 

x/staking/keeper/delegation_test.go

@@ -273,6 +273,7 @@ func TestUnbondingDelegationsMaxEntries(t *testing.T) {
 	var completionTime time.Time
 	for i := uint32(0); i < maxEntries; i++ {
 		var err error
+		ctx = ctx.WithBlockHeight(int64(i))
 		completionTime, err = app.StakingKeeper.Undelegate(ctx, addrDels[0], addrVals[0], math.LegacyNewDec(1))
 		require.NoError(t, err)
 	}

x/staking/migrations/v4/store.go

@@ -1,6 +1,8 @@
 package v4
 
 import (
+	"sort"
+
 	"github.com/cosmos/cosmos-sdk/codec"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -21,5 +23,58 @@ func MigrateStore(ctx sdk.Context, storeKey storetypes.StoreKey, cdc codec.Binar
 	bz := cdc.MustMarshal(&legacyParams)
 	store.Set(types.ParamsKey, bz)
 
+	// this will remove the ubdEntries with same creation_height
+	// and create a new ubdEntry with updated balance and initial_balance
+
+	iterator := sdk.KVStorePrefixIterator(store, types.UnbondingDelegationKey)
+	defer iterator.Close()
+
+	for ; iterator.Valid(); iterator.Next() {
+		ubd := types.MustUnmarshalUBD(cdc, iterator.Value())
+
+		entriesAtSameCreationHeight := make(map[int64][]types.UnbondingDelegationEntry)
+		for _, ubdEntry := range ubd.Entries {
+			entriesAtSameCreationHeight[ubdEntry.CreationHeight] = append(entriesAtSameCreationHeight[ubdEntry.CreationHeight], ubdEntry)
+		}
+
+		creationHeights := make([]int64, 0, len(entriesAtSameCreationHeight))
+		for k := range entriesAtSameCreationHeight {
+			creationHeights = append(creationHeights, k)
+		}
+
+		sort.Slice(creationHeights, func(i, j int) bool { return creationHeights[i] < creationHeights[j] })
+
+		ubd.Entries = make([]types.UnbondingDelegationEntry, 0, len(creationHeights))
+
+		for _, h := range creationHeights {
+			var ubdEntry types.UnbondingDelegationEntry
+			for _, entry := range entriesAtSameCreationHeight[h] {
+				ubdEntry.Balance = ubdEntry.Balance.Add(entry.Balance)
+				ubdEntry.InitialBalance = ubdEntry.InitialBalance.Add(entry.InitialBalance)
+				ubdEntry.CreationHeight = entry.CreationHeight
+				ubdEntry.CompletionTime = entry.CompletionTime
+			}
+			ubd.Entries = append(ubd.Entries, ubdEntry)
+		}
+
+		// set the new ubd to the store
+		setUBDToStore(ctx, store, cdc, ubd)
+	}
+
 	return nil
 }
+
+func setUBDToStore(ctx sdk.Context, store storetypes.KVStore, cdc codec.BinaryCodec, ubd types.UnbondingDelegation) {
+	delegatorAddress := sdk.MustAccAddressFromBech32(ubd.DelegatorAddress)
+
+	bz := types.MustMarshalUBD(cdc, ubd)
+
+	addr, err := sdk.ValAddressFromBech32(ubd.ValidatorAddress)
+	if err != nil {
+		panic(err)
+	}
+
+	key := types.GetUBDKey(delegatorAddress, addr)
+
+	store.Set(key, bz)
+}

x/staking/types/delegation.go

@@ -130,8 +130,27 @@ func NewUnbondingDelegation(
 
 // AddEntry - append entry to the unbonding delegation
 func (ubd *UnbondingDelegation) AddEntry(creationHeight int64, minTime time.Time, balance math.Int) {
-	entry := NewUnbondingDelegationEntry(creationHeight, minTime, balance)
-	ubd.Entries = append(ubd.Entries, entry)
+	// Check the entries exists with creation_height and complete_time
+	entryIndex := -1
+	for index, ubdEntry := range ubd.Entries {
+		if ubdEntry.CreationHeight == creationHeight && ubdEntry.CompletionTime.Equal(minTime) {
+			entryIndex = index
+			break
+		}
+	}
+	// entryIndex exists
+	if entryIndex != -1 {
+		ubdEntry := ubd.Entries[entryIndex]
+		ubdEntry.Balance = ubdEntry.Balance.Add(balance)
+		ubdEntry.InitialBalance = ubdEntry.InitialBalance.Add(balance)
+
+		// update the entry
+		ubd.Entries[entryIndex] = ubdEntry
+	} else {
+		// append the new unbond delegation entry
+		entry := NewUnbondingDelegationEntry(creationHeight, minTime, balance)
+		ubd.Entries = append(ubd.Entries, entry)
+	}
 }
 
 // RemoveEntry - remove entry at index i to the unbonding delegation