Create Force Unlock Messages

app/apptesting/superfluid.go

@@ -0,0 +1,22 @@
+package apptesting
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+
+	gammtypes "github.com/osmosis-labs/osmosis/v12/x/gamm/types"
+	"github.com/osmosis-labs/osmosis/v12/x/superfluid/types"
+)
+
+func (s *KeeperTestHelper) SuperfluidDelegateToDefaultVal(sender sdk.AccAddress, poolId uint64, lockId uint64) error {
+	valAddr := s.SetupValidator(stakingtypes.Bonded)
+
+	poolDenom := gammtypes.GetPoolShareDenom(poolId)
+	err := s.App.SuperfluidKeeper.AddNewSuperfluidAsset(s.Ctx, types.SuperfluidAsset{
+		Denom:     poolDenom,
+		AssetType: types.SuperfluidAssetTypeLPShare,
+	})
+	s.Require().NoError(err)
+
+	return s.App.SuperfluidKeeper.SuperfluidDelegate(s.Ctx, sender.String(), lockId, valAddr.String())
+}

app/keepers/keepers.go

@@ -255,7 +255,7 @@ func (appKeepers *AppKeepers) InitNormalKeepers(
 		// TODO: Visit why this needs to be deref'd
 		*appKeepers.AccountKeeper,
 		appKeepers.BankKeeper,
-		appKeepers.DistrKeeper)
+		appKeepers.DistrKeeper, appKeepers.GetSubspace(lockuptypes.ModuleName))
 
 	appKeepers.EpochsKeeper = epochskeeper.NewKeeper(appKeepers.keys[epochstypes.StoreKey])
 
@@ -430,6 +430,7 @@ func (appKeepers *AppKeepers) initParamsKeeper(appCodec codec.BinaryCodec, legac
 	paramsKeeper.Subspace(ibchost.ModuleName)
 	paramsKeeper.Subspace(icahosttypes.SubModuleName)
 	paramsKeeper.Subspace(incentivestypes.ModuleName)
+	paramsKeeper.Subspace(lockuptypes.ModuleName)
 	paramsKeeper.Subspace(poolincentivestypes.ModuleName)
 	paramsKeeper.Subspace(superfluidtypes.ModuleName)
 	paramsKeeper.Subspace(gammtypes.ModuleName)

app/upgrades/v13/upgrades.go

@@ -0,0 +1,25 @@
+package v13
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
+	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
+
+	lockuptypes "github.com/osmosis-labs/osmosis/v12/x/lockup/types"
+
+	"github.com/osmosis-labs/osmosis/v12/app/keepers"
+	"github.com/osmosis-labs/osmosis/v12/app/upgrades"
+)
+
+func CreateUpgradeHandler(
+	mm *module.Manager,
+	configurator module.Configurator,
+	bpm upgrades.BaseAppParamManager,
+	keepers *keepers.AppKeepers,
+) upgradetypes.UpgradeHandler {
+	return func(ctx sdk.Context, plan upgradetypes.Plan, fromVM module.VersionMap) (module.VersionMap, error) {
+		keepers.LockupKeeper.SetParams(ctx, lockuptypes.DefaultParams())
+
+		return mm.RunMigrations(ctx, configurator, fromVM)
+	}
+}

proto/osmosis/lockup/params.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+package osmosis.lockup;
+
+import "gogoproto/gogo.proto";
+
+option go_package = "github.com/osmosis-labs/osmosis/v12/x/lockup/types";
+
+message Params {
+  repeated string force_unlock_allowed_addresses = 1
+      [ (gogoproto.moretags) = "yaml:\"force_unlock_allowed_address\"" ];
+}

proto/osmosis/lockup/tx.proto

