chore!: refactore store key constructors

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/store.go

@@ -170,8 +170,7 @@ func (k Keeper) setReserves(ctx sdk.Context, reserves sdk.Coin) error {
 // 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
 }
 

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 (
@@ -34,36 +35,30 @@ var (
 
 // 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
+	// assetprefix | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyPrefixRegisteredToken, []byte(baseTokenDenom))
 }
 
 // CreateAdjustedBorrowKey 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
+	// borrowprefix | lengthprefixed(borrowerAddr) | denom | 0x00 for null-termination
 	key := CreateAdjustedBorrowKeyNoDenom(borrowerAddr)
 	key = append(key, []byte(tokenDenom)...)
 	return append(key, 0) // append 0 for null-termination
 }
 
 // CreateAdjustedBorrowKeyNoDenom returns the common prefix used by all borrows
 // associated with a given borrower address.
-func CreateAdjustedBorrowKeyNoDenom(borrowerAddr sdk.AccAddress) []byte {
+func CreateAdjustedBorrowKeyNoDenom(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
 // collateral stored for a user in a given denom.
 func CreateCollateralAmountKey(addr sdk.AccAddress, uTokenDenom string) []byte {
-	// collateralPrefix | lengthprefixed(addr) | denom | 0x00
+	// collateralPrefix | lengthprefixed(addr) | denom | 0x00 for null-termination
 	key := CreateCollateralAmountKeyNoDenom(addr)
 	key = append(key, []byte(uTokenDenom)...)
 	return append(key, 0) // append 0 for null-termination
@@ -73,87 +68,39 @@ func CreateCollateralAmountKey(addr sdk.AccAddress, uTokenDenom string) []byte {
 // with a given address.
 func CreateCollateralAmountKeyNoDenom(addr sdk.AccAddress) []byte {
 	// collateralPrefix | lengthprefixed(addr)
-	key := CreateCollateralAmountKeyNoAddress()
-	key = append(key, address.MustLengthPrefix(addr)...)
-	return key
-}
-
-// CreateCollateralAmountKeyNoAddress returns a safe copy of collateralPrefix
-func CreateCollateralAmountKeyNoAddress() []byte {
-	// collateralPrefix
-	var key []byte
-	key = append(key, KeyPrefixCollateralAmount...)
-	return key
+	return util.ConcatBytes(0, KeyPrefixCollateralAmount, address.MustLengthPrefix(addr))
 }
 
 // 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
-}
-
-// 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
+	// reserveamountprefix | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyPrefixReserveAmount, []byte(tokenDenom))
 }
 
 // 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
+func CreateBadDebtKey(denom string, borrower sdk.AccAddress) []byte {
+	// badDebtAddrPrefix | lengthprefixed(borrowerAddr) | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyPrefixBadDebt, address.MustLengthPrefix(borrower), []byte(denom))
 }
 
 // CreateInterestScalarKey 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
+	// 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
 // 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
+	// 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
+	// supplyprefix | denom | 0x00 for null-termination
+	return util.ConcatBytes(1, KeyPrefixUtokenSupply, []byte(uTokenDenom))
 }
 
 // AddressFromKey extracts address from a key with the form

x/oracle/keeper/historic_price.go

@@ -55,7 +55,7 @@ func (k Keeper) GetMedian(
 	blockNum uint64,
 ) (sdk.Dec, error) {
 	store := ctx.KVStore(k.storeKey)
-	bz := store.Get(types.MedianKey(denom, blockNum))
+	bz := store.Get(types.KeyMedian(denom, blockNum))
 	if bz == nil {
 		return sdk.ZeroDec(), sdkerrors.Wrap(types.ErrNoMedian, fmt.Sprintf("denom: %s block: %d", denom, blockNum))
 	}
@@ -78,7 +78,7 @@ func (k Keeper) SetMedian(
 	historicPrices := k.getHistoricPrices(ctx, denom)
 	median := median(historicPrices)
 	bz := k.cdc.MustMarshal(&sdk.DecProto{Dec: median})
-	store.Set(types.MedianKey(denom, uint64(ctx.BlockHeight())), bz)
+	store.Set(types.KeyMedian(denom, uint64(ctx.BlockHeight())), bz)
 	k.setMedianDeviation(ctx, denom, median, historicPrices)
 }
 
@@ -90,7 +90,7 @@ func (k Keeper) GetMedianDeviation(
 	blockNum uint64,
 ) (sdk.Dec, error) {
 	store := ctx.KVStore(k.storeKey)
-	bz := store.Get(types.MedianDeviationKey(denom, blockNum))
+	bz := store.Get(types.KeyMedianDeviation(denom, blockNum))
 	if bz == nil {
 		return sdk.ZeroDec(), sdkerrors.Wrap(types.ErrNoMedianDeviation, fmt.Sprintf("denom: %s block: %d", denom, blockNum))
 	}
@@ -112,7 +112,7 @@ func (k Keeper) setMedianDeviation(
 	store := ctx.KVStore(k.storeKey)
 	medianDeviation := medianDeviation(median, prices)
 	bz := k.cdc.MustMarshal(&sdk.DecProto{Dec: medianDeviation})
-	store.Set(types.MedianDeviationKey(denom, uint64(ctx.BlockHeight())), bz)
+	store.Set(types.KeyMedianDeviation(denom, uint64(ctx.BlockHeight())), bz)
 }
 
 // getHistoricPrices returns all the historic prices of a given denom.
@@ -171,7 +171,7 @@ func (k Keeper) AddHistoricPrice(
 		ExchangeRate: exchangeRate,
 		BlockNum:     block,
 	})
-	store.Set(types.HistoricPriceKey(denom, block), bz)
+	store.Set(types.KeyHistoricPrice(denom, block), bz)
 }
 
 // DeleteHistoricPrice deletes the historic price of a denom at a
@@ -182,7 +182,7 @@ func (k Keeper) DeleteHistoricPrice(
 	blockNum uint64,
 ) {
 	store := ctx.KVStore(k.storeKey)
-	store.Delete(types.HistoricPriceKey(denom, blockNum))
+	store.Delete(types.KeyHistoricPrice(denom, blockNum))
 }
 
 // DeleteMedian deletes a given denom's median price in the last prune
@@ -193,7 +193,7 @@ func (k Keeper) DeleteMedian(
 	blockNum uint64,
 ) {
 	store := ctx.KVStore(k.storeKey)
-	store.Delete(types.MedianKey(denom, blockNum))
+	store.Delete(types.KeyMedian(denom, blockNum))
 }
 
 // DeleteMedianDeviation deletes a given denom's standard deviation around
@@ -204,5 +204,5 @@ func (k Keeper) DeleteMedianDeviation(
 	blockNum uint64,
 ) {
 	store := ctx.KVStore(k.storeKey)
-	store.Delete(types.MedianDeviationKey(denom, blockNum))
+	store.Delete(types.KeyMedianDeviation(denom, blockNum))
 }