[Commitment]: Skip funds locked

x/amm/keeper/apply_exit_pool_state_change.go

@@ -6,12 +6,12 @@ import (
 	"github.com/elys-network/elys/x/amm/types"
 )
 
-func (k Keeper) ApplyExitPoolStateChange(ctx sdk.Context, pool types.Pool, exiter sdk.AccAddress, numShares math.Int, exitCoins sdk.Coins) (sdk.Coins, error) {
+func (k Keeper) ApplyExitPoolStateChange(ctx sdk.Context, pool types.Pool, exiter sdk.AccAddress, numShares math.Int, exitCoins sdk.Coins, isLiquidation bool) (sdk.Coins, error) {
 	// Withdraw exit amount of token from commitment module to exiter's wallet.
 	poolShareDenom := types.GetPoolShareDenom(pool.GetPoolId())
 
 	// Withdraw committed LP tokens
-	err := k.commitmentKeeper.UncommitTokens(ctx, exiter, poolShareDenom, numShares)
+	err := k.commitmentKeeper.UncommitTokens(ctx, exiter, poolShareDenom, numShares, isLiquidation)
 	if err != nil {
 		return sdk.Coins{}, err
 	}

x/amm/keeper/apply_exit_pool_state_change_test.go

@@ -75,6 +75,6 @@ func (suite *KeeperTestSuite) TestApplyExitPoolStateChange_WithdrawFromCommitmen
 	suite.Require().True(lpTokenBalance.Amount.Equal(sdk.ZeroInt()))
 
 	ctx = ctx.WithBlockTime(ctx.BlockTime().Add(time.Hour))
-	_, err = app.AmmKeeper.ApplyExitPoolStateChange(ctx, pool, addrs[0], pool.TotalShares.Amount, coins)
+	_, err = app.AmmKeeper.ApplyExitPoolStateChange(ctx, pool, addrs[0], pool.TotalShares.Amount, coins, false)
 	suite.Require().NoError(err)
 }

x/amm/keeper/keeper_exit_pool.go

@@ -14,6 +14,7 @@ func (k Keeper) ExitPool(
 	shareInAmount math.Int,
 	tokenOutMins sdk.Coins,
 	tokenOutDenom string,
+	isLiquidation bool,
 ) (exitCoins, exitCoinsAfterExitFee sdk.Coins, err error) {
 	pool, poolExists := k.GetPool(ctx, poolId)
 	if !poolExists {
@@ -36,7 +37,7 @@ func (k Keeper) ExitPool(
 			exitCoins, tokenOutMins)
 	}
 
-	exitCoinsAfterExitFee, err = k.ApplyExitPoolStateChange(ctx, pool, sender, shareInAmount, exitCoins)
+	exitCoinsAfterExitFee, err = k.ApplyExitPoolStateChange(ctx, pool, sender, shareInAmount, exitCoins, isLiquidation)
 	if err != nil {
 		return sdk.Coins{}, sdk.Coins{}, err
 	}

x/amm/keeper/msg_server_exit_pool.go

@@ -15,7 +15,7 @@ func (k msgServer) ExitPool(goCtx context.Context, msg *types.MsgExitPool) (*typ
 		return nil, err
 	}
 
-	exitCoins, _, err := k.Keeper.ExitPool(ctx, sender, msg.PoolId, msg.ShareAmountIn, msg.MinAmountsOut, msg.TokenOutDenom)
+	exitCoins, _, err := k.Keeper.ExitPool(ctx, sender, msg.PoolId, msg.ShareAmountIn, msg.MinAmountsOut, msg.TokenOutDenom, false)
 	if err != nil {
 		return nil, err
 	}

x/commitment/keeper/commitments.go

@@ -181,7 +181,7 @@
 	}
 
 	// Subtract the amount from the committed balance
-	err = commitments.DeductFromCommitted(denom, amount, uint64(ctx.BlockTime().Unix()))
+	err = commitments.DeductFromCommitted(denom, amount, uint64(ctx.BlockTime().Unix()), false)
 	if err != nil {
 		return err
 	}

x/commitment/keeper/msg_server_uncommit_tokens.go

@@ -12,7 +12,7 @@
 	ptypes "github.com/elys-network/elys/x/parameter/types"
 )
 
-func (k Keeper) UncommitTokens(ctx sdk.Context, addr sdk.AccAddress, denom string, amount math.Int) error {
+func (k Keeper) UncommitTokens(ctx sdk.Context, addr sdk.AccAddress, denom string, amount math.Int, isLiquidation bool) error {
 	assetProfile, found := k.assetProfileKeeper.GetEntry(ctx, denom)
 	if !found {
 		return errorsmod.Wrapf(assetprofiletypes.ErrAssetProfileNotFound, "denom: %s", denom)
@@ -40,7 +40,7 @@
 	}
 
 	// Deduct from committed tokens
-	err := commitments.DeductFromCommitted(denom, amount, uint64(ctx.BlockTime().Unix()))
+	err := commitments.DeductFromCommitted(denom, amount, uint64(ctx.BlockTime().Unix()), isLiquidation)
 	if err != nil {
 		return err
 	}
@@ -107,7 +107,7 @@
 		return nil, types.ErrUnsupportedUncommitToken
 	}
 
-	err = k.Keeper.UncommitTokens(ctx, addr, msg.Denom, msg.Amount)
+	err = k.Keeper.UncommitTokens(ctx, addr, msg.Denom, msg.Amount, false)
 	if err != nil {
 		return nil, err
 	}

x/commitment/keeper/msg_server_uncommit_tokens_test.go

@@ -51,7 +51,7 @@ func TestUncommitTokens(t *testing.T) {
 	require.NoError(t, err)
 
 	// Call the UncommitTokens function
-	err = keeper.UncommitTokens(ctx, addr[0], denom, uncommitAmount)
+	err = keeper.UncommitTokens(ctx, addr[0], denom, uncommitAmount, false)
 	require.NoError(t, err)
 
 	// Check if the committed tokens have been added to the store

x/commitment/types/commitments.go

@@ -81,7 +81,7 @@ func (c Commitments) CommittedTokensLocked(ctx sdk.Context) (sdk.Coins, sdk.Coin
 	return totalLocked, totalCommitted
 }
 
-func (c *Commitments) DeductFromCommitted(denom string, amount math.Int, currTime uint64) error {
+func (c *Commitments) DeductFromCommitted(denom string, amount math.Int, currTime uint64, isLiquidation bool) error {
 	for i, token := range c.CommittedTokens {
 		if token.Denom == denom {
 			c.CommittedTokens[i].Amount = token.Amount.Sub(amount)
@@ -92,7 +92,7 @@ func (c *Commitments) DeductFromCommitted(denom string, amount math.Int, currTim
 			newLockups := []Lockup{}
 			lockedAmount := sdk.ZeroInt()
 			for _, lockup := range token.Lockups {
-				if lockup.UnlockTimestamp > currTime {
+				if lockup.UnlockTimestamp > currTime && !isLiquidation {
 					newLockups = append(newLockups, lockup)
 					lockedAmount = lockedAmount.Add(lockup.Amount)
 				}

x/commitment/types/commitments_test.go

@@ -48,13 +48,13 @@ func TestCommitments_WithdrawCommitedTokens(t *testing.T) {
 	commitments.AddCommittedTokens("lp/1", sdk.NewInt(100), 200)
 	commitments.AddCommittedTokens("lp/2", sdk.NewInt(100), 100)
 
-	err := commitments.DeductFromCommitted("lp/1", sdk.NewInt(100), 100)
+	err := commitments.DeductFromCommitted("lp/1", sdk.NewInt(100), 100, false)
 	require.NoError(t, err)
 
-	err = commitments.DeductFromCommitted("lp/1", sdk.NewInt(100), 100)
+	err = commitments.DeductFromCommitted("lp/1", sdk.NewInt(100), 100, false)
 	require.Error(t, err)
 
-	err = commitments.DeductFromCommitted("lp/2", sdk.NewInt(200), 100)
+	err = commitments.DeductFromCommitted("lp/2", sdk.NewInt(200), 100, false)
 	require.Error(t, err)
 }
 
@@ -69,6 +69,6 @@ func TestLockupAmount_WithdrawCommited(t *testing.T) {
 	commitments.AddCommittedTokens("lp/1", sdk.NewInt(5000), 2)
 	commitments.AddCommittedTokens("lp/1", sdk.NewInt(3000), 4)
 
-	err := commitments.DeductFromCommitted("lp/1", sdk.NewInt(9000), 3)
+	err := commitments.DeductFromCommitted("lp/1", sdk.NewInt(9000), 3, false)
 	require.Error(t, err)
 }

x/leveragelp/keeper/begin_blocker.go

@@ -85,7 +85,7 @@ func (k Keeper) CheckAndLiquidateUnhealthyPosition(ctx sdk.Context, position *ty
 		return true, false, h, fmt.Errorf("position is healthy to close")
 	}
 
-	repayAmount, err := k.ForceCloseLong(ctx, *position, pool, position.LeveragedLpAmount)
+	repayAmount, err := k.ForceCloseLong(ctx, *position, pool, position.LeveragedLpAmount, true)
 	if err != nil {
 		ctx.Logger().Debug(errors.Wrap(err, "error executing liquidation").Error())
 		return isHealthy, true, h, err
@@ -127,7 +127,7 @@ func (k Keeper) CheckAndCloseAtStopLoss(ctx sdk.Context, position *types.Positio
 		return underStopLossPrice, false, fmt.Errorf("position stop loss price is not <= lp token price")
 	}
 
-	repayAmount, err := k.ForceCloseLong(ctx, *position, pool, position.LeveragedLpAmount)
+	repayAmount, err := k.ForceCloseLong(ctx, *position, pool, position.LeveragedLpAmount, false)
 	if err != nil {
 		ctx.Logger().Error(errors.Wrap(err, "error executing close for stopLossPrice").Error())
 		return underStopLossPrice, true, err

x/leveragelp/keeper/begin_blocker_test.go

@@ -241,17 +241,17 @@ func (suite *KeeperTestSuite) TestCheckAndLiquidateUnhealthyPosition() {
 			},
 		},
 		{
-			"closing position before 1 hour",
-			true,
-			"funds will be locked for 1 hour",
+			"success", // liquidating position before lockup period should be successful
+			false,
+			"",
 			func() *types.Position {
 				suite.ResetSuite()
 				suite.SetupCoinPrices(suite.ctx)
 				initializeForOpen(suite, addresses, asset1, asset2)
 				openMsg := types.MsgOpen{
 					Creator:          addresses[1].String(),
 					CollateralAsset:  "uusdc",
-					CollateralAmount: sdk.NewInt(1000_000_000),
+					CollateralAmount: sdk.NewInt(1000_000),
 					AmmPoolId:        1,
 					Leverage:         leverage,
 					StopLossPrice:    sdk.NewDec(2),

x/leveragelp/keeper/position_close.go

@@ -7,13 +7,13 @@ import (
 	"github.com/elys-network/elys/x/leveragelp/types"
 )
 
-func (k Keeper) ForceCloseLong(ctx sdk.Context, position types.Position, pool types.Pool, lpAmount math.Int) (math.Int, error) {
+func (k Keeper) ForceCloseLong(ctx sdk.Context, position types.Position, pool types.Pool, lpAmount math.Int, isLiquidation bool) (math.Int, error) {
 	if lpAmount.GT(position.LeveragedLpAmount) || lpAmount.IsNegative() {
 		return sdk.ZeroInt(), types.ErrInvalidCloseSize
 	}
 
 	// Exit liquidity with collateral token
-	_, exitCoinsAfterExitFee, err := k.amm.ExitPool(ctx, position.GetPositionAddress(), position.AmmPoolId, lpAmount, sdk.Coins{}, position.Collateral.Denom)
+	_, exitCoinsAfterExitFee, err := k.amm.ExitPool(ctx, position.GetPositionAddress(), position.AmmPoolId, lpAmount, sdk.Coins{}, position.Collateral.Denom, isLiquidation)
 	if err != nil {
 		return sdk.ZeroInt(), err
 	}
@@ -117,6 +117,6 @@ func (k Keeper) CloseLong(ctx sdk.Context, msg *types.MsgClose) (*types.Position
 		lpAmount = position.LeveragedLpAmount
 	}
 
-	repayAmount, err := k.ForceCloseLong(ctx, position, pool, lpAmount)
+	repayAmount, err := k.ForceCloseLong(ctx, position, pool, lpAmount, false)
 	return &position, repayAmount, err
 }

x/leveragelp/keeper/position_close_test.go

@@ -130,7 +130,7 @@ func (suite KeeperTestSuite) TestForceCloseLong() {
 		Quo(sdk.NewDec(86400 * 365))).RoundInt()
 
 	suite.ctx = suite.ctx.WithBlockTime(suite.ctx.BlockTime().Add(time.Hour))
-	repayAmountOut, err := k.ForceCloseLong(suite.ctx, *position, pool, position.LeveragedLpAmount)
+	repayAmountOut, err := k.ForceCloseLong(suite.ctx, *position, pool, position.LeveragedLpAmount, false)
 	suite.Require().NoError(err)
 	suite.Require().Equal(repayAmount.String(), repayAmountOut.String())
 }
@@ -148,7 +148,7 @@ func (suite KeeperTestSuite) TestForceCloseLongWithNoFullRepayment() {
 		Quo(sdk.NewDec(86400 * 365))).RoundInt()
 
 	suite.ctx = suite.ctx.WithBlockTime(suite.ctx.BlockTime().Add(time.Hour * 24 * 365 * 5))
-	repayAmountOut, err := k.ForceCloseLong(suite.ctx, *position, pool, position.LeveragedLpAmount)
+	repayAmountOut, err := k.ForceCloseLong(suite.ctx, *position, pool, position.LeveragedLpAmount, false)
 	suite.Require().NoError(err)
 	suite.Require().Greater(repayAmount.String(), repayAmountOut.String())
 }
@@ -166,7 +166,7 @@ func (suite KeeperTestSuite) TestForceCloseLongPartial() {
 		Quo(sdk.NewDec(86400 * 365))).RoundInt()
 	suite.ctx = suite.ctx.WithBlockTime(suite.ctx.BlockTime().Add(time.Hour))
 	// close 50%
-	repayAmountOut, err := k.ForceCloseLong(suite.ctx, *position, pool, position.LeveragedLpAmount.Quo(sdk.NewInt(2)))
+	repayAmountOut, err := k.ForceCloseLong(suite.ctx, *position, pool, position.LeveragedLpAmount.Quo(sdk.NewInt(2)), false)
 	suite.Require().NoError(err)
 	suite.Require().Equal(repayAmount.Quo(sdk.NewInt(2)).String(), repayAmountOut.String())
 }

x/leveragelp/types/expected_keepers.go

@@ -31,7 +31,7 @@ type AmmKeeper interface {
 	CalcOutAmtGivenIn(ctx sdk.Context, poolId uint64, oracle ammtypes.OracleKeeper, snapshot *ammtypes.Pool, tokensIn sdk.Coins, tokenOutDenom string, swapFee sdk.Dec) (sdk.Coin, sdk.Dec, error)
 	CalcInAmtGivenOut(ctx sdk.Context, poolId uint64, oracle ammtypes.OracleKeeper, snapshot *ammtypes.Pool, tokensOut sdk.Coins, tokenInDenom string, swapFee sdk.Dec) (tokenIn sdk.Coin, slippage sdk.Dec, err error)
 	JoinPoolNoSwap(ctx sdk.Context, sender sdk.AccAddress, poolId uint64, shareOutAmount math.Int, tokenInMaxs sdk.Coins) (tokenIn sdk.Coins, sharesOut math.Int, err error)
-	ExitPool(ctx sdk.Context, sender sdk.AccAddress, poolId uint64, shareInAmount math.Int, tokenOutMins sdk.Coins, tokenOutDenom string) (exitCoins, exitCoinsAfterExitFee sdk.Coins, err error)
+	ExitPool(ctx sdk.Context, sender sdk.AccAddress, poolId uint64, shareInAmount math.Int, tokenOutMins sdk.Coins, tokenOutDenom string, isLiquidation bool) (exitCoins, exitCoinsAfterExitFee sdk.Coins, err error)
 }
 
 // BankKeeper defines the expected interface needed to retrieve account balances.

x/masterchef/keeper/hooks_masterchef_test.go

@@ -169,7 +169,7 @@ func TestHookMasterchef(t *testing.T) {
 	// check length of pools
 	require.Equal(t, len(pools), 1)
 
-	_, _, err = amm.ExitPool(ctx, addr[0], pools[0].PoolId, math.NewIntWithDecimal(1, 21), sdk.NewCoins(), "")
+	_, _, err = amm.ExitPool(ctx, addr[0], pools[0].PoolId, math.NewIntWithDecimal(1, 21), sdk.NewCoins(), "", false)
 	require.NoError(t, err)
 
 	// new user join pool with same shares
@@ -255,7 +255,7 @@ func TestHookMasterchef(t *testing.T) {
 	require.Len(t, res.TotalRewards, 0)
 
 	// first user exit pool
-	_, _, err = amm.ExitPool(ctx, addr[1], pools[0].PoolId, share.Quo(math.NewInt(2)), sdk.NewCoins(), "")
+	_, _, err = amm.ExitPool(ctx, addr[1], pools[0].PoolId, share.Quo(math.NewInt(2)), sdk.NewCoins(), "", false)
 	require.NoError(t, err)
 
 	// check rewards after 100 block

x/stablestake/keeper/msg_server_unbond.go

@@ -16,7 +16,7 @@ func (k msgServer) Unbond(goCtx context.Context, msg *types.MsgUnbond) (*types.M
 	shareDenom := types.GetShareDenom()
 
 	// Withdraw committed LP tokens
-	err := k.commitmentKeeper.UncommitTokens(ctx, creator, shareDenom, msg.Amount)
+	err := k.commitmentKeeper.UncommitTokens(ctx, creator, shareDenom, msg.Amount, false)
 	if err != nil {
 		return nil, err
 	}