fix(x/accounts/default/lockup): Lockup account track undelegation when unbonding entry is mature

tests/integration/accounts/lockup/continous_lockup_test_suite.go

@@ -23,6 +23,7 @@ func (s *IntegrationTestSuite) TestContinuousLockingAccount() {
 	ctx := sdk.NewContext(app.CommitMultiStore(), false, app.Logger()).WithHeaderInfo(header.Info{
 		Time: currentTime,
 	})
+	s.setupStakingParams(ctx, app)
 	ownerAddrStr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
 	require.NoError(t, err)
 	s.fundAccount(app, ctx, accOwner, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000000))})
@@ -163,17 +164,22 @@ func (s *IntegrationTestSuite) TestContinuousLockingAccount() {
 		require.NoError(t, err)
 		require.Equal(t, len(ubd.Entries), 1)
 
-		// check if tracking is updated accordingly
-		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
-		delLocking := lockupAccountInfoResponse.DelegatedLocking
-		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
+		// check if an entry is added
+		unbondingEntriesResponse := s.queryUnbondingEntries(ctx, app, accountAddr, val.OperatorAddress)
+		entries := unbondingEntriesResponse.UnbondingEntries
+		require.True(t, entries[0].Amount.Amount.Equal(math.NewInt(100)))
+		require.True(t, entries[0].ValidatorAddress == val.OperatorAddress)
 	})
 
 	// Update context time to end time
 	ctx = ctx.WithHeaderInfo(header.Info{
 		Time: currentTime.Add(time.Minute),
 	})
 
+	// trigger endblock for staking to handle matured unbonding delegation
+	_, err = app.StakingKeeper.EndBlocker(ctx)
+	require.NoError(t, err)
+
 	// test if tracking delegate work perfectly
 	t.Run("ok - execute delegate message", func(t *testing.T) {
 		msg := &types.MsgDelegate{
@@ -196,8 +202,14 @@ func (s *IntegrationTestSuite) TestContinuousLockingAccount() {
 		// check if tracking is updated accordingly
 		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
 		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		// should be update as ubd entry is matured
 		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
 		delFree := lockupAccountInfoResponse.DelegatedFree
 		require.True(t, delFree.AmountOf("stake").Equal(math.NewInt(100)))
+
+		// check if the entry is removed
+		unbondingEntriesResponse := s.queryUnbondingEntries(ctx, app, accountAddr, val.OperatorAddress)
+		entries := unbondingEntriesResponse.UnbondingEntries
+		require.Len(t, entries, 0)
 	})
 }

tests/integration/accounts/lockup/delayed_lockup_test_suite.go

@@ -23,6 +23,7 @@ func (s *IntegrationTestSuite) TestDelayedLockingAccount() {
 	ctx := sdk.NewContext(app.CommitMultiStore(), false, app.Logger()).WithHeaderInfo(header.Info{
 		Time: currentTime,
 	})
+	s.setupStakingParams(ctx, app)
 	ownerAddrStr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
 	require.NoError(t, err)
 	s.fundAccount(app, ctx, accOwner, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000000))})
@@ -125,18 +126,24 @@ func (s *IntegrationTestSuite) TestDelayedLockingAccount() {
 		require.NoError(t, err)
 		require.Equal(t, len(ubd.Entries), 1)
 
-		// check if tracking is updated accordingly
-		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
-		delLocking := lockupAccountInfoResponse.DelegatedLocking
-		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
+		// check if an entry is added
+		unbondingEntriesResponse := s.queryUnbondingEntries(ctx, app, accountAddr, val.OperatorAddress)
+		entries := unbondingEntriesResponse.UnbondingEntries
+		require.True(t, entries[0].Amount.Amount.Equal(math.NewInt(100)))
+		require.True(t, entries[0].ValidatorAddress == val.OperatorAddress)
 	})
 
 	// Update context time
 	// After endtime fund should be unlock
+	// And unbond time elapsed
 	ctx = ctx.WithHeaderInfo(header.Info{
 		Time: currentTime.Add(time.Second * 61),
 	})
 
