when withdrawing non-collateral only, skip borrower health check

x/leverage/keeper/keeper.go

@@ -111,21 +111,24 @@ func (k Keeper) Supply(ctx sdk.Context, supplierAddr sdk.AccAddress, coin sdk.Co
 // the amount requested, returns an error. Returns the amount of base tokens received.
 // This function does NOT check that a borrower remains under their borrow limit or that
 // collateral liquidity remains healthy - those assertions have been moved to MsgServer.
-func (k Keeper) Withdraw(ctx sdk.Context, supplierAddr sdk.AccAddress, uToken sdk.Coin) (sdk.Coin, error) {
+// Returns a boolean which is true if some or all of the withdrawn uTokens were from collateral.
+func (k Keeper) Withdraw(ctx sdk.Context, supplierAddr sdk.AccAddress, uToken sdk.Coin) (sdk.Coin, bool, error) {
+	isFromCollateral := false
+
 	if err := validateUToken(uToken); err != nil {
-		return sdk.Coin{}, err
+		return sdk.Coin{}, isFromCollateral, err
 	}
 
 	// calculate base asset amount to withdraw
 	token, err := k.ExchangeUToken(ctx, uToken)
 	if err != nil {
-		return sdk.Coin{}, err
+		return sdk.Coin{}, isFromCollateral, err
 	}
 
 	// Ensure module account has sufficient unreserved tokens to withdraw
 	availableAmount := k.AvailableLiquidity(ctx, token.Denom)
 	if token.Amount.GT(availableAmount) {
-		return sdk.Coin{}, types.ErrLendingPoolInsufficient.Wrap(token.String())
+		return sdk.Coin{}, isFromCollateral, types.ErrLendingPoolInsufficient.Wrap(token.String())
 	}
 
 	// Withdraw will first attempt to use any uTokens in the supplier's wallet
@@ -134,43 +137,46 @@ func (k Keeper) Withdraw(ctx sdk.Context, supplierAddr sdk.AccAddress, uToken sd
 	amountFromCollateral := uToken.Amount.Sub(amountFromWallet)
 
 	if amountFromCollateral.IsPositive() {
+		// This indicates that borrower health check cannot be skipped after MsgWithdraw
+		isFromCollateral = true
+
 		// Check for sufficient collateral
 		collateral := k.GetBorrowerCollateral(ctx, supplierAddr)
 		collateralAmount := collateral.AmountOf(uToken.Denom)
 		if collateral.AmountOf(uToken.Denom).LT(amountFromCollateral) {
-			return sdk.Coin{}, types.ErrInsufficientBalance.Wrapf(
+			return sdk.Coin{}, isFromCollateral, types.ErrInsufficientBalance.Wrapf(
 				"%s uToken balance + %s from collateral is less than %s to withdraw",
 				amountFromWallet, collateralAmount, uToken)
 		}
 
 		// reduce the supplier's collateral by amountFromCollateral
 		newCollateral := sdk.NewCoin(uToken.Denom, collateralAmount.Sub(amountFromCollateral))
 		if err = k.setCollateral(ctx, supplierAddr, newCollateral); err != nil {
-			return sdk.Coin{}, err
+			return sdk.Coin{}, isFromCollateral, err
 		}
 	}
 
 	// transfer amountFromWallet uTokens to the module account
 	uTokens := sdk.NewCoins(sdk.NewCoin(uToken.Denom, amountFromWallet))
 	if err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, supplierAddr, types.ModuleName, uTokens); err != nil {
-		return sdk.Coin{}, err
+		return sdk.Coin{}, isFromCollateral, err
 	}
 
 	// send the base assets to supplier
 	tokens := sdk.NewCoins(token)
 	if err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, supplierAddr, tokens); err != nil {
-		return sdk.Coin{}, err
+		return sdk.Coin{}, isFromCollateral, err
 	}
 
 	// burn the uTokens and set the new total uToken supply
 	if err = k.bankKeeper.BurnCoins(ctx, types.ModuleName, sdk.NewCoins(uToken)); err != nil {
-		return sdk.Coin{}, err
+		return sdk.Coin{}, isFromCollateral, err
 	}
 	if err = k.setUTokenSupply(ctx, k.GetUTokenSupply(ctx, uToken.Denom).Sub(uToken)); err != nil {
-		return sdk.Coin{}, err
+		return sdk.Coin{}, isFromCollateral, err
 	}
 
-	return token, nil
+	return token, isFromCollateral, nil
 }
 
 // Borrow attempts to borrow tokens from the leverage module account using

x/leverage/keeper/msg_server.go

@@ -68,16 +68,18 @@ func (s msgServer) Withdraw(
 	if err != nil {
 		return nil, err
 	}
-	received, err := s.keeper.Withdraw(ctx, supplierAddr, msg.Asset)
+	received, isFromCollateral, err := s.keeper.Withdraw(ctx, supplierAddr, msg.Asset)
 	if err != nil {
 		return nil, err
 	}
 
 	// Fail here if supplier ends up over their borrow limit under current or historic prices
 	// Tolerates missing collateral prices if the rest of the borrower's collateral can cover all borrows
-	err = s.keeper.assertBorrowerHealth(ctx, supplierAddr)
-	if err != nil {
-		return nil, err
+	if isFromCollateral {
+		err = s.keeper.assertBorrowerHealth(ctx, supplierAddr)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	// Ensure MinCollateralLiquidity is still satisfied after the transaction
@@ -122,16 +124,18 @@ func (s msgServer) MaxWithdraw(
 		return &types.MsgMaxWithdrawResponse{Withdrawn: uToken, Received: zeroCoin}, nil
 	}
 
-	received, err := s.keeper.Withdraw(ctx, supplierAddr, uToken)
+	received, isFromCollateral, err := s.keeper.Withdraw(ctx, supplierAddr, uToken)
 	if err != nil {
 		return nil, err
 	}
 
 	// Fail here if supplier ends up over their borrow limit under current or historic prices
 	// Tolerates missing collateral prices if the rest of the borrower's collateral can cover all borrows
-	err = s.keeper.assertBorrowerHealth(ctx, supplierAddr)
-	if err != nil {
-		return nil, err
+	if isFromCollateral {
+		err = s.keeper.assertBorrowerHealth(ctx, supplierAddr)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	// Ensure MinCollateralLiquidity is still satisfied after the transaction

x/leverage/keeper/outage_test.go

@@ -44,7 +44,7 @@ func (s *IntegrationTestSuite) TestBorrowedPriceOutage() {
 	// Non-collateral UMEE can still be withdrawn using max withdraw
 	msg3 := &types.MsgMaxWithdraw{
 		Supplier: umeeSupplier.String(),
-		Denom:    "u/" + umeeDenom,
+		Denom:    umeeDenom,
 	}
 	_, err = srv.MaxWithdraw(ctx, msg3)
 	require.NoError(err, "max withdraw non-collateral umee")