0g-chain/x/pricefeed/keeper/keeper.go

package keeper

import (
	"fmt"
	"sort"
	"time"

	"github.com/cosmos/cosmos-sdk/codec"
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/cosmos/cosmos-sdk/x/params/subspace"

	"github.com/kava-labs/kava/x/pricefeed/types"
)

// Keeper struct for pricefeed module
type Keeper struct {
	// key used to access the stores from Context
	key sdk.StoreKey
	// Codec for binary encoding/decoding
	cdc *codec.Codec
	// The reference to the Paramstore to get and set pricefeed specific params
	paramSubspace subspace.Subspace
	// Reserved codespace
	codespace sdk.CodespaceType
}

// NewKeeper returns a new keeper for the pricefeed module.
func NewKeeper(
	cdc *codec.Codec, key sdk.StoreKey, paramSubspace subspace.Subspace, codespace sdk.CodespaceType,
) Keeper {
	return Keeper{
		paramSubspace: paramSubspace.WithKeyTable(types.ParamKeyTable()),
		key:           key,
		cdc:           cdc,
		codespace:     codespace,
	}
}

// SetPrice updates the posted price for a specific oracle
func (k Keeper) SetPrice(
	ctx sdk.Context,
	oracle sdk.AccAddress,
	marketID string,
	price sdk.Dec,
	expiry time.Time) (types.PostedPrice, sdk.Error) {
	// If the expiry is less than or equal to the current blockheight, we consider the price valid
	if expiry.After(ctx.BlockTime()) {
		store := ctx.KVStore(k.key)
		prices := k.GetRawPrices(ctx, marketID)
		var index int
		found := false
		for i := range prices {
			if prices[i].OracleAddress.Equals(oracle) {
				index = i
				found = true
				break
			}
		}
		// set the price for that particular oracle
		if found {
			prices[index] = types.NewPostedPrice(marketID, oracle, price, expiry)
		} else {
			prices = append(prices, types.NewPostedPrice(marketID, oracle, price, expiry))
			index = len(prices) - 1
		}

		// Emit an event containing the oracle's new price
		ctx.EventManager().EmitEvent(
			sdk.NewEvent(
				types.EventTypeOracleUpdatedPrice,
				sdk.NewAttribute(types.AttributeMarketID, marketID),
				sdk.NewAttribute(types.AttributeOracle, oracle.String()),
				sdk.NewAttribute(types.AttributeMarketPrice, price.String()),
				sdk.NewAttribute(types.AttributeExpiry, fmt.Sprintf("%d", expiry.Unix())),
			),
		)
		store.Set(
			types.RawPriceKey(marketID), k.cdc.MustMarshalBinaryBare(prices),
		)
		return prices[index], nil
	}
	return types.PostedPrice{}, types.ErrExpired(k.codespace)

}

// SetCurrentPrices updates the price of an asset to the median of all valid oracle inputs
func (k Keeper) SetCurrentPrices(ctx sdk.Context, marketID string) sdk.Error {
	_, ok := k.GetMarket(ctx, marketID)
	if !ok {
		return types.ErrInvalidMarket(k.codespace, marketID)
	}
	// store current price
	validPrevPrice := true
	prevPrice, err := k.GetCurrentPrice(ctx, marketID)
	if err != nil {
		validPrevPrice = false
	}

	prices := k.GetRawPrices(ctx, marketID)
	var notExpiredPrices types.CurrentPrices
	// filter out expired prices
	for _, v := range prices {
		if v.Expiry.After(ctx.BlockTime()) {
			notExpiredPrices = append(notExpiredPrices, types.NewCurrentPrice(v.MarketID, v.Price))
		}
	}
	if len(notExpiredPrices) == 0 {
		store := ctx.KVStore(k.key)
		store.Set(
			types.CurrentPriceKey(marketID), k.cdc.MustMarshalBinaryBare(types.CurrentPrice{}),
		)
		return types.ErrNoValidPrice(k.codespace)
	}
	medianPrice := k.CalculateMedianPrice(ctx, notExpiredPrices)

	// check case that market price was not set in genesis
	if validPrevPrice {
		// only emit event if price has changed
		if !medianPrice.Equal(prevPrice.Price) {
			ctx.EventManager().EmitEvent(
				sdk.NewEvent(
					types.EventTypeMarketPriceUpdated,
					sdk.NewAttribute(types.AttributeMarketID, fmt.Sprintf("%s", marketID)),
					sdk.NewAttribute(types.AttributeMarketPrice, fmt.Sprintf("%s", medianPrice.String())),
				),
			)
		}
	}

	store := ctx.KVStore(k.key)
	currentPrice := types.NewCurrentPrice(marketID, medianPrice)

	store.Set(
		types.CurrentPriceKey(marketID), k.cdc.MustMarshalBinaryBare(currentPrice),
	)

	return nil
}

// CalculateMedianPrice calculates the median prices for the input prices.
func (k Keeper) CalculateMedianPrice(ctx sdk.Context, prices types.CurrentPrices) sdk.Dec {
	l := len(prices)

	if l == 1 {
		// Return immediately if there's only one price
		return prices[0].Price
	}
	// sort the prices
	sort.Slice(prices, func(i, j int) bool {
		return prices[i].Price.LT(prices[j].Price)
	})
	// for even numbers of prices, the median is calculated as the mean of the two middle prices
	if l%2 == 0 {
		median := k.calculateMeanPrice(ctx, prices[l/2-1:l/2+1])
		return median
	}
	// for odd numbers of prices, return the middle element
	return prices[l/2].Price

}

func (k Keeper) calculateMeanPrice(ctx sdk.Context, prices types.CurrentPrices) sdk.Dec {
	sum := prices[0].Price.Add(prices[1].Price)
	mean := sum.Quo(sdk.NewDec(2))
	return mean
}

// GetCurrentPrice fetches the current median price of all oracles for a specific market
func (k Keeper) GetCurrentPrice(ctx sdk.Context, marketID string) (types.CurrentPrice, sdk.Error) {
	store := ctx.KVStore(k.key)
	bz := store.Get(types.CurrentPriceKey(marketID))

	if bz == nil {
		return types.CurrentPrice{}, types.ErrNoValidPrice(k.codespace)
	}
	var price types.CurrentPrice
	k.cdc.MustUnmarshalBinaryBare(bz, &price)
	if price.Price.Equal(sdk.ZeroDec()) {
		return types.CurrentPrice{}, types.ErrNoValidPrice(k.codespace)
	}
	return price, nil
}

// GetRawPrices fetches the set of all prices posted by oracles for an asset
func (k Keeper) GetRawPrices(ctx sdk.Context, marketID string) types.PostedPrices {
	store := ctx.KVStore(k.key)
	bz := store.Get(types.RawPriceKey(marketID))
	var prices types.PostedPrices
	k.cdc.MustUnmarshalBinaryBare(bz, &prices)
	return prices
}

// Codespace return the codespace for the keeper
func (k Keeper) Codespace() sdk.CodespaceType {
	return k.codespace
}