+	// trigger endblock for staking to handle matured unbonding delegation
+	_, err = app.StakingKeeper.EndBlocker(ctx)
+	require.NoError(t, err)
+
 	// Check if token is sendable after unlock
 	t.Run("ok - execute send message", func(t *testing.T) {
 		msg := &types.MsgSend{
@@ -149,6 +156,16 @@ func (s *IntegrationTestSuite) TestDelayedLockingAccount() {
 
 		balance := app.BankKeeper.GetBalance(ctx, randAcc, "stake")
 		require.True(t, balance.Amount.Equal(math.NewInt(100)))
+
+		// check if tracking ubd entry is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
+
+		// check if the entry is removed
+		unbondingEntriesResponse := s.queryUnbondingEntries(ctx, app, accountAddr, val.OperatorAddress)
+		entries := unbondingEntriesResponse.UnbondingEntries
+		require.Len(t, entries, 0)
 	})
 	// Test to withdraw all the remain funds to an account of choice
 	t.Run("ok - execute withdraw message", func(t *testing.T) {
@@ -165,8 +182,8 @@ func (s *IntegrationTestSuite) TestDelayedLockingAccount() {
 		require.NoError(t, err)
 
 		// withdrawable amount should be
-		// 1000stake - 100stake( above sent amt ) - 100stake(above delegate amt) = 800stake
+		// 1000stake - 100stake( above sent amt ) = 800stake
 		balance := app.BankKeeper.GetBalance(ctx, withdrawAcc, "stake")
-		require.True(t, balance.Amount.Equal(math.NewInt(800)))
+		require.True(t, balance.Amount.Equal(math.NewInt(900)))
 	})
 }

tests/integration/accounts/lockup/periodic_lockup_test_suite.go

@@ -23,6 +23,7 @@ func (s *IntegrationTestSuite) TestPeriodicLockingAccount() {
 	ctx := sdk.NewContext(app.CommitMultiStore(), false, app.Logger()).WithHeaderInfo(header.Info{
 		Time: currentTime,
 	})
+	s.setupStakingParams(ctx, app)
 	ownerAddrStr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
 	require.NoError(t, err)
 	s.fundAccount(app, ctx, accOwner, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000000))})
@@ -185,10 +186,11 @@ func (s *IntegrationTestSuite) TestPeriodicLockingAccount() {
 		require.NoError(t, err)
 		require.Equal(t, len(ubd.Entries), 1)
 
-		// check if tracking is updated accordingly
-		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
-		delLocking := lockupAccountInfoResponse.DelegatedLocking
-		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
+		// check if an entry is added
+		unbondingEntriesResponse := s.queryUnbondingEntries(ctx, app, accountAddr, val.OperatorAddress)
+		entries := unbondingEntriesResponse.UnbondingEntries
+		require.True(t, entries[0].Amount.Amount.Equal(math.NewInt(100)))
+		require.True(t, entries[0].ValidatorAddress == val.OperatorAddress)
 	})
 
 	// Update context time
@@ -197,6 +199,10 @@ func (s *IntegrationTestSuite) TestPeriodicLockingAccount() {
 		Time: currentTime.Add(time.Minute * 3),
 	})
 
+	// trigger endblock for staking to handle matured unbonding delegation
+	_, err = app.StakingKeeper.EndBlocker(ctx)
+	require.NoError(t, err)
+
 	t.Run("ok - execute delegate message", func(t *testing.T) {
 		msg := &types.MsgDelegate{
 			Sender:           ownerAddrStr,
@@ -217,7 +223,15 @@ func (s *IntegrationTestSuite) TestPeriodicLockingAccount() {
 
 		// check if tracking is updated accordingly
 		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		// check if matured ubd entry cleared
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
 		delFree := lockupAccountInfoResponse.DelegatedFree
 		require.True(t, delFree.AmountOf("stake").Equal(math.NewInt(100)))
+
+		// check if the entry is removed
+		unbondingEntriesResponse := s.queryUnbondingEntries(ctx, app, accountAddr, val.OperatorAddress)
+		entries := unbondingEntriesResponse.UnbondingEntries
+		require.Len(t, entries, 0)
 	})
 }

tests/integration/accounts/lockup/permanent_lockup_test_suite.go

@@ -23,6 +23,7 @@ func (s *IntegrationTestSuite) TestPermanentLockingAccount() {
 	ctx := sdk.NewContext(app.CommitMultiStore(), false, app.Logger()).WithHeaderInfo(header.Info{
 		Time: currentTime,
 	})
+	s.setupStakingParams(ctx, app)
 	ownerAddrStr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
 	require.NoError(t, err)
 	s.fundAccount(app, ctx, accOwner, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000000))})
@@ -109,10 +110,11 @@ func (s *IntegrationTestSuite) TestPermanentLockingAccount() {
 		require.NoError(t, err)
 		require.Equal(t, len(ubd.Entries), 1)
 
-		// check if tracking is updated accordingly
-		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
-		delLocking := lockupAccountInfoResponse.DelegatedLocking
-		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
+		// check if an entry is added
+		unbondingEntriesResponse := s.queryUnbondingEntries(ctx, app, accountAddr, val.OperatorAddress)
+		entries := unbondingEntriesResponse.UnbondingEntries
+		require.True(t, entries[0].Amount.Amount.Equal(math.NewInt(100)))
+		require.True(t, entries[0].ValidatorAddress == val.OperatorAddress)
 	})
 
 	s.fundAccount(app, ctx, accountAddr, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000))})
