feat: leverage + historacle

CHANGELOG.md

@@ -53,6 +53,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 - [1630](https://github.com/umee-network/umee/pull/1630) Incentive module proto.
 - [1588](https://github.com/umee-network/umee/pull/1588) Historacle proto.
 - [1653](https://github.com/umee-network/umee/pull/1653) Incentive Msg Server interface implementation.
+- [1654](https://github.com/umee-network/umee/pull/1654) Leverage historacle integration.
 
 ## [v3.3.0](https://github.com/umee-network/umee/releases/tag/v3.3.0) - 2022-12-20
 

app/test_helpers.go

@@ -270,6 +270,17 @@ func IntegrationTestNetworkConfig() network.Config {
 	oracleGenState.ExchangeRates = append(oracleGenState.ExchangeRates, oracletypes.NewExchangeRateTuple(
 		params.DisplayDenom, sdk.MustNewDecFromStr("34.21"),
 	))
+	// Set mock historic medians to satisfy leverage module's 24 median requirement
+	for i := 1; i <= 24; i++ {
+		median := oracletypes.Price{
+			ExchangeRateTuple: oracletypes.NewExchangeRateTuple(
+				params.DisplayDenom,
+				sdk.MustNewDecFromStr("34.21"),
+			),
+			BlockNum: uint64(i),
+		}
+		oracleGenState.Medians = append(oracleGenState.Medians, median)
+	}
 
 	bz, err = cdc.MarshalJSON(&oracleGenState)
 	if err != nil {

x/leverage/keeper/borrows.go

@@ -7,6 +7,48 @@ import (
 	"github.com/umee-network/umee/v3/x/leverage/types"
 )
 
+// assertBorrowerHealth returns an error if a borrower is currently above their borrow limit,
+// under either recent (historic median) or current prices. It returns an error if current
+// prices cannot be calculated, but will use current prices (without returning an error)
+// for any token whose historic prices cannot be calculated.
+// This should be checked in msg_server.go at the end of any transaction which is restricted
+// by borrow limits, i.e. Borrow, Decollateralize, Withdraw, MaxWithdraw.
+func (k Keeper) assertBorrowerHealth(ctx sdk.Context, borrowerAddr sdk.AccAddress) error {
+	borrowed := k.GetBorrowerBorrows(ctx, borrowerAddr)
+	collateral := k.GetBorrowerCollateral(ctx, borrowerAddr)
+
+	// Check using current prices
+	err := k.checkPositionHealth(ctx, borrowed, collateral, false)
+	if err != nil {
+		return err
+	}
+
+	// Check using historic prices
+	return k.checkPositionHealth(ctx, borrowed, collateral, true)
+}
+
+// checkPositionHealth returns an error if a borrow + collateral position is not healthy. uses either
+// current or historic prices.
+func (k Keeper) checkPositionHealth(ctx sdk.Context, borrowed, collateral sdk.Coins, historic bool) error {
+	value, err := k.TotalTokenValue(ctx, borrowed, historic)
+	if err != nil {
+		return err
+	}
+	limit, err := k.CalculateBorrowLimit(ctx, collateral, historic)
+	if err != nil {
+		return err
+	}
+	if value.GT(limit) {
+		desc := "current"
+		if historic {
+			desc = "historic"
+		}
+		return types.ErrUndercollaterized.Wrapf(
+			"borrowed: %s, limit: %s (%s prices)", value, limit, desc)
+	}
+	return nil
+}
+
 // GetBorrow returns an sdk.Coin representing how much of a given denom a
 // borrower currently owes.
 func (k Keeper) GetBorrow(ctx sdk.Context, borrowerAddr sdk.AccAddress, denom string) sdk.Coin {
@@ -72,7 +114,8 @@ func (k Keeper) SupplyUtilization(ctx sdk.Context, denom string) sdk.Dec {
 // CalculateBorrowLimit uses the price oracle to determine the borrow limit (in USD) provided by
 // collateral sdk.Coins, using each token's uToken exchange rate and collateral weight.
 // An error is returned if any input coins are not uTokens or if value calculation fails.
-func (k Keeper) CalculateBorrowLimit(ctx sdk.Context, collateral sdk.Coins) (sdk.Dec, error) {
+// If the historic parameter is true, uses medians of recent prices instead of current prices.
+func (k Keeper) CalculateBorrowLimit(ctx sdk.Context, collateral sdk.Coins, historic bool) (sdk.Dec, error) {
 	limit := sdk.ZeroDec()
 
 	for _, coin := range collateral {
@@ -90,7 +133,7 @@ func (k Keeper) CalculateBorrowLimit(ctx sdk.Context, collateral sdk.Coins) (sdk
 		// ignore blacklisted tokens
 		if !ts.Blacklist {
 			// get USD value of base assets
-			v, err := k.TokenValue(ctx, baseAsset)
+			v, err := k.TokenValue(ctx, baseAsset, historic)
 			if err != nil {
 				return sdk.ZeroDec(), err
 			}
@@ -125,7 +168,7 @@ func (k Keeper) CalculateLiquidationThreshold(ctx sdk.Context, collateral sdk.Co
 		// ignore blacklisted tokens
 		if !ts.Blacklist {
 			// get USD value of base assets
-			v, err := k.TokenValue(ctx, baseAsset)
+			v, err := k.TokenValue(ctx, baseAsset, false)
 			if err != nil {
 				return sdk.ZeroDec(), err
 			}
@@ -137,3 +180,18 @@ func (k Keeper) CalculateLiquidationThreshold(ctx sdk.Context, collateral sdk.Co
 
 	return totalThreshold, nil
 }
+
+// checkSupplyUtilization returns the appropriate error if a token denom's
+// supply utilization has exceeded MaxSupplyUtilization
+func (k Keeper) checkSupplyUtilization(ctx sdk.Context, denom string) error {
+	token, err := k.GetTokenSettings(ctx, denom)
+	if err != nil {
+		return err
+	}
+
+	utilization := k.SupplyUtilization(ctx, denom)
+	if utilization.GT(token.MaxSupplyUtilization) {
+		return types.ErrMaxSupplyUtilization.Wrap(utilization.String())
+	}
+	return nil
+}

x/leverage/keeper/borrows_test.go

@@ -202,13 +202,13 @@ func (s *IntegrationTestSuite) TestCalculateBorrowLimit() {
 	app, ctx, require := s.app, s.ctx, s.Require()
 
 	// Empty coins
-	borrowLimit, err := app.LeverageKeeper.CalculateBorrowLimit(ctx, sdk.NewCoins())
+	borrowLimit, err := app.LeverageKeeper.CalculateBorrowLimit(ctx, sdk.NewCoins(), false)
 	require.NoError(err)
 	require.Equal(sdk.ZeroDec(), borrowLimit)
 
 	// Unregistered asset
 	invalidCoins := sdk.NewCoins(coin("abcd", 1000))
-	_, err = app.LeverageKeeper.CalculateBorrowLimit(ctx, invalidCoins)
+	_, err = app.LeverageKeeper.CalculateBorrowLimit(ctx, invalidCoins, false)
 	require.ErrorIs(err, types.ErrNotUToken)
 
 	// Create collateral uTokens (1k u/umee)
@@ -222,7 +222,7 @@ func (s *IntegrationTestSuite) TestCalculateBorrowLimit() {
 		Mul(sdk.MustNewDecFromStr("0.25"))
 
 	// Check borrow limit vs. manually computed value
-	borrowLimit, err = app.LeverageKeeper.CalculateBorrowLimit(ctx, umeeCollateral)
+	borrowLimit, err = app.LeverageKeeper.CalculateBorrowLimit(ctx, umeeCollateral, false)
 	require.NoError(err)
 	require.Equal(expectedUmeeLimit, borrowLimit)
 
@@ -237,7 +237,7 @@ func (s *IntegrationTestSuite) TestCalculateBorrowLimit() {
 		Mul(sdk.MustNewDecFromStr("0.25"))
 
 	// Check borrow limit vs. manually computed value
-	borrowLimit, err = app.LeverageKeeper.CalculateBorrowLimit(ctx, atomCollateral)
+	borrowLimit, err = app.LeverageKeeper.CalculateBorrowLimit(ctx, atomCollateral, false)
 	require.NoError(err)
 	require.Equal(expectedAtomLimit, borrowLimit)
 
@@ -246,7 +246,7 @@ func (s *IntegrationTestSuite) TestCalculateBorrowLimit() {
 	combinedCollateral := umeeCollateral.Add(atomCollateral...)
 
 	// Check borrow limit vs. manually computed value
-	borrowLimit, err = app.LeverageKeeper.CalculateBorrowLimit(ctx, combinedCollateral)
+	borrowLimit, err = app.LeverageKeeper.CalculateBorrowLimit(ctx, combinedCollateral, false)
 	require.NoError(err)
 	require.Equal(expectedCombinedLimit, borrowLimit)
 }

x/leverage/keeper/collateral.go

@@ -66,7 +66,7 @@ func (k Keeper) CalculateCollateralValue(ctx sdk.Context, collateral sdk.Coins)
 		}
 
 		// get USD value of base assets
-		v, err := k.TokenValue(ctx, baseAsset)
+		v, err := k.TokenValue(ctx, baseAsset, false)
 		if err != nil {
 			return sdk.ZeroDec(), err
 		}

x/leverage/keeper/grpc_query.go

@@ -135,7 +135,7 @@ func (q Querier) MarketSummary(
 	}
 
 	// Oracle price in response will be nil if it is unavailable
-	if oraclePrice, _, oracleErr := q.Keeper.TokenDefaultDenomPrice(ctx, req.Denom); oracleErr == nil {
+	if oraclePrice, _, oracleErr := q.Keeper.TokenDefaultDenomPrice(ctx, req.Denom, false); oracleErr == nil {
 		resp.OraclePrice = &oraclePrice
 	}
 
@@ -199,19 +199,19 @@ func (q Querier) AccountSummary(
 	collateral := q.Keeper.GetBorrowerCollateral(ctx, addr)
 	borrowed := q.Keeper.GetBorrowerBorrows(ctx, addr)
 
-	suppliedValue, err := q.Keeper.TotalTokenValue(ctx, supplied)
+	suppliedValue, err := q.Keeper.TotalTokenValue(ctx, supplied, false)
 	if err != nil {
 		return nil, err
 	}
-	borrowedValue, err := q.Keeper.TotalTokenValue(ctx, borrowed)
+	borrowedValue, err := q.Keeper.TotalTokenValue(ctx, borrowed, false)
 	if err != nil {
 		return nil, err
 	}
 	collateralValue, err := q.Keeper.CalculateCollateralValue(ctx, collateral)
 	if err != nil {
 		return nil, err
 	}
-	borrowLimit, err := q.Keeper.CalculateBorrowLimit(ctx, collateral)
+	borrowLimit, err := q.Keeper.CalculateBorrowLimit(ctx, collateral, false)
 	if err != nil {
 		return nil, err
 	}
@@ -288,10 +288,19 @@ func (q Querier) MaxWithdraw(
 		return nil, err
 	}
 
-	uToken, err := q.Keeper.maxWithdraw(ctx, addr, req.Denom)
+	maxCurrentWithdraw, err := q.Keeper.maxWithdraw(ctx, addr, req.Denom, false)
 	if err != nil {
 		return nil, err
 	}
+	maxHistoricWithdraw, err := q.Keeper.maxWithdraw(ctx, addr, req.Denom, true)
+	if err != nil {
+		return nil, err
+	}
+
+	uToken := sdk.NewCoin(
+		maxCurrentWithdraw.Denom,
+		sdk.MinInt(maxCurrentWithdraw.Amount, maxHistoricWithdraw.Amount),
+	)
 
 	token, err := q.Keeper.ExchangeUToken(ctx, uToken)
 	if err != nil {

x/leverage/keeper/grpc_query_test.go

@@ -14,7 +14,7 @@ func (s *IntegrationTestSuite) TestQuerier_RegisteredTokens() {
 
 	resp, err := s.queryClient.RegisteredTokens(ctx.Context(), &types.QueryRegisteredTokens{})
 	require.NoError(err)
-	require.Len(resp.Registry, 3, "token registry length")
+	require.Len(resp.Registry, 5, "token registry length")
 }
 
 func (s *IntegrationTestSuite) TestQuerier_Params() {

x/leverage/keeper/iter.go

@@ -182,7 +182,7 @@ func (k Keeper) GetEligibleLiquidationTargets(ctx sdk.Context) ([]sdk.AccAddress
 		collateral := k.GetBorrowerCollateral(ctx, addr)
 
 		// use oracle helper functions to find total borrowed value in USD
-		borrowValue, err := k.TotalTokenValue(ctx, borrowed)
+		borrowValue, err := k.TotalTokenValue(ctx, borrowed, false)
 		if err != nil {
 			return err
 		}