feat: implement special asset pairs

util/coin/coin.go

@@ -50,7 +50,7 @@ func Zero(denom string) sdk.Coin {
 	return sdk.NewInt64Coin(denom, 0)
 }
 
-// Zero returns new coin with zero amount
+// ZeroDec returns new decCoin with zero amount
 func ZeroDec(denom string) sdk.DecCoin {
 	return sdk.NewInt64DecCoin(denom, 0)
 }

util/coin/fixtures.go

@@ -48,7 +48,7 @@ func UmeeDec(amount string) sdk.DecCoin {
 	return Dec(appparams.BondDenom, amount)
 }
 
-// Utoken creates a uToken DecCoin.
+// Utoken creates a uToken Coin.
 func Utoken(denom string, amount int64) sdk.Coin {
 	return New(leveragetypes.ToUTokenDenom(denom), amount)
 }

x/leverage/README.md

@@ -200,13 +200,14 @@ For example, an account using a single collateral token with `CollateralWeight 0
 
 The leverage module can define pairs of assets which are advantaged when one is used as collateral to borrow the other.
 
-They are defined in the form `[Asset A, Asset B, Special Collateral Weight]`. In effect, this means that
+They are defined in the form `[Asset A, Asset B, Special Collateral Weight, Special Liquidation Threshold]`. In effect, this means that
 
-> When a user has collateral of `Asset A` and borrows `Asset B`, or vice versa, the `CollateralWeight` of both `Asset A` and `Asset B` are replaced by `Special Collateral Weight`.
+> When a user has collateral of `Asset A` and borrows `Asset B`, or vice versa, the `CollateralWeight` of both `Asset A` and `Asset B` are replaced by `Special Collateral Weight`. The `LiquidationThreshold` of the assets is also replaced by that of the special pair.
 
 #### Special Asset Pair Examples
 
 > Consider a scenario where assets `A,B,C,D` all have collateral weight `0.75`. There is also a special asset pair `[A,B,0.9]` which privileges borrows between those two assets.
+> (Note: Liquidation threshold has been omitted from the special pair in this example.)
 >
 > A user with `Collateral: $10A, Borrowed: $7A` is unaffected by any special asset pairs. The maximum `A` it could borrow is `$7.50`
 >
@@ -320,6 +321,7 @@ In practice, the following calculation (which reduces to the logic above in simp
 This utilizes the borrow limit, which has already been computed with special asset pairs, and the token parameters of borrower's collateral:
 
 - The average (weighted by collateral value) collateral weights and liquidation thresholds of the borrower's collateral assets are collected.
+- For collateral assets being counted in special asset pairs, the collateral weight and liquidation threshold of the pair is used instead of that of the asset.
 - The distances from average collateral weight to average liquidation threshold and 1 are compared. (For example when `CW = 0.6` and `LT = 0.7`, then liquidation threshold is `25%` of the way from `CW` to `1`.)
 - Then the borrower's liquidation threshold behaves the same as the average parameters (e.g. it will be `25%` of the way between `borrow limit` and `collateral value`).
 

x/leverage/keeper/borrows.go

@@ -8,48 +8,28 @@ import (
 )
 
 // assertBorrowerHealth returns an error if a borrower is currently above their borrow limit,
-// under either recent (historic median) or current prices. Checks using borrow limit based
-// on collateral weight, then check separately for borrow limit using borrow factor. Error if
-// borrowed asset prices cannot be calculated, but will try to treat collateral whose prices are
+// under either recent (historic median) or current prices. Checks using rules for collateral
+// weight, borrow factor, and special asset pairs to determine borrow limit. Error if
+// borrowed asset prices cannot be calculated, but will  treat collateral whose prices are
 // unavailable as having zero value. This can still result in a borrow limit being too low,
 // unless the remaining collateral is enough to cover all borrows.
 // 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.
+// by borrow limits, i.e. Borrow, Decollateralize, Withdraw, MaxWithdraw, LeverageLiquidate.
 // MaxUsage sets the maximum percent of a user's borrow limit that can be in use: set to 1
 // to allow up to 100% borrow limit, or a lower value (e.g. 0.9) if a transaction should fail
 // if a safety margin is desired (e.g. <90% borrow limit).
 func (k Keeper) assertBorrowerHealth(ctx sdk.Context, borrowerAddr sdk.AccAddress, maxUsage sdk.Dec) error {
-	borrowed := k.GetBorrowerBorrows(ctx, borrowerAddr)
-	collateral := k.GetBorrowerCollateral(ctx, borrowerAddr)
-
-	// check health using collateral weight
-	borrowValue, err := k.TotalTokenValue(ctx, borrowed, types.PriceModeHigh)
+	position, err := k.GetAccountPosition(ctx, borrowerAddr, false)
 	if err != nil {
 		return err
 	}
-	borrowLimit, err := k.VisibleBorrowLimit(ctx, collateral)
-	if err != nil {
-		return err
-	}
-	if borrowValue.GT(borrowLimit.Mul(maxUsage)) {
-		return types.ErrUndercollaterized.Wrapf(
-			"borrowed: %s, limit: %s, max usage %s", borrowValue, borrowLimit, maxUsage)
-	}
 
-	// check health using borrow factor
-	weightedBorrowValue, err := k.ValueWithBorrowFactor(ctx, borrowed, types.PriceModeHigh)
-	if err != nil {
-		return err
-	}
-	collateralValue, err := k.VisibleUTokensValue(ctx, collateral, types.PriceModeLow)
-	if err != nil {
-		return err
-	}
-	if weightedBorrowValue.GT(collateralValue.Mul(maxUsage)) {
+	borrowedValue := position.BorrowedValue()
+	borrowLimit := position.Limit()
+	if borrowedValue.GT(borrowLimit.Mul(maxUsage)) {
 		return types.ErrUndercollaterized.Wrapf(
-			"weighted borrow: %s, collateral value: %s, max usage %s", weightedBorrowValue, collateralValue, maxUsage)
+			"borrowed: %s, limit: %s, max usage %s", borrowedValue, borrowLimit, maxUsage)
 	}
-
 	return nil
 }
 
@@ -125,115 +105,6 @@ func (k Keeper) SupplyUtilization(ctx sdk.Context, denom string) sdk.Dec {
 	return totalBorrowed.Quo(tokenSupply)
 }
 
-// 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.
-// The lower of spot price or historic price is used for each collateral token.
-// 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) {
-	limit := sdk.ZeroDec()
-
-	for _, coin := range collateral {
-		// convert uToken collateral to base assets
-		baseAsset, err := k.ExchangeUToken(ctx, coin)
-		if err != nil {
-			return sdk.ZeroDec(), err
-		}
-
-		ts, err := k.GetTokenSettings(ctx, baseAsset.Denom)
-		if err != nil {
-			return sdk.ZeroDec(), err
-		}
-
-		// ignore blacklisted tokens
-		if !ts.Blacklist {
-			// get USD value of base assets using the chosen price mode
-			v, err := k.TokenValue(ctx, baseAsset, types.PriceModeLow)
-			if err != nil {
-				return sdk.ZeroDec(), err
-			}
-			// add each collateral coin's weighted value to borrow limit
-			limit = limit.Add(v.Mul(ts.CollateralWeight))
-		}
-	}
-
-	return limit, nil
-}
-
-// VisibleBorrowLimit 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.
-// The lower of spot price or historic price is used for each collateral token.
-// An error is returned if any input coins are not uTokens.
-// This function skips assets that are missing prices, which will lead to a lower borrow
-// limit when prices are down instead of a complete loss of borrowing ability.
-func (k Keeper) VisibleBorrowLimit(ctx sdk.Context, collateral sdk.Coins) (sdk.Dec, error) {
-	limit := sdk.ZeroDec()
-
-	for _, coin := range collateral {
-		// convert uToken collateral to base assets
-		baseAsset, err := k.ExchangeUToken(ctx, coin)
-		if err != nil {
-			return sdk.ZeroDec(), err
-		}
-
-		ts, err := k.GetTokenSettings(ctx, baseAsset.Denom)
-		if err != nil {
-			return sdk.ZeroDec(), err
-		}
-
-		// ignore blacklisted tokens
-		if !ts.Blacklist {
-			// get USD value of base assets using the chosen price mode
-			v, err := k.TokenValue(ctx, baseAsset, types.PriceModeLow)
-			if err == nil {
-				// if both spot and historic (if required) prices exist,
-				// add collateral coin's weighted value to borrow limit
-				limit = limit.Add(v.Mul(ts.CollateralWeight))
-			}
-			if nonOracleError(err) {
-				return sdk.ZeroDec(), err
-			}
-		}
-	}
-
-	return limit, nil
-}
-
-// CalculateLiquidationThreshold determines the maximum borrowed value (in USD) that a
-// borrower with given collateral could reach before being eligible for liquidation, using
-// each token's oracle price, uToken exchange rate, and liquidation threshold.
-// An error is returned if any input coins are not uTokens or if value
-// calculation fails. Always uses spot prices.
-func (k Keeper) CalculateLiquidationThreshold(ctx sdk.Context, collateral sdk.Coins) (sdk.Dec, error) {
-	totalThreshold := sdk.ZeroDec()
-
-	for _, coin := range collateral {
-		// convert uToken collateral to base assets
-		baseAsset, err := k.ExchangeUToken(ctx, coin)
-		if err != nil {
-			return sdk.ZeroDec(), err
-		}
-
-		ts, err := k.GetTokenSettings(ctx, baseAsset.Denom)
-		if err != nil {
-			return sdk.ZeroDec(), err
-		}
-
-		// ignore blacklisted tokens
-		if !ts.Blacklist {
-			// get USD value of base assets
-			v, err := k.TokenValue(ctx, baseAsset, types.PriceModeSpot)
-			if err != nil {
-				return sdk.ZeroDec(), err
-			}
-
-			// add each collateral coin's weighted value to liquidation threshold
-			totalThreshold = totalThreshold.Add(v.Mul(ts.LiquidationThreshold))
-		}
-	}
-
-	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 {

x/leverage/keeper/borrows_test.go

@@ -199,6 +199,7 @@ func (s *IntegrationTestSuite) TestDeriveBorrowUtilization() {
 	require.Equal(sdk.MustNewDecFromStr("1.0"), utilization)
 }
 
+/*
 func (s *IntegrationTestSuite) TestCalculateBorrowLimit() {
 	app, ctx, require := s.app, s.ctx, s.Require()
 
@@ -251,3 +252,4 @@ func (s *IntegrationTestSuite) TestCalculateBorrowLimit() {
 	require.NoError(err)
 	require.Equal(expectedCombinedLimit, borrowLimit)
 }
+*/

x/leverage/keeper/grpc_query.go

@@ -259,10 +259,11 @@ func (q Querier) AccountSummary(
 	// borrow limit shown here as it is used in leverage logic:
 	// using the lower of spot or historic prices for each collateral token
 	// skips collateral tokens with missing oracle prices
-	borrowLimit, err := q.Keeper.VisibleBorrowLimit(ctx, collateral)
+	ap, err := q.Keeper.GetAccountPosition(ctx, addr, false)
 	if err != nil {
 		return nil, err
 	}
+	borrowLimit := ap.Limit()
 
 	resp := &types.QueryAccountSummaryResponse{
 		SuppliedValue:   suppliedValue,
@@ -273,9 +274,10 @@ func (q Querier) AccountSummary(
 
 	// liquidation always uses spot prices. This response field will be null
 	// if a price is missing
-	liquidationThreshold, err := q.Keeper.CalculateLiquidationThreshold(ctx, collateral)
+	ap, err = q.Keeper.GetAccountPosition(ctx, addr, true)
 	if err == nil {
-		resp.LiquidationThreshold = &liquidationThreshold
+		lt := ap.Limit()
+		resp.LiquidationThreshold = &lt
 	}
 
 	return resp, nil

x/leverage/keeper/inspector.go

@@ -65,11 +65,15 @@ func (q Querier) Inspect(
 		}
 		checkedAddrs[addr.String()] = struct{}{}
 
+		borrowedValue, collateralValue, liquidationThreshold := sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()
+		position, err := k.GetAccountPosition(ctx, addr, true)
+		if err == nil {
+			borrowedValue = position.BorrowedValue()
+			collateralValue = position.CollateralValue()
+			liquidationThreshold = position.Limit()
+		}
 		borrowed := k.GetBorrowerBorrows(ctx, addr)
-		borrowedValue, _ := k.TotalTokenValue(ctx, borrowed, types.PriceModeSpot)
 		collateral := k.GetBorrowerCollateral(ctx, addr)
-		collateralValue, _ := k.CalculateCollateralValue(ctx, collateral, types.PriceModeSpot)
-		liquidationThreshold, _ := k.CalculateLiquidationThreshold(ctx, collateral)
 
 		account := types.InspectAccount{
 			Address: addr.String(),

x/leverage/keeper/iter.go

@@ -1,6 +1,8 @@
 package keeper
 
 import (
+	"sort"
+
 	sdkmath "cosmossdk.io/math"
 	prefixstore "github.com/cosmos/cosmos-sdk/store/prefix"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
@@ -45,14 +47,22 @@ func (k Keeper) GetAllRegisteredTokens(ctx sdk.Context) []types.Token {
 // GetAllSpecialAssetPairs returns all the special asset pairs from the x/leverage
 // module's KVStore.
 func (k Keeper) GetAllSpecialAssetPairs(ctx sdk.Context) []types.SpecialAssetPair {
-	return store.MustLoadAll[*types.SpecialAssetPair](ctx.KVStore(k.storeKey), types.KeyPrefixSpecialAssetPair)
+	pairs := store.MustLoadAll[*types.SpecialAssetPair](ctx.KVStore(k.storeKey), types.KeyPrefixSpecialAssetPair)
+	sort.SliceStable(pairs, func(i, j int) bool {
+		return pairs[i].CollateralWeight.LT(pairs[j].CollateralWeight)
+	})
+	return pairs
 }
 
 // GetSpecialAssetPairs returns all the special asset pairs from the x/leverage
 // module's KVStore which match a single asset.
 func (k Keeper) GetSpecialAssetPairs(ctx sdk.Context, denom string) []types.SpecialAssetPair {
 	prefix := types.KeySpecialAssetPairOneDenom(denom)
-	return store.MustLoadAll[*types.SpecialAssetPair](ctx.KVStore(k.storeKey), prefix)
+	pairs := store.MustLoadAll[*types.SpecialAssetPair](ctx.KVStore(k.storeKey), prefix)
+	sort.SliceStable(pairs, func(i, j int) bool {
+		return pairs[i].CollateralWeight.LT(pairs[j].CollateralWeight)
+	})
+	return pairs
 }
 
 // GetBorrowerBorrows returns an sdk.Coins object containing all open borrows
@@ -117,29 +127,18 @@ func (k Keeper) GetEligibleLiquidationTargets(ctx sdk.Context) ([]sdk.AccAddress
 		}
 		checkedAddrs[borrowerAddr.String()] = struct{}{}
 
-		// get borrower's total borrowed
-		borrowed := k.GetBorrowerBorrows(ctx, borrowerAddr)
-
-		// get borrower's total collateral
-		collateral := k.GetBorrowerCollateral(ctx, borrowerAddr)
-
-		// use oracle helper functions to find total borrowed value in USD
-		// skips denoms without prices
-		borrowValue, err := k.VisibleTokenValue(ctx, borrowed, types.PriceModeSpot)
-		if err != nil {
-			return err
-		}
-
-		// compute liquidation threshold from enabled collateral
-		// in this case, we can't reasonably skip missing prices but can move on
-		// to the next borrower instead of stopping the entire query
-		liquidationLimit, err := k.CalculateLiquidationThreshold(ctx, collateral)
-		if err == nil && liquidationLimit.LT(borrowValue) {
-			// If liquidation limit is smaller than borrowed value then the
-			// address is eligible for liquidation.
-			liquidationTargets = append(liquidationTargets, borrowerAddr)
+		position, err := k.GetAccountPosition(ctx, borrowerAddr, true)
+		if err == nil {
+			borrowValue := position.BorrowedValue()
+			liquidationThreshold := position.Limit()
+			if liquidationThreshold.LT(borrowValue) {
+				// If liquidation threshold is smaller than borrowed value then the
+				// address is eligible for liquidation.
+				liquidationTargets = append(liquidationTargets, borrowerAddr)
+			}
 		}
-		// Non-price errors will cause the query itself to fail
+		// Non-price errors will cause the query itself to fail, whereas oracle errors
+		// simply cause the address to be skipped
 		if nonOracleError(err) {
 			return err
 		}