@@ -129,4 +131,43 @@ func (s *IntegrationTestSuite) TestPermanentLockingAccount() {
 		balance := app.BankKeeper.GetBalance(ctx, randAcc, "stake")
 		require.True(t, balance.Amount.Equal(math.NewInt(100)))
 	})
+
+	// Update context time
+	ctx = ctx.WithHeaderInfo(header.Info{
+		Time: currentTime.Add(time.Second * 11),
+	})
+
+	// trigger endblock for staking to handle matured unbonding delegation
+	_, err = app.StakingKeeper.EndBlocker(ctx)
+	require.NoError(t, err)
+
+	t.Run("ok - execute delegate message", func(t *testing.T) {
+		msg := &types.MsgDelegate{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+			Amount:           sdk.NewCoin("stake", math.NewInt(10)),
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		valbz, err := app.StakingKeeper.ValidatorAddressCodec().StringToBytes(val.OperatorAddress)
+		require.NoError(t, err)
+
+		del, err := app.StakingKeeper.Delegations.Get(
+			ctx, collections.Join(sdk.AccAddress(accountAddr), sdk.ValAddress(valbz)),
+		)
+		require.NoError(t, err)
+		require.NotNil(t, del)
+
+		// check if tracking is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		// matured ubd entry should be cleared so del locking should only be 10
+		require.True(t, delLocking.AmountOf("stake").Equal(math.NewInt(10)))
+
+		// check if the entry is removed
+		unbondingEntriesResponse := s.queryUnbondingEntries(ctx, app, accountAddr, val.OperatorAddress)
+		entries := unbondingEntriesResponse.UnbondingEntries
+		require.Len(t, entries, 0)
+	})
 }

tests/integration/accounts/lockup/utils.go