@@ -19,6 +19,7 @@ service Msg {
   rpc BeginUnlocking(MsgBeginUnlocking) returns (MsgBeginUnlockingResponse);
   // MsgEditLockup edits the existing lockups by lock ID
   rpc ExtendLockup(MsgExtendLockup) returns (MsgExtendLockupResponse);
+  rpc ForceUnlock(MsgForceUnlock) returns (MsgForceUnlockResponse);
 }
 
 message MsgLockTokens {
@@ -71,3 +72,17 @@ message MsgExtendLockup {
 }
 
 message MsgExtendLockupResponse { bool success = 1; }
+
+// MsgForceUnlock unlocks locks immediately for
+// addresses registered via governance.
+message MsgForceUnlock {
+  string owner = 1 [ (gogoproto.moretags) = "yaml:\"owner\"" ];
+  uint64 ID = 2;
+  // Amount of unlocking coins. Unlock all if not set.
+  repeated cosmos.base.v1beta1.Coin coins = 3 [
+    (gogoproto.nullable) = false,
+    (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"
+  ];
+}
+
+message MsgForceUnlockResponse { bool success = 1; }

x/lockup/keeper/keeper.go

@@ -8,6 +8,7 @@ import (
 	"github.com/osmosis-labs/osmosis/v12/x/lockup/types"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 )
 
 // Keeper provides a way to manage module storage.
@@ -16,21 +17,44 @@ type Keeper struct {
 
 	hooks types.LockupHooks
 
+	paramSpace paramtypes.Subspace
+
 	ak types.AccountKeeper
 	bk types.BankKeeper
 	ck types.CommunityPoolKeeper
 }
 
 // NewKeeper returns an instance of Keeper.
-func NewKeeper(storeKey sdk.StoreKey, ak types.AccountKeeper, bk types.BankKeeper, ck types.CommunityPoolKeeper) *Keeper {
+func NewKeeper(storeKey sdk.StoreKey, ak types.AccountKeeper, bk types.BankKeeper, ck types.CommunityPoolKeeper, paramSpace paramtypes.Subspace) *Keeper {
+	// set KeyTable if it has not already been set
+	if !paramSpace.HasKeyTable() {
+		paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable())
+	}
+
 	return &Keeper{
-		storeKey: storeKey,
-		ak:       ak,
-		bk:       bk,
-		ck:       ck,
+		storeKey:   storeKey,
+		paramSpace: paramSpace,
+		ak:         ak,
+		bk:         bk,
+		ck:         ck,
 	}
 }
 
+// GetParams returns the total set of lockup parameters.
+func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) {
+	k.paramSpace.GetParamSet(ctx, &params)
+	return params
+}
+
+// SetParams sets the total set of lockup parameters.
+func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
+	k.paramSpace.SetParamSet(ctx, &params)
+}
+
+func (k Keeper) GetForceUnlockAllowedAddresses(ctx sdk.Context) (forceUnlockAllowedAddresses []string) {
+	return k.GetParams(ctx).ForceUnlockAllowedAddresses
+}
+
 // Logger returns a logger instance.
 func (k Keeper) Logger(ctx sdk.Context) log.Logger {
 	return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))

x/lockup/keeper/keeper_test.go

