mirror of
				https://github.com/0glabs/0g-chain.git
				synced 2025-11-04 00:17:27 +00:00 
			
		
		
		
	
		
			
				
	
	
		
			243 lines
		
	
	
		
			7.1 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
			
		
		
	
	
			243 lines
		
	
	
		
			7.1 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
package keeper
 | 
						|
 | 
						|
import (
 | 
						|
	"fmt"
 | 
						|
	"sort"
 | 
						|
	"time"
 | 
						|
 | 
						|
	"github.com/tendermint/tendermint/libs/log"
 | 
						|
 | 
						|
	"github.com/cosmos/cosmos-sdk/codec"
 | 
						|
	"github.com/cosmos/cosmos-sdk/store/prefix"
 | 
						|
	sdk "github.com/cosmos/cosmos-sdk/types"
 | 
						|
	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 | 
						|
	"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
 | 
						|
}
 | 
						|
 | 
						|
// NewKeeper returns a new keeper for the pricefeed module.
 | 
						|
func NewKeeper(
 | 
						|
	cdc *codec.Codec, key sdk.StoreKey, paramstore subspace.Subspace,
 | 
						|
) Keeper {
 | 
						|
	if !paramstore.HasKeyTable() {
 | 
						|
		paramstore = paramstore.WithKeyTable(types.ParamKeyTable())
 | 
						|
	}
 | 
						|
 | 
						|
	return Keeper{
 | 
						|
		cdc:           cdc,
 | 
						|
		key:           key,
 | 
						|
		paramSubspace: paramstore,
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
// Logger returns a module-specific logger.
 | 
						|
func (k Keeper) Logger(ctx sdk.Context) log.Logger {
 | 
						|
	return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
 | 
						|
}
 | 
						|
 | 
						|
// 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, error) {
 | 
						|
	// If the expiry is less than or equal to the current blockheight, we consider the price valid
 | 
						|
	if !expiry.After(ctx.BlockTime()) {
 | 
						|
		return types.PostedPrice{}, types.ErrExpired
 | 
						|
	}
 | 
						|
 | 
						|
	store := ctx.KVStore(k.key)
 | 
						|
	prices, err := k.GetRawPrices(ctx, marketID)
 | 
						|
	if err != nil {
 | 
						|
		return types.PostedPrice{}, err
 | 
						|
	}
 | 
						|
	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, expiry.UTC().String()),
 | 
						|
		),
 | 
						|
	)
 | 
						|
 | 
						|
	store.Set(types.RawPriceKey(marketID), k.cdc.MustMarshalBinaryBare(prices))
 | 
						|
	return prices[index], nil
 | 
						|
}
 | 
						|
 | 
						|
// SetCurrentPrices updates the price of an asset to the median of all valid oracle inputs
 | 
						|
func (k Keeper) SetCurrentPrices(ctx sdk.Context, marketID string) error {
 | 
						|
	_, ok := k.GetMarket(ctx, marketID)
 | 
						|
	if !ok {
 | 
						|
		return sdkerrors.Wrap(types.ErrInvalidMarket, marketID)
 | 
						|
	}
 | 
						|
	// store current price
 | 
						|
	validPrevPrice := true
 | 
						|
	prevPrice, err := k.GetCurrentPrice(ctx, marketID)
 | 
						|
	if err != nil {
 | 
						|
		validPrevPrice = false
 | 
						|
	}
 | 
						|
 | 
						|
	prices, err := k.GetRawPrices(ctx, marketID)
 | 
						|
	if err != nil {
 | 
						|
		return err
 | 
						|
	}
 | 
						|
	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 {
 | 
						|
		// NOTE: The current price stored will continue storing the most recent (expired)
 | 
						|
		// price if this is not set.
 | 
						|
		// This zero's out the current price stored value for that market and ensures
 | 
						|
		// that CDP methods that GetCurrentPrice will return error.
 | 
						|
		k.setCurrentPrice(ctx, marketID, types.CurrentPrice{})
 | 
						|
		return types.ErrNoValidPrice
 | 
						|
	}
 | 
						|
 | 
						|
	medianPrice := k.CalculateMedianPrice(ctx, notExpiredPrices)
 | 
						|
 | 
						|
	// check case that market price was not set in genesis
 | 
						|
	if validPrevPrice && !medianPrice.Equal(prevPrice.Price) {
 | 
						|
		// only emit event if price has changed
 | 
						|
		ctx.EventManager().EmitEvent(
 | 
						|
			sdk.NewEvent(
 | 
						|
				types.EventTypeMarketPriceUpdated,
 | 
						|
				sdk.NewAttribute(types.AttributeMarketID, marketID),
 | 
						|
				sdk.NewAttribute(types.AttributeMarketPrice, medianPrice.String()),
 | 
						|
			),
 | 
						|
		)
 | 
						|
	}
 | 
						|
 | 
						|
	currentPrice := types.NewCurrentPrice(marketID, medianPrice)
 | 
						|
	k.setCurrentPrice(ctx, marketID, currentPrice)
 | 
						|
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (k Keeper) setCurrentPrice(ctx sdk.Context, marketID string, currentPrice types.CurrentPrice) {
 | 
						|
	store := ctx.KVStore(k.key)
 | 
						|
	store.Set(types.CurrentPriceKey(marketID), k.cdc.MustMarshalBinaryBare(currentPrice))
 | 
						|
}
 | 
						|
 | 
						|
// 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, error) {
 | 
						|
	store := ctx.KVStore(k.key)
 | 
						|
	bz := store.Get(types.CurrentPriceKey(marketID))
 | 
						|
 | 
						|
	if bz == nil {
 | 
						|
		return types.CurrentPrice{}, types.ErrNoValidPrice
 | 
						|
	}
 | 
						|
	var price types.CurrentPrice
 | 
						|
	err := k.cdc.UnmarshalBinaryBare(bz, &price)
 | 
						|
	if err != nil {
 | 
						|
		return types.CurrentPrice{}, err
 | 
						|
	}
 | 
						|
	if price.Price.Equal(sdk.ZeroDec()) {
 | 
						|
		return types.CurrentPrice{}, types.ErrNoValidPrice
 | 
						|
	}
 | 
						|
	return price, nil
 | 
						|
}
 | 
						|
 | 
						|
// IterateCurrentPrices iterates over all current price objects in the store and performs a callback function
 | 
						|
func (k Keeper) IterateCurrentPrices(ctx sdk.Context, cb func(cp types.CurrentPrice) (stop bool)) {
 | 
						|
	store := prefix.NewStore(ctx.KVStore(k.key), types.CurrentPricePrefix)
 | 
						|
	iterator := sdk.KVStorePrefixIterator(store, []byte{})
 | 
						|
	defer iterator.Close()
 | 
						|
	for ; iterator.Valid(); iterator.Next() {
 | 
						|
		var cp types.CurrentPrice
 | 
						|
		k.cdc.MustUnmarshalBinaryBare(iterator.Value(), &cp)
 | 
						|
		if cb(cp) {
 | 
						|
			break
 | 
						|
		}
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
// GetCurrentPrices returns all current price objects from the store
 | 
						|
func (k Keeper) GetCurrentPrices(ctx sdk.Context) types.CurrentPrices {
 | 
						|
	cps := types.CurrentPrices{}
 | 
						|
	k.IterateCurrentPrices(ctx, func(cp types.CurrentPrice) (stop bool) {
 | 
						|
		cps = append(cps, cp)
 | 
						|
		return false
 | 
						|
	})
 | 
						|
	return cps
 | 
						|
}
 | 
						|
 | 
						|
// GetRawPrices fetches the set of all prices posted by oracles for an asset
 | 
						|
func (k Keeper) GetRawPrices(ctx sdk.Context, marketID string) (types.PostedPrices, error) {
 | 
						|
	store := ctx.KVStore(k.key)
 | 
						|
	bz := store.Get(types.RawPriceKey(marketID))
 | 
						|
	if bz == nil {
 | 
						|
		return types.PostedPrices{}, nil
 | 
						|
	}
 | 
						|
	var prices types.PostedPrices
 | 
						|
	err := k.cdc.UnmarshalBinaryBare(bz, &prices)
 | 
						|
	if err != nil {
 | 
						|
		return types.PostedPrices{}, err
 | 
						|
	}
 | 
						|
	return prices, nil
 | 
						|
}
 |