@@ -2,6 +2,7 @@ package lockup
 
 import (
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
@@ -70,3 +71,27 @@ func (s *IntegrationTestSuite) queryLockupAccInfo(ctx sdk.Context, app *simapp.S
 
 	return lockupAccountInfoResponse
 }
+
+func (s *IntegrationTestSuite) queryUnbondingEntries(ctx sdk.Context, app *simapp.SimApp, accAddr []byte, valAddr string) *types.QueryUnbondingEntriesResponse {
+	req := &types.QueryUnbondingEntriesRequest{
+		ValidatorAddress: valAddr,
+	}
+	resp, err := s.queryAcc(ctx, req, app, accAddr)
+	require.NoError(s.T(), err)
+	require.NotNil(s.T(), resp)
+
+	unbondingEntriesResponse, ok := resp.(*types.QueryUnbondingEntriesResponse)
+	require.True(s.T(), ok)
+
+	return unbondingEntriesResponse
+}
+
+func (s *IntegrationTestSuite) setupStakingParams(ctx sdk.Context, app *simapp.SimApp) {
+	params, err := app.StakingKeeper.Params.Get(ctx)
+	require.NoError(s.T(), err)
+
+	// update unbonding time
+	params.UnbondingTime = time.Duration(time.Second * 10)
+	err = app.StakingKeeper.Params.Set(ctx, params)
+	require.NoError(s.T(), err)
+}

x/accounts/defaults/lockup/continuous_locking_account.go

@@ -200,4 +200,5 @@ func (cva ContinuousLockingAccount) RegisterExecuteHandlers(builder *accountstd.
 
 func (cva ContinuousLockingAccount) RegisterQueryHandlers(builder *accountstd.QueryBuilder) {
 	accountstd.RegisterQueryHandler(builder, cva.QueryLockupAccountInfo)
+	cva.BaseLockup.RegisterQueryHandlers(builder)
 }

x/accounts/defaults/lockup/continuous_locking_account_test.go

@@ -102,48 +102,21 @@ func TestContinousAccountUndelegate(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	delLocking, err = acc.DelegatedLocking.Get(ctx, "test")
-	require.NoError(t, err)
-	require.True(t, delLocking.Equal(math.ZeroInt()))
-
-	startTime, err := acc.StartTime.Get(sdkCtx)
-	require.NoError(t, err)
-
-	// Update context time to unlocked half of the original locking amount
-	sdkCtx = sdkCtx.WithHeaderInfo(header.Info{
-		Time: startTime.Add(time.Minute * 1),
-	})
-
-	_, err = acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{
-		Sender:           "owner",
-		ValidatorAddress: "val_address",
-		Amount:           sdk.NewCoin("test", math.NewInt(6)),
-	})
+	entries, err := acc.UnbondEntries.Get(sdkCtx, "val_address")
 	require.NoError(t, err)
+	require.Len(t, entries.Entries, 1)
+	require.True(t, entries.Entries[0].Amount.Amount.Equal(math.NewInt(1)))
+	require.True(t, entries.Entries[0].ValidatorAddress == "val_address")
 
-	delLocking, err = acc.DelegatedLocking.Get(ctx, "test")
-	require.NoError(t, err)
-	require.True(t, delLocking.Equal(math.NewInt(5)))
-
-	delFree, err := acc.DelegatedFree.Get(ctx, "test")
+	err = acc.CheckUbdEntriesMature(sdkCtx)
 	require.NoError(t, err)
-	require.True(t, delFree.Equal(math.NewInt(1)))
 
-	// Undelegate
-	_, err = acc.Undelegate(sdkCtx, &lockuptypes.MsgUndelegate{
-		Sender:           "owner",
-		ValidatorAddress: "val_address",
-		Amount:           sdk.NewCoin("test", math.NewInt(4)),
-	})
-	require.NoError(t, err)
+	_, err = acc.UnbondEntries.Get(sdkCtx, "val_address")
+	require.Error(t, err)
 
 	delLocking, err = acc.DelegatedLocking.Get(ctx, "test")
 	require.NoError(t, err)
-	require.True(t, delLocking.Equal(math.NewInt(2)))
-
-	delFree, err = acc.DelegatedFree.Get(ctx, "test")
-	require.NoError(t, err)
-	require.True(t, delFree.Equal(math.ZeroInt()))
+	require.True(t, delLocking.Equal(math.ZeroInt()))
 }
 
 func TestContinousAccountSendCoins(t *testing.T) {

x/accounts/defaults/lockup/delayed_locking_account.go

@@ -149,4 +149,5 @@ func (dva DelayedLockingAccount) RegisterExecuteHandlers(builder *accountstd.Exe
 
 func (dva DelayedLockingAccount) RegisterQueryHandlers(builder *accountstd.QueryBuilder) {
 	accountstd.RegisterQueryHandler(builder, dva.QueryVestingAccountInfo)
+	dva.BaseLockup.RegisterQueryHandlers(builder)
 }

x/accounts/defaults/lockup/delayed_locking_account_test.go

@@ -101,44 +101,21 @@ func TestDelayedAccountUndelegate(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	delLocking, err = acc.DelegatedLocking.Get(ctx, "test")
+	entries, err := acc.UnbondEntries.Get(sdkCtx, "val_address")
 	require.NoError(t, err)
-	require.True(t, delLocking.Equal(math.ZeroInt()))
+	require.Len(t, entries.Entries, 1)
+	require.True(t, entries.Entries[0].Amount.Amount.Equal(math.NewInt(1)))
+	require.True(t, entries.Entries[0].ValidatorAddress == "val_address")
 
-	endTime, err := acc.EndTime.Get(sdkCtx)
+	err = acc.CheckUbdEntriesMature(sdkCtx)
 	require.NoError(t, err)
 
-	// Update context time to unlocked all the original locking amount
-	sdkCtx = sdkCtx.WithHeaderInfo(header.Info{
-		Time: endTime.Add(time.Second),
-	})
-
-	_, err = acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{
-		Sender:           "owner",
-		ValidatorAddress: "val_address",
-		Amount:           sdk.NewCoin("test", math.NewInt(6)),
-	})
-	require.NoError(t, err)
+	_, err = acc.UnbondEntries.Get(sdkCtx, "val_address")
+	require.Error(t, err)
 
 	delLocking, err = acc.DelegatedLocking.Get(ctx, "test")
 	require.NoError(t, err)
 	require.True(t, delLocking.Equal(math.ZeroInt()))
-
-	delFree, err := acc.DelegatedFree.Get(ctx, "test")
-	require.NoError(t, err)
-	require.True(t, delFree.Equal(math.NewInt(6)))
-
-	// Undelegate
-	_, err = acc.Undelegate(sdkCtx, &lockuptypes.MsgUndelegate{
-		Sender:           "owner",
-		ValidatorAddress: "val_address",
-		Amount:           sdk.NewCoin("test", math.NewInt(4)),
-	})
-	require.NoError(t, err)
-
-	delFree, err = acc.DelegatedFree.Get(ctx, "test")
-	require.NoError(t, err)
-	require.True(t, delFree.Equal(math.NewInt(2)))
 }
 
 func TestDelayedAccountSendCoins(t *testing.T) {