@@ -22,6 +22,14 @@ type KeeperTestSuite struct {
 func (suite *KeeperTestSuite) SetupTest() {
 	suite.Setup()
 	suite.querier = keeper.NewQuerier(*suite.App.LockupKeeper)
+	unbondingDuration := suite.App.StakingKeeper.GetParams(suite.Ctx).UnbondingTime
+	suite.App.IncentivesKeeper.SetLockableDurations(suite.Ctx, []time.Duration{
+		time.Hour * 24 * 14,
+		time.Hour,
+		time.Hour * 3,
+		time.Hour * 7,
+		unbondingDuration,
+	})
 }
 
 func (suite *KeeperTestSuite) SetupTestWithLevelDb() {

x/lockup/keeper/lock.go

@@ -205,7 +205,7 @@ func (k Keeper) beginUnlock(ctx sdk.Context, lock types.PeriodLock, coins sdk.Co
 	// Otherwise, split the lock into two locks, and fully unlock the newly created lock.
 	// (By virtue, the newly created lock we split into should have the unlock amount)
 	if len(coins) != 0 && !coins.IsEqual(lock.Coins) {
-		splitLock, err := k.splitLock(ctx, lock, coins)
+		splitLock, err := k.splitLock(ctx, lock, coins, false)
 		if err != nil {
 			return err
 		}
@@ -307,6 +307,28 @@ func (k Keeper) UnlockMaturedLock(ctx sdk.Context, lockID uint64) error {
 	return k.unlockMaturedLockInternalLogic(ctx, *lock)
 }
 
+// PartialForceUnlock begins partial ForceUnlock of given lock for the given amount of coins.
+// ForceUnlocks the lock as a whole when provided coins are empty, or coin provided equals amount of coins in the lock.
+// This also supports the case of lock in an unbonding status.
+func (k Keeper) PartialForceUnlock(ctx sdk.Context, lock types.PeriodLock, coins sdk.Coins) error {
+	// sanity check
+	if !coins.IsAllLTE(lock.Coins) {
+		return fmt.Errorf("requested amount to unlock exceeds locked tokens")
+	}
+
+	// split lock to support partial force unlock.
+	// (By virtue, the newly created lock we split into should have the unlock amount)
+	if len(coins) != 0 && !coins.IsEqual(lock.Coins) {
+		splitLock, err := k.splitLock(ctx, lock, coins, true)
+		if err != nil {
+			return err
+		}
+		lock = splitLock
+	}
+
+	return k.ForceUnlock(ctx, lock)
+}
+
 // ForceUnlock ignores unlock duration and immediately unlocks the lock and refunds tokens to lock owner.
 func (k Keeper) ForceUnlock(ctx sdk.Context, lock types.PeriodLock) error {
 	// Steps:
@@ -658,20 +680,24 @@ func (k Keeper) deleteLock(ctx sdk.Context, id uint64) {
 }
 
 // splitLock splits a lock with the given amount, and stores split new lock to the state.
-func (k Keeper) splitLock(ctx sdk.Context, lock types.PeriodLock, coins sdk.Coins) (types.PeriodLock, error) {
-	if lock.IsUnlocking() {
+// Returns the new lock after modifying the state of the old lock.
+func (k Keeper) splitLock(ctx sdk.Context, lock types.PeriodLock, coins sdk.Coins, forceUnlock bool) (types.PeriodLock, error) {
+	if !forceUnlock && lock.IsUnlocking() {
 		return types.PeriodLock{}, fmt.Errorf("cannot split unlocking lock")
 	}
+
 	lock.Coins = lock.Coins.Sub(coins)
 	err := k.setLock(ctx, lock)
 	if err != nil {
 		return types.PeriodLock{}, err
 	}
 
+	// create a new lock
 	splitLockID := k.GetLastLockID(ctx) + 1
 	k.SetLastLockID(ctx, splitLockID)
 
 	splitLock := types.NewPeriodLock(splitLockID, lock.OwnerAddress(), lock.Duration, lock.EndTime, coins)
+
 	err = k.setLock(ctx, splitLock)
 	return splitLock, err
 }

x/lockup/keeper/lock_test.go

@@ -871,3 +871,123 @@ func (suite *KeeperTestSuite) TestEditLockup() {
 	})
 	suite.Require().Equal(int64(0), acc.Int64())
 }
+
+func (suite *KeeperTestSuite) TestForceUnlock() {
+	addr1 := sdk.AccAddress([]byte("addr1---------------"))
+
+	testCases := []struct {
+		name          string
+		postLockSetup func()
+	}{
+		{
+			name: "happy path",
+		},
+		{
+			name: "superfluid staked",
+			postLockSetup: func() {
+				err := suite.App.LockupKeeper.CreateSyntheticLockup(suite.Ctx, 1, "testDenom", time.Minute, true)
+				suite.Require().NoError(err)
+			},
+		},
+	}
+	for _, tc := range testCases {
+		// set up test and create default lock
+		suite.SetupTest()
+		coinsToLock := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10000000)))
+		suite.FundAcc(addr1, sdk.NewCoins(coinsToLock...))
+		lock, err := suite.App.LockupKeeper.CreateLock(suite.Ctx, addr1, coinsToLock, time.Minute)
+		suite.Require().NoError(err)
+
+		// post lock setup
+		if tc.postLockSetup != nil {
+			tc.postLockSetup()
+		}
+
+		err = suite.App.LockupKeeper.ForceUnlock(suite.Ctx, lock)
+		suite.Require().NoError(err)
+
+		// check that accumulation store has decreased
+		accum := suite.App.LockupKeeper.GetPeriodLocksAccumulation(suite.Ctx, types.QueryCondition{
+			LockQueryType: types.ByDuration,
+			Denom:         "foo",
+			Duration:      time.Minute,
+		})
+		suite.Require().Equal(accum.String(), "0")
+
+		// check balance of lock account to confirm
+		balances := suite.App.BankKeeper.GetAllBalances(suite.Ctx, addr1)
+		suite.Require().Equal(balances, coinsToLock)
+
+		// if it was superfluid delegated lock,
+		//  confirm that we don't have associated synth locks
+		synthLocks := suite.App.LockupKeeper.GetAllSyntheticLockupsByLockup(suite.Ctx, lock.ID)
+		suite.Require().Equal(0, len(synthLocks))
+
+		// check if lock is deleted by checking trying to get lock ID
+		_, err = suite.App.LockupKeeper.GetLockByID(suite.Ctx, lock.ID)
+		suite.Require().Error(err)
+	}
+}
+
+func (suite *KeeperTestSuite) TestPartialForceUnlock() {
+	addr1 := sdk.AccAddress([]byte("addr1---------------"))
+
+	defaultDenomToLock := "stake"
+	defaultAmountToLock := sdk.NewInt(10000000)
+
+	testCases := []struct {
+		name               string
+		coinsToForceUnlock sdk.Coins
+		expectedPass       bool
+	}{
+		{
+			name:               "unlock full amount",
+			coinsToForceUnlock: sdk.Coins{sdk.NewCoin(defaultDenomToLock, defaultAmountToLock)},
+			expectedPass:       true,
+		},
+		{
+			name:               "partial unlock",
+			coinsToForceUnlock: sdk.Coins{sdk.NewCoin(defaultDenomToLock, defaultAmountToLock.Quo(sdk.NewInt(2)))},
+			expectedPass:       true,
+		},
+		{
+			name:               "unlock more than locked",
+			coinsToForceUnlock: sdk.Coins{sdk.NewCoin(defaultDenomToLock, defaultAmountToLock.Add(sdk.NewInt(2)))},
+			expectedPass:       false,
+		},
+		{
+			name:               "try unlocking with empty coins",
+			coinsToForceUnlock: sdk.Coins{},
+			expectedPass:       true,
+		},
+	}
+	for _, tc := range testCases {
+		// set up test and create default lock
+		suite.SetupTest()
+		coinsToLock := sdk.NewCoins(sdk.NewCoin("stake", defaultAmountToLock))
+		suite.FundAcc(addr1, sdk.NewCoins(coinsToLock...))
+		// balanceBeforeLock := suite.App.BankKeeper.GetAllBalances(suite.Ctx, addr1)
+		lock, err := suite.App.LockupKeeper.CreateLock(suite.Ctx, addr1, coinsToLock, time.Minute)
+		suite.Require().NoError(err)
+
+		err = suite.App.LockupKeeper.PartialForceUnlock(suite.Ctx, lock, tc.coinsToForceUnlock)
+
+		if tc.expectedPass {
+			suite.Require().NoError(err)
+
+			// check balance
+			balanceAfterForceUnlock := suite.App.BankKeeper.GetBalance(suite.Ctx, addr1, "stake")
+
+			if tc.coinsToForceUnlock.Empty() {
+				tc.coinsToForceUnlock = coinsToLock
+			}
+			suite.Require().Equal(tc.coinsToForceUnlock, sdk.Coins{balanceAfterForceUnlock})
+		} else {
+			suite.Require().Error(err)
+
+			// check balance
+			balanceAfterForceUnlock := suite.App.BankKeeper.GetBalance(suite.Ctx, addr1, "stake")
+			suite.Require().Equal(sdk.NewInt(0), balanceAfterForceUnlock.Amount)
+		}
+	}
+}