Merge branch 'main' into sai/1001

CHANGELOG.md

@@ -54,6 +54,10 @@ Ref: https://keepachangelog.com/en/1.0.0/
 
 - [1555](https://github.com/umee-network/umee/pull/1555) Enable GB Slashing.
 
+### API Breaking
+
+- [1578](https://github.com/umee-network/umee/pull/1578) Reorganize key constructors in x/leverage/types and x/oracle/types.
+
 ## [v3.1.0](https://github.com/umee-network/umee/releases/tag/v3.0.0) - 2022-10-22
 
 ### Features

x/leverage/keeper/invariants.go

@@ -35,15 +35,13 @@ func ReserveAmountInvariant(k Keeper) sdk.Invariant {
 			count int
 		)
 
-		reserveAmountPrefix := types.CreateReserveAmountKeyNoDenom()
-
 		// Iterate through all denoms which have an reserve amount stored
 		// in the keeper. If a token is registered but its reserve amount is
 		// negative or it has some error doing the unmarshal it
 		// adds the denom invariant count and message description
-		err := k.iterate(ctx, reserveAmountPrefix, func(key, val []byte) error {
-			// remove reserveAmountPrefix and null-terminator
-			denom := types.DenomFromKey(key, reserveAmountPrefix)
+		err := k.iterate(ctx, types.KeyPrefixReserveAmount, func(key, val []byte) error {
+			// remove types.KeyPrefixReserveAmount and null-terminator
+			denom := types.DenomFromKey(key, types.KeyPrefixReserveAmount)
 
 			amount := sdk.ZeroInt()
 			if err := amount.Unmarshal(val); err != nil {
@@ -81,15 +79,13 @@ func InefficientCollateralAmountInvariant(k Keeper) sdk.Invariant {
 			count int
 		)
 
-		collateralPrefix := types.CreateCollateralAmountKeyNoAddress()
-
 		// Iterate through all collateral amounts stored in the keeper,
 		// ensuring all successfully unmarshal to positive values.
-		err := k.iterate(ctx, collateralPrefix, func(key, val []byte) error {
+		err := k.iterate(ctx, types.KeyPrefixCollateralAmount, func(key, val []byte) error {
 			// remove prefix | lengthPrefixed(addr) and null-terminator
-			denom := types.DenomFromKeyWithAddress(key, collateralPrefix)
+			denom := types.DenomFromKeyWithAddress(key, types.KeyPrefixCollateralAmount)
 			// remove prefix | denom and null-terminator
-			address := types.AddressFromKey(key, collateralPrefix)
+			address := types.AddressFromKey(key, types.KeyPrefixCollateralAmount)
 
 			amount := sdk.ZeroInt()
 			if err := amount.Unmarshal(val); err != nil {

x/leverage/keeper/iter.go

@@ -101,7 +101,7 @@ func (k Keeper) GetAllReserves(ctx sdk.Context) sdk.Coins {
 // GetBorrowerBorrows returns an sdk.Coins object containing all open borrows
 // associated with an address.
 func (k Keeper) GetBorrowerBorrows(ctx sdk.Context, borrowerAddr sdk.AccAddress) sdk.Coins {
-	prefix := types.CreateAdjustedBorrowKeyNoDenom(borrowerAddr)
+	prefix := types.KeyAdjustedBorrowNoDenom(borrowerAddr)
 	totalBorrowed := sdk.NewCoins()
 
 	iterator := func(key, val []byte) error {
@@ -133,7 +133,7 @@ func (k Keeper) GetBorrowerBorrows(ctx sdk.Context, borrowerAddr sdk.AccAddress)
 
 // GetBorrowerCollateral returns an sdk.Coins containing all of a borrower's collateral.
 func (k Keeper) GetBorrowerCollateral(ctx sdk.Context, borrowerAddr sdk.AccAddress) sdk.Coins {
-	prefix := types.CreateCollateralAmountKeyNoDenom(borrowerAddr)
+	prefix := types.KeyCollateralAmountNoDenom(borrowerAddr)
 	totalCollateral := sdk.NewCoins()
 
 	iterator := func(key, val []byte) error {

x/leverage/keeper/store.go

@@ -87,14 +87,14 @@ func (k Keeper) setStoredInt(ctx sdk.Context, key []byte, val sdkmath.Int, desc
 // getAdjustedBorrow gets the adjusted amount borrowed by an address in a given denom.
 // Returned value is non-negative.
 func (k Keeper) getAdjustedBorrow(ctx sdk.Context, addr sdk.AccAddress, denom string) sdk.Dec {
-	key := types.CreateAdjustedBorrowKey(addr, denom)
+	key := types.KeyAdjustedBorrow(addr, denom)
 	return k.getStoredDec(ctx, key, sdk.ZeroDec(), "adjusted borrow")
 }
 
 // getAdjustedTotalBorrowed gets the total amount borrowed across all borrowers for a given denom.
 // Returned value is non-negative.
 func (k Keeper) getAdjustedTotalBorrowed(ctx sdk.Context, denom string) sdk.Dec {
-	key := types.CreateAdjustedTotalBorrowKey(denom)
+	key := types.KeyAdjustedTotalBorrow(denom)
 	return k.getStoredDec(ctx, key, sdk.ZeroDec(), "adjusted total borrow")
 }
 
@@ -114,22 +114,22 @@ func (k Keeper) setAdjustedBorrow(ctx sdk.Context, addr sdk.AccAddress, adjusted
 	delta := adjustedBorrow.Amount.Sub(k.getAdjustedBorrow(ctx, addr, adjustedBorrow.Denom))
 
 	// Update total adjusted borrow
-	key := types.CreateAdjustedTotalBorrowKey(adjustedBorrow.Denom)
+	key := types.KeyAdjustedTotalBorrow(adjustedBorrow.Denom)
 	newTotal := k.getAdjustedTotalBorrowed(ctx, adjustedBorrow.Denom).Add(delta)
 	err := k.setStoredDec(ctx, key, newTotal, sdk.ZeroDec(), "total adjusted borrow")
 	if err != nil {
 		return err
 	}
 
 	// Set new adjusted borrow
-	key = types.CreateAdjustedBorrowKey(addr, adjustedBorrow.Denom)
+	key = types.KeyAdjustedBorrow(addr, adjustedBorrow.Denom)
 	return k.setStoredDec(ctx, key, adjustedBorrow.Amount, sdk.ZeroDec(), "adjusted borrow")
 }
 
 // GetCollateral returns an sdk.Coin representing how much of a given denom the
 // x/leverage module account currently holds as collateral for a given borrower.
 func (k Keeper) GetCollateral(ctx sdk.Context, borrowerAddr sdk.AccAddress, denom string) sdk.Coin {
-	key := types.CreateCollateralAmountKey(borrowerAddr, denom)
+	key := types.KeyCollateralAmount(borrowerAddr, denom)
 	amount := k.getStoredInt(ctx, key, "collateral")
 	return sdk.NewCoin(denom, amount)
 }
@@ -144,14 +144,14 @@ func (k Keeper) setCollateral(ctx sdk.Context, borrowerAddr sdk.AccAddress, coll
 	if borrowerAddr.Empty() {
 		return types.ErrEmptyAddress
 	}
-	key := types.CreateCollateralAmountKey(borrowerAddr, collateral.Denom)
+	key := types.KeyCollateralAmount(borrowerAddr, collateral.Denom)
 	return k.setStoredInt(ctx, key, collateral.Amount, "collateral")
 }
 
 // GetReserves gets the reserved amount of a specified token.
 // On invalid asset, the reserved amount is zero.
 func (k Keeper) GetReserves(ctx sdk.Context, denom string) sdk.Coin {
-	key := types.CreateReserveAmountKey(denom)
+	key := types.KeyReserveAmount(denom)
 	amount := k.getStoredInt(ctx, key, "reserves")
 	return sdk.NewCoin(denom, amount)
 }
@@ -162,16 +162,15 @@ func (k Keeper) setReserves(ctx sdk.Context, reserves sdk.Coin) error {
 		return err
 	}
 
-	key := types.CreateReserveAmountKey(reserves.Denom)
+	key := types.KeyReserveAmount(reserves.Denom)
 	return k.setStoredInt(ctx, key, reserves.Amount, "reserves")
 }
 
 // getLastInterestTime returns unix timestamp (in seconds) when the last interest was accrued.
 // Returns 0 if the value if the value is absent.
 func (k Keeper) getLastInterestTime(ctx sdk.Context) int64 {
 	store := ctx.KVStore(k.storeKey)
-	timeKey := types.CreateLastInterestTimeKey()
-	bz := store.Get(timeKey)
+	bz := store.Get(types.KeyPrefixLastInterestTime)
 	if bz == nil {
 		return 0
 	}
@@ -190,8 +189,6 @@ func (k Keeper) getLastInterestTime(ctx sdk.Context) int64 {
 // setLastInterestTime sets LastInterestTime to a given value
 func (k *Keeper) setLastInterestTime(ctx sdk.Context, interestTime int64) error {
 	store := ctx.KVStore(k.storeKey)
-	key := types.CreateLastInterestTimeKey()
-
 	prevTime := k.getLastInterestTime(ctx)
 	if interestTime < prevTime {
 		// prevent time from moving backwards
@@ -204,7 +201,7 @@ func (k *Keeper) setLastInterestTime(ctx sdk.Context, interestTime int64) error
 		return err
 	}
 
-	store.Set(key, bz)
+	store.Set(types.KeyPrefixLastInterestTime, bz)
 	return nil
 }
 
@@ -218,7 +215,7 @@ func (k Keeper) setBadDebtAddress(ctx sdk.Context, addr sdk.AccAddress, denom st
 	}
 
 	store := ctx.KVStore(k.storeKey)
-	key := types.CreateBadDebtKey(denom, addr)
+	key := types.KeyBadDebt(denom, addr)
 
 	if hasDebt {
 		store.Set(key, []byte{0x01})
@@ -231,7 +228,7 @@ func (k Keeper) setBadDebtAddress(ctx sdk.Context, addr sdk.AccAddress, denom st
 // getInterestScalar gets the interest scalar for a given base token
 // denom. Returns 1.0 if no value is stored.
 func (k Keeper) getInterestScalar(ctx sdk.Context, denom string) sdk.Dec {
-	key := types.CreateInterestScalarKey(denom)
+	key := types.KeyInterestScalar(denom)
 	return k.getStoredDec(ctx, key, sdk.OneDec(), "interest scalar")
 }
 
@@ -240,14 +237,14 @@ func (k Keeper) setInterestScalar(ctx sdk.Context, denom string, scalar sdk.Dec)
 	if err := validateBaseDenom(denom); err != nil {
 		return err
 	}
-	key := types.CreateInterestScalarKey(denom)
+	key := types.KeyInterestScalar(denom)
 	return k.setStoredDec(ctx, key, scalar, sdk.OneDec(), "interest scalar")
 }
 
 // GetUTokenSupply gets the total supply of a specified utoken, as tracked by
 // module state. On invalid asset or non-uToken, the supply is zero.
 func (k Keeper) GetUTokenSupply(ctx sdk.Context, denom string) sdk.Coin {
-	key := types.CreateUTokenSupplyKey(denom)
+	key := types.KeyUTokenSupply(denom)
 	amount := k.getStoredInt(ctx, key, "uToken supply")
 	return sdk.NewCoin(denom, amount)
 }
@@ -257,6 +254,6 @@ func (k Keeper) setUTokenSupply(ctx sdk.Context, uToken sdk.Coin) error {
 	if err := validateUToken(uToken); err != nil {
 		return err
 	}
-	key := types.CreateUTokenSupplyKey(uToken.Denom)
+	key := types.KeyUTokenSupply(uToken.Denom)
 	return k.setStoredInt(ctx, key, uToken.Amount, "uToken supply")
 }

x/leverage/keeper/token.go

@@ -13,7 +13,7 @@ func (k Keeper) SetTokenSettings(ctx sdk.Context, token types.Token) error {
 	}
 
 	store := ctx.KVStore(k.storeKey)
-	tokenKey := types.CreateRegisteredTokenKey(token.BaseDenom)
+	tokenKey := types.KeyRegisteredToken(token.BaseDenom)
 
 	bz, err := k.cdc.Marshal(&token)
 	if err != nil {
@@ -28,7 +28,7 @@ func (k Keeper) SetTokenSettings(ctx sdk.Context, token types.Token) error {
 // GetTokenSettings gets a token from the x/leverage module's KVStore.
 func (k Keeper) GetTokenSettings(ctx sdk.Context, denom string) (types.Token, error) {
 	store := ctx.KVStore(k.storeKey)
-	tokenKey := types.CreateRegisteredTokenKey(denom)
+	tokenKey := types.KeyRegisteredToken(denom)
 
 	token := types.Token{}
 	bz := store.Get(tokenKey)

x/leverage/types/keys.go

@@ -3,6 +3,7 @@ package types
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/address"
+	"github.com/umee-network/umee/v3/util"
 )
 
 const (
@@ -32,128 +33,70 @@ var (
 	KeyPrefixUtokenSupply        = []byte{0x0A}
 )
 
-// CreateRegisteredTokenKey returns a KVStore key for getting and setting a Token.
-func CreateRegisteredTokenKey(baseTokenDenom string) []byte {
-	// assetprefix | denom | 0x00
-	var key []byte
-	key = append(key, KeyPrefixRegisteredToken...)
-	key = append(key, []byte(baseTokenDenom)...)
-	return append(key, 0) // append 0 for null-termination
+// KeyRegisteredToken returns a KVStore key for getting and setting a Token.
+func KeyRegisteredToken(baseTokenDenom string) []byte {
+	// assetprefix | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyPrefixRegisteredToken, []byte(baseTokenDenom))
 }
 
-// CreateAdjustedBorrowKey returns a KVStore key for getting and setting an
+// KeyAdjustedBorrow returns a KVStore key for getting and setting an
 // adjusted borrow for a denom and borrower address.
-func CreateAdjustedBorrowKey(borrowerAddr sdk.AccAddress, tokenDenom string) []byte {
-	// borrowprefix | lengthprefixed(borrowerAddr) | denom | 0x00
-	key := CreateAdjustedBorrowKeyNoDenom(borrowerAddr)
-	key = append(key, []byte(tokenDenom)...)
-	return append(key, 0) // append 0 for null-termination
+func KeyAdjustedBorrow(borrowerAddr sdk.AccAddress, tokenDenom string) []byte {
+	// borrowprefix | lengthprefixed(borrowerAddr) | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyAdjustedBorrowNoDenom(borrowerAddr), []byte(tokenDenom))
 }
 
-// CreateAdjustedBorrowKeyNoDenom returns the common prefix used by all borrows
+// KeyAdjustedBorrowNoDenom returns the common prefix used by all borrows
 // associated with a given borrower address.
-func CreateAdjustedBorrowKeyNoDenom(borrowerAddr sdk.AccAddress) []byte {
+func KeyAdjustedBorrowNoDenom(borrower sdk.AccAddress) []byte {
 	// borrowprefix | lengthprefixed(borrowerAddr)
-	var key []byte
-	key = append(key, KeyPrefixAdjustedBorrow...)
-	key = append(key, address.MustLengthPrefix(borrowerAddr)...)
-	return key
+	return util.ConcatBytes(0, KeyPrefixAdjustedBorrow, address.MustLengthPrefix(borrower))
 }
 
-// CreateCollateralAmountKey returns a KVStore key for getting and setting the amount of
+// KeyCollateralAmount returns a KVStore key for getting and setting the amount of
 // collateral stored for a user in a given denom.
-func CreateCollateralAmountKey(addr sdk.AccAddress, uTokenDenom string) []byte {
-	// collateralPrefix | lengthprefixed(addr) | denom | 0x00
-	key := CreateCollateralAmountKeyNoDenom(addr)
-	key = append(key, []byte(uTokenDenom)...)
-	return append(key, 0) // append 0 for null-termination
+func KeyCollateralAmount(addr sdk.AccAddress, uTokenDenom string) []byte {
+	// collateralPrefix | lengthprefixed(addr) | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyCollateralAmountNoDenom(addr), []byte(uTokenDenom))
 }
 
-// CreateCollateralAmountKeyNoDenom returns the common prefix used by all collateral associated
+// KeyCollateralAmountNoDenom returns the common prefix used by all collateral associated
 // with a given address.
-func CreateCollateralAmountKeyNoDenom(addr sdk.AccAddress) []byte {
+func KeyCollateralAmountNoDenom(addr sdk.AccAddress) []byte {
 	// collateralPrefix | lengthprefixed(addr)
-	key := CreateCollateralAmountKeyNoAddress()
-	key = append(key, address.MustLengthPrefix(addr)...)
-	return key
+	return util.ConcatBytes(0, KeyPrefixCollateralAmount, address.MustLengthPrefix(addr))
 }
 
-// CreateCollateralAmountKeyNoAddress returns a safe copy of collateralPrefix
-func CreateCollateralAmountKeyNoAddress() []byte {
-	// collateralPrefix
-	var key []byte
-	key = append(key, KeyPrefixCollateralAmount...)
-	return key
+// KeyReserveAmount returns a KVStore key for getting and setting the amount reserved of a a given token.
+func KeyReserveAmount(tokenDenom string) []byte {
+	// reserveamountprefix | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyPrefixReserveAmount, []byte(tokenDenom))
 }
 
-// CreateReserveAmountKey returns a KVStore key for getting and setting the amount reserved of a a given token.
-func CreateReserveAmountKey(tokenDenom string) []byte {
-	// reserveamountprefix | denom | 0x00
-	key := CreateReserveAmountKeyNoDenom()
-	key = append(key, []byte(tokenDenom)...)
-	return append(key, 0) // append 0 for null-termination
+// KeyBadDebt returns a KVStore key for tracking an address with unpaid bad debt
+func KeyBadDebt(denom string, borrower sdk.AccAddress) []byte {
+	// badDebtAddrPrefix | lengthprefixed(borrowerAddr) | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyPrefixBadDebt, address.MustLengthPrefix(borrower), []byte(denom))
 }
 
-// CreateReserveAmountKeyNoDenom returns a safe copy of reserveAmountPrefix
-func CreateReserveAmountKeyNoDenom() []byte {
-	// reserveAmountPrefix
-	var key []byte
-	key = append(key, KeyPrefixReserveAmount...)
-	return key
-}
-
-// CreateLastInterestTimeKey returns a KVStore key for getting and setting the amount reserved of a a given token.
-func CreateLastInterestTimeKey() []byte {
-	// lastinterestprefix
-	var key []byte
-	key = append(key, KeyPrefixLastInterestTime...)
-	return key
-}
-
-// CreateBadDebtKey returns a KVStore key for tracking an address with unpaid bad debt
-func CreateBadDebtKey(denom string, borrowerAddr sdk.AccAddress) []byte {
-	// badDebtAddrPrefix | lengthprefixed(borrowerAddr) | denom | 0x00
-	key := CreateBadDebtKeyNoAddress()
-	key = append(key, address.MustLengthPrefix(borrowerAddr)...)
-	key = append(key, []byte(denom)...)
-	return append(key, 0) // append 0 for null-termination
-}
-
-// CreateBadDebtKeyNoAddress returns a safe copy of bad debt prefix
-func CreateBadDebtKeyNoAddress() []byte {
-	// badDebtPrefix
-	var key []byte
-	key = append(key, KeyPrefixBadDebt...)
-	return key
-}
-
-// CreateInterestScalarKey returns a KVStore key for getting and setting the interest scalar for a
+// KeyInterestScalar returns a KVStore key for getting and setting the interest scalar for a
 // given token.
-func CreateInterestScalarKey(tokenDenom string) []byte {
-	// interestScalarPrefix | denom | 0x00
-	var key []byte
-	key = append(key, KeyPrefixInterestScalar...)
-	key = append(key, []byte(tokenDenom)...)
-	return append(key, 0) // append 0 for null-termination
+func KeyInterestScalar(tokenDenom string) []byte {
+	// interestScalarPrefix | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyPrefixInterestScalar, []byte(tokenDenom))
 }
 
-// CreateAdjustedTotalBorrowKey returns a KVStore key for getting and setting the total ajdusted borrows for
+// KeyAdjustedTotalBorrow returns a KVStore key for getting and setting the total ajdusted borrows for
 // a given token.
-func CreateAdjustedTotalBorrowKey(tokenDenom string) []byte {
-	// totalBorrowedPrefix | denom | 0x00
-	var key []byte
-	key = append(key, KeyPrefixAdjustedTotalBorrow...)
-	key = append(key, []byte(tokenDenom)...)
-	return append(key, 0) // append 0 for null-termination
+func KeyAdjustedTotalBorrow(tokenDenom string) []byte {
+	// totalBorrowedPrefix | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyPrefixAdjustedTotalBorrow, []byte(tokenDenom))
 }
 
-// CreateUTokenSupplyKey returns a KVStore key for getting and setting a utoken's total supply.
-func CreateUTokenSupplyKey(uTokenDenom string) []byte {
-	// supplyprefix | denom | 0x00
-	var key []byte
-	key = append(key, KeyPrefixUtokenSupply...)
-	key = append(key, []byte(uTokenDenom)...)
-	return append(key, 0) // append 0 for null-termination
+// KeyUTokenSupply returns a KVStore key for getting and setting a utoken's total supply.
+func KeyUTokenSupply(uTokenDenom string) []byte {
+	// supplyprefix | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyPrefixUtokenSupply, []byte(uTokenDenom))
 }
 
 // AddressFromKey extracts address from a key with the form