updating oracle end blocker to have only latest price and optimizations (#1333)

* optimizing oracle module asset price

* adding unit test cases

* updating oracle end blocker to have only latest price

* updating comment

Author: avkr003

app/setup_handlers.go

@@ -13,13 +13,9 @@ import (
 )
 
 const (
-	LocalNetVersion = "v999999"
-	NewMaxBytes     = 5 * 1024 * 1024 // 5MB
+	NewMaxBytes = 5 * 1024 * 1024 // 5MB
 )
 
-// make sure to update these when you upgrade the version
-var NextVersion = "vNEXT"
-
 // generate upgrade version from the current version (v999999.999999.999999 => v999999)
 func generateUpgradeVersion() string {
 	currentVersion := version.Version
@@ -68,6 +64,8 @@ func (app *ElysApp) setUpgradeHandler() {
 
 			vm, vmErr := app.mm.RunMigrations(ctx, app.configurator, vm)
 
+			app.OracleKeeper.EndBlock(ctx)
+
 			//oracleParams := app.OracleKeeper.GetParams(ctx)
 			//if len(oracleParams.MandatoryList) == 0 {
 			//	err := app.ojoOracleMigration(ctx, plan.Height+1)

x/amm/types/expected_keepers.go

@@ -40,7 +40,7 @@ type BankKeeper interface {
 //
 //go:generate mockery --srcpkg . --name OracleKeeper --structname OracleKeeper --filename oracle_keeper.go --with-expecter
 type OracleKeeper interface {
-	GetAssetPrice(ctx sdk.Context, asset string) (osmomath.BigDec, bool)
+	GetAssetPrice(ctx sdk.Context, asset string) (sdkmath.LegacyDec, bool)
 	GetDenomPrice(ctx sdk.Context, denom string) osmomath.BigDec
 	GetPriceFeeder(ctx sdk.Context, feeder sdk.AccAddress) (val oracletypes.PriceFeeder, found bool)
 	//SetPool(ctx sdk.Context, pool oracletypes.Pool)

x/amm/types/mocks/accounted_pool_keeper.go

@@ -99,7 +99,7 @@ type AmmKeeper interface {
 
 // OracleKeeper defines the expected interface needed to retrieve price info
 type OracleKeeper interface {
-	GetAssetPrice(ctx sdk.Context, asset string) (osmomath.BigDec, bool)
+	GetAssetPrice(ctx sdk.Context, asset string) (math.LegacyDec, bool)
 	GetDenomPrice(ctx sdk.Context, denom string) osmomath.BigDec
 	GetPriceFeeder(ctx sdk.Context, feeder sdk.AccAddress) (val oracletypes.PriceFeeder, found bool)
 	//SetPool(ctx sdk.Context, pool oracletypes.Pool)

x/amm/types/mocks/oracle_keeper.go

@@ -2,14 +2,28 @@ package keeper
 
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"sort"
 )
 
 func (k Keeper) EndBlock(ctx sdk.Context) {
-	// Remove outdated prices
-	params := k.GetParams(ctx)
-	for _, price := range k.GetAllPrice(ctx) {
-		if price.Timestamp+params.PriceExpiryTime < uint64(ctx.BlockTime().Unix()) || price.BlockHeight+params.LifeTimeInBlocks < uint64(ctx.BlockHeight()) {
-			k.RemovePrice(ctx, price.Asset, price.Source, price.Timestamp)
+
+	assetInfos := k.GetAllAssetInfo(ctx)
+
+	for _, info := range assetInfos {
+		allAssetPrice := k.GetAllAssetPrice(ctx, info.Display)
+		total := len(allAssetPrice)
+
+		// Need to sort it because order fetched from GetAllAssetPrice will not be in ascending order - depending on source
+		// If we remove the source then this should not be needed
+		sort.Slice(allAssetPrice, func(i, j int) bool {
+			return allAssetPrice[i].Timestamp < allAssetPrice[j].Timestamp
+		})
+
+		for i, price := range allAssetPrice {
+			// We don't remove the last element
+			if i < total-1 {
+				k.RemovePrice(ctx, price.Asset, price.Source, price.Timestamp)
+			}
 		}
 	}
 }

x/masterchef/types/expected_keepers.go

@@ -1,44 +1,113 @@
 package keeper_test
 
 import (
-	"time"
-
 	sdkmath "cosmossdk.io/math"
+	"sort"
 
 	"github.com/elys-network/elys/v6/x/oracle/types"
 )
 
 // This test ensures old price data is automatically removed
 func (suite *KeeperTestSuite) TestEndBlock() {
-	now := time.Now()
-	params := types.DefaultParams()
-	suite.app.OracleKeeper.SetParams(suite.ctx, params)
-
-	prices := []types.Price{
+	btcPriceData := []types.Price{
 		{
 			Asset:     "BTC",
-			Price:     sdkmath.LegacyNewDec(1),
+			Price:     sdkmath.LegacyNewDec(23),
 			Source:    "elys",
-			Timestamp: uint64(now.Unix()),
+			Timestamp: 20,
 		},
 		{
 			Asset:     "BTC",
-			Price:     sdkmath.LegacyNewDec(2),
+			Price:     sdkmath.LegacyNewDec(12),
 			Source:    "band",
-			Timestamp: uint64(now.Unix()) + params.PriceExpiryTime,
+			Timestamp: 10,
+		},
+		{
+			Asset:     "BTC",
+			Price:     sdkmath.LegacyNewDec(76),
+			Source:    "elys",
+			Timestamp: 40,
 		},
 		{
 			Asset:     "BTC",
-			Price:     sdkmath.LegacyNewDec(3),
+			Price:     sdkmath.LegacyNewDec(55),
 			Source:    "band",
-			Timestamp: uint64(now.Unix()) + params.PriceExpiryTime,
+			Timestamp: 30,
+		},
+		{
+			Asset:     "BTC",
+			Price:     sdkmath.LegacyNewDec(89),
+			Source:    "random",
+			Timestamp: 25,
 		},
 	}
-	for _, price := range prices {
+	ethPriceData := []types.Price{
+		{
+			Asset:     "ETH",
+			Price:     sdkmath.LegacyNewDec(23),
+			Source:    "elys",
+			Timestamp: 34,
+		},
+		{
+			Asset:     "ETH",
+			Price:     sdkmath.LegacyNewDec(12),
+			Source:    "band",
+			Timestamp: 23,
+		},
+		{
+			Asset:     "ETH",
+			Price:     sdkmath.LegacyNewDec(76),
+			Source:    "elys",
+			Timestamp: 89,
+		},
+		{
+			Asset:     "ETH",
+			Price:     sdkmath.LegacyNewDec(55),
+			Source:    "random",
+			Timestamp: 54,
+		},
+		{
+			Asset:     "ETH",
+			Price:     sdkmath.LegacyNewDec(89),
+			Source:    "band",
+			Timestamp: 76,
+		},
+	}
+	suite.app.OracleKeeper.SetAssetInfo(suite.ctx, types.AssetInfo{
+		Denom:      "satoshi",
+		Display:    "BTC",
+		BandTicker: "BTC",
+		ElysTicker: "BTC",
+		Decimal:    8,
+	})
+	suite.app.OracleKeeper.SetAssetInfo(suite.ctx, types.AssetInfo{
+		Denom:      "wei",
+		Display:    "ETH",
+		BandTicker: "ETH",
+		ElysTicker: "ETH",
+		Decimal:    18,
+	})
+	for _, price := range btcPriceData {
+		suite.app.OracleKeeper.SetPrice(suite.ctx, price)
+	}
+	for _, price := range ethPriceData {
 		suite.app.OracleKeeper.SetPrice(suite.ctx, price)
 	}
-	suite.ctx = suite.ctx.WithBlockTime(now.Add(time.Second * time.Duration(params.PriceExpiryTime)))
 
-	prices = suite.app.OracleKeeper.GetAllPrice(suite.ctx)
-	suite.Require().Len(prices, 2)
+	suite.app.OracleKeeper.EndBlock(suite.ctx)
+
+	sort.Slice(btcPriceData, func(i, j int) bool {
+		return btcPriceData[i].Timestamp < btcPriceData[j].Timestamp
+	})
+	sort.Slice(ethPriceData, func(i, j int) bool {
+		return ethPriceData[i].Timestamp < ethPriceData[j].Timestamp
+	})
+
+	allPrices := suite.app.OracleKeeper.GetAllAssetPrice(suite.ctx, "BTC")
+	suite.Require().Equal(1, len(allPrices))
+	suite.Require().Equal(btcPriceData[len(btcPriceData)-1], allPrices[0])
+
+	allPrices = suite.app.OracleKeeper.GetAllAssetPrice(suite.ctx, "ETH")
+	suite.Require().Equal(1, len(allPrices))
+	suite.Require().Equal(ethPriceData[len(ethPriceData)-1], allPrices[0])
 }

x/oracle/keeper/abci.go

@@ -1,6 +1,7 @@
 package keeper
 
 import (
+	"cosmossdk.io/math"
 	"cosmossdk.io/store/prefix"
 	storetypes "cosmossdk.io/store/types"
 	"github.com/cosmos/cosmos-sdk/runtime"
@@ -80,48 +81,40 @@ func (k Keeper) GetAllPrice(ctx sdk.Context) (list []types.Price) {
 	return
 }
 
-// MigrateAllLegacyPrices migrates all legacy prices
-func (k Keeper) MigrateAllLegacyPrices(ctx sdk.Context) {
-	store := prefix.NewStore(runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx)), types.KeyPrefix(types.PriceKeyPrefix))
+func (k Keeper) GetAllAssetPrice(ctx sdk.Context, asset string) (list []types.Price) {
+	store := prefix.NewStore(runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx)), types.PriceKeyPrefixAsset(asset))
 	iterator := storetypes.KVStorePrefixIterator(store, []byte{})
 
 	defer iterator.Close()
 
 	for ; iterator.Valid(); iterator.Next() {
-		var val types.LegacyPrice
+		var val types.Price
 		k.cdc.MustUnmarshal(iterator.Value(), &val)
-		k.SetPrice(ctx, types.Price{
-			Asset:       val.Asset,
-			Price:       val.Price,
-			Source:      val.Source,
-			Provider:    val.Provider,
-			Timestamp:   val.Timestamp,
-			BlockHeight: uint64(ctx.BlockHeight()),
-		})
+		list = append(list, val)
 	}
 
 	return
 }
 
-func (k Keeper) GetAssetPrice(ctx sdk.Context, asset string) (osmomath.BigDec, bool) {
+func (k Keeper) GetAssetPrice(ctx sdk.Context, asset string) (math.LegacyDec, bool) {
 	// try out elys source
 	val, found := k.GetLatestPriceFromAssetAndSource(ctx, asset, types.ELYS)
 	if found {
-		return osmomath.BigDecFromDec(val.Price), true
+		return val.Price, true
 	}
 
 	// try out band source
 	val, found = k.GetLatestPriceFromAssetAndSource(ctx, asset, types.BAND)
 	if found {
-		return osmomath.BigDecFromDec(val.Price), true
+		return val.Price, true
 	}
 
 	// find from any source if band source does not exist
 	price, found := k.GetLatestPriceFromAnySource(ctx, asset)
 	if found {
-		return osmomath.BigDecFromDec(price.Price), true
+		return price.Price, true
 	}
-	return osmomath.BigDec{}, false
+	return math.LegacyDec{}, false
 }
 
 func (k Keeper) GetDenomPrice(ctx sdk.Context, denom string) osmomath.BigDec {
@@ -134,7 +127,7 @@ func (k Keeper) GetDenomPrice(ctx sdk.Context, denom string) osmomath.BigDec {
 		return osmomath.ZeroBigDec()
 	}
 	if info.Decimal <= 18 {
-		return price.QuoInt64(utils.Pow10Int64(info.Decimal))
+		return osmomath.BigDecFromDec(price).QuoInt64(utils.Pow10Int64(info.Decimal))
 	}
-	return price.Quo(utils.Pow10(info.Decimal))
+	return osmomath.BigDecFromDec(price).Quo(utils.Pow10(info.Decimal))
 }