refactor(oracle): use collections

CHANGELOG.md

@@ -47,6 +47,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### State Machine Breaking
 
+* [#994](https://github.com/NibiruChain/nibiru/pull/994) - x/oracle refactor to use collections
 * [#991](https://github.com/NibiruChain/nibiru/pull/991) - collections refactoring of keys and values
 * [#978](https://github.com/NibiruChain/nibiru/pull/978) - x/vpool move state logic to collections
 * [#977](https://github.com/NibiruChain/nibiru/pull/977) - x/perp add whitelisted liquidators

collections/keys.go

@@ -17,6 +17,8 @@ var (
 	TimeKeyEncoder KeyEncoder[time.Time] = timeKey{}
 	// Uint64KeyEncoder can be used to encode uint64 keys.
 	Uint64KeyEncoder KeyEncoder[uint64] = uint64Key{}
+	// ValAddressKeyEncoder can be used to encode sdk.ValAddress keys.
+	ValAddressKeyEncoder KeyEncoder[sdk.ValAddress] = valAddressKeyEncoder{}
 )
 
 type stringKey struct{}
@@ -70,6 +72,21 @@ func (accAddressKey) Decode(b []byte) (int, sdk.AccAddress) {
 	return i, sdk.MustAccAddressFromBech32(s)
 }
 
+type valAddressKeyEncoder struct{}
+
+func (v valAddressKeyEncoder) Encode(key sdk.ValAddress) []byte {
+	return StringKeyEncoder.Encode(key.String())
+}
+func (v valAddressKeyEncoder) Decode(b []byte) (int, sdk.ValAddress) {
+	r, s := StringKeyEncoder.Decode(b)
+	valAddr, err := sdk.ValAddressFromBech32(s)
+	if err != nil {
+		panic(err)
+	}
+	return r, valAddr
+}
+func (v valAddressKeyEncoder) Stringify(key sdk.ValAddress) string { return key.String() }
+
 func (stringKey) Stringify(s string) string {
 	return s
 }

collections/keys_test.go

@@ -83,3 +83,9 @@ func TestTimeKey(t *testing.T) {
 		assertBijective[time.Time](t, TimeKeyEncoder, key)
 	})
 }
+
+func TestValAddressKey(t *testing.T) {
+	t.Run("bijective", func(t *testing.T) {
+		assertBijective(t, ValAddressKeyEncoder, sdk.ValAddress(secp256k1.GenPrivKey().PubKey().Address()))
+	})
+}

collections/values.go

@@ -2,9 +2,16 @@ package collections
 
 import (
 	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/gogo/protobuf/proto"
 )
 
+var (
+	AccAddressValueEncoder ValueEncoder[sdk.AccAddress] = accAddressValueEncoder{}
+	DecValueEncoder        ValueEncoder[sdk.Dec]        = decValue{}
+	Uint64ValueEncoder     ValueEncoder[uint64]         = uint64Value{}
+)
+
 // ProtoValueEncoder returns a protobuf value encoder given the codec.BinaryCodec.
 // It's used to convert a specific protobuf object into bytes representation and convert
 // the protobuf object bytes representation into the concrete object.
@@ -32,3 +39,37 @@ func (p protoValueEncoder[V, PV]) Decode(b []byte) V {
 	p.cdc.MustUnmarshal(b, v)
 	return *v
 }
+
+type decValue struct{}
+
+func (d decValue) Encode(value sdk.Dec) []byte {
+	b, err := value.Marshal()
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
+
+func (d decValue) Decode(b []byte) sdk.Dec {
+	dec := new(sdk.Dec)
+	err := dec.Unmarshal(b)
+	if err != nil {
+		panic(err)
+	}
+	return *dec
+}
+
+func (d decValue) Stringify(value sdk.Dec) string {
+	return value.String()
+}
+
+func (d decValue) Name() string {
+	return "sdk.Dec"
+}
+
+type accAddressValueEncoder struct{}
+
+func (a accAddressValueEncoder) Encode(value sdk.AccAddress) []byte    { return value }
+func (a accAddressValueEncoder) Decode(b []byte) sdk.AccAddress        { return b }
+func (a accAddressValueEncoder) Stringify(value sdk.AccAddress) string { return value.String() }
+func (a accAddressValueEncoder) Name() string                          { return "sdk.AccAddress" }

collections/values_test.go

@@ -3,6 +3,10 @@ package collections
 import (
 	"testing"
 
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/NibiruChain/nibiru/x/testutil"
+
 	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/testutil/testdata"
 	"github.com/gogo/protobuf/types"
@@ -18,3 +22,21 @@ func TestProtoValueEncoder(t *testing.T) {
 		assertValueBijective[types.BytesValue](t, ProtoValueEncoder[types.BytesValue](cdc), protoType)
 	})
 }
+
+func TestDecValueEncoder(t *testing.T) {
+	t.Run("bijectivity", func(t *testing.T) {
+		assertValueBijective(t, DecValueEncoder, sdk.MustNewDecFromStr("-1000.5858"))
+	})
+}
+
+func TestAccAddressValueEncoder(t *testing.T) {
+	t.Run("bijectivity", func(t *testing.T) {
+		assertValueBijective(t, AccAddressValueEncoder, testutil.AccAddress())
+	})
+}
+
+func TestUint64ValueEncoder(t *testing.T) {
+	t.Run("bijectivity", func(t *testing.T) {
+		assertValueBijective(t, Uint64ValueEncoder, 1000)
+	})
+}

x/oracle/genesis.go

@@ -3,6 +3,8 @@ package oracle
 import (
 	"fmt"
 
+	"github.com/NibiruChain/nibiru/collections"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/NibiruChain/nibiru/x/oracle/keeper"
@@ -23,11 +25,11 @@ func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, data *types.GenesisState
 			panic(err)
 		}
 
-		keeper.SetFeederDelegation(ctx, voter, feeder)
+		keeper.FeederDelegations.Insert(ctx, voter, feeder)
 	}
 
 	for _, ex := range data.ExchangeRates {
-		keeper.SetExchangeRate(ctx, ex.Pair, ex.ExchangeRate)
+		keeper.ExchangeRates.Insert(ctx, ex.Pair, ex.ExchangeRate)
 	}
 
 	for _, mc := range data.MissCounters {
@@ -36,7 +38,7 @@ func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, data *types.GenesisState
 			panic(err)
 		}
 
-		keeper.SetMissCounter(ctx, operator, mc.MissCounter)
+		keeper.MissCounters.Insert(ctx, operator, mc.MissCounter)
 	}
 
 	for _, ap := range data.AggregateExchangeRatePrevotes {
@@ -45,7 +47,7 @@ func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, data *types.GenesisState
 			panic(err)
 		}
 
-		keeper.SetAggregateExchangeRatePrevote(ctx, valAddr, ap)
+		keeper.Prevotes.Insert(ctx, valAddr, ap)
 	}
 
 	for _, av := range data.AggregateExchangeRateVotes {
@@ -54,23 +56,27 @@ func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, data *types.GenesisState
 			panic(err)
 		}
 
-		keeper.SetAggregateExchangeRateVote(ctx, valAddr, av)
+		keeper.Votes.Insert(ctx, valAddr, av)
 	}
 
 	if len(data.Pairs) > 0 {
 		for _, tt := range data.Pairs {
-			keeper.SetPair(ctx, tt.Name)
+			keeper.Pairs.Insert(ctx, tt.Name)
 		}
 	} else {
 		for _, item := range data.Params.Whitelist {
-			keeper.SetPair(ctx, item.Name)
+			keeper.Pairs.Insert(ctx, item.Name)
 		}
 	}
 
 	for _, pr := range data.PairRewards {
-		keeper.SetPairReward(ctx, &pr)
+		keeper.PairRewards.Insert(ctx, pr.Id, pr)
 	}
 
+	// set last ID based on the last pair reward
+	if len(data.PairRewards) != 0 {
+		keeper.PairRewardsID.Set(ctx, data.PairRewards[len(data.PairRewards)-1].Id)
+	}
 	keeper.SetParams(ctx, data.Params)
 
 	// check if the module account exists
@@ -86,60 +92,38 @@ func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, data *types.GenesisState
 func ExportGenesis(ctx sdk.Context, keeper keeper.Keeper) *types.GenesisState {
 	params := keeper.GetParams(ctx)
 	feederDelegations := []types.FeederDelegation{}
-	keeper.IterateFeederDelegations(ctx, func(valAddr sdk.ValAddress, feederAddr sdk.AccAddress) (stop bool) {
+	for _, kv := range keeper.FeederDelegations.Iterate(ctx, collections.Range[sdk.ValAddress]{}).KeyValues() {
 		feederDelegations = append(feederDelegations, types.FeederDelegation{
-			FeederAddress:    feederAddr.String(),
-			ValidatorAddress: valAddr.String(),
+			FeederAddress:    kv.Value.String(),
+			ValidatorAddress: kv.Key.String(),
 		})
-		return false
-	})
+	}
 
 	exchangeRates := []types.ExchangeRateTuple{}
-	keeper.IterateExchangeRates(ctx, func(pair string, rate sdk.Dec) (stop bool) {
-		exchangeRates = append(exchangeRates, types.ExchangeRateTuple{Pair: pair, ExchangeRate: rate})
-		return false
-	})
+	for _, er := range keeper.ExchangeRates.Iterate(ctx, collections.Range[string]{}).KeyValues() {
+		exchangeRates = append(exchangeRates, types.ExchangeRateTuple{Pair: er.Key, ExchangeRate: er.Value})
+	}
 
 	missCounters := []types.MissCounter{}
-	keeper.IterateMissCounters(ctx, func(operator sdk.ValAddress, missCounter uint64) (stop bool) {
+	for _, mc := range keeper.MissCounters.Iterate(ctx, collections.Range[sdk.ValAddress]{}).KeyValues() {
 		missCounters = append(missCounters, types.MissCounter{
-			ValidatorAddress: operator.String(),
-			MissCounter:      missCounter,
+			ValidatorAddress: mc.Key.String(),
+			MissCounter:      mc.Value,
 		})
-		return false
-	})
-
-	aggregateExchangeRatePrevotes := []types.AggregateExchangeRatePrevote{}
-	keeper.IterateAggregateExchangeRatePrevotes(ctx, func(_ sdk.ValAddress, aggregatePrevote types.AggregateExchangeRatePrevote) (stop bool) {
-		aggregateExchangeRatePrevotes = append(aggregateExchangeRatePrevotes, aggregatePrevote)
-		return false
-	})
-
-	aggregateExchangeRateVotes := []types.AggregateExchangeRateVote{}
-	keeper.IterateAggregateExchangeRateVotes(ctx, func(_ sdk.ValAddress, aggregateVote types.AggregateExchangeRateVote) bool {
-		aggregateExchangeRateVotes = append(aggregateExchangeRateVotes, aggregateVote)
-		return false
-	})
+	}
 
 	pairs := []types.Pair{}
-	keeper.IteratePairs(ctx, func(pair string) (stop bool) {
-		pairs = append(pairs, types.Pair{Name: pair})
-		return false
-	})
-
-	pairRewards := []types.PairReward{}
-	keeper.IterateAllPairRewards(ctx, func(rewards *types.PairReward) (stop bool) {
-		pairRewards = append(pairRewards, *rewards)
-		return false
-	})
+	for _, p := range keeper.Pairs.Iterate(ctx, collections.Range[string]{}).Keys() {
+		pairs = append(pairs, types.Pair{Name: p})
+	}
 
 	return types.NewGenesisState(params,
 		exchangeRates,
 		feederDelegations,
 		missCounters,
-		aggregateExchangeRatePrevotes,
-		aggregateExchangeRateVotes,
+		keeper.Prevotes.Iterate(ctx, collections.Range[sdk.ValAddress]{}).Values(),
+		keeper.Votes.Iterate(ctx, collections.Range[sdk.ValAddress]{}).Values(),
 		pairs,
-		pairRewards,
+		keeper.PairRewards.Iterate(ctx, collections.Range[uint64]{}).Values(),
 	)
 }

x/oracle/genesis_test.go

@@ -15,15 +15,18 @@ import (
 func TestExportInitGenesis(t *testing.T) {
 	input := keeper.CreateTestInput(t)
 
-	input.OracleKeeper.SetFeederDelegation(input.Ctx, keeper.ValAddrs[0], keeper.Addrs[1])
-	input.OracleKeeper.SetExchangeRate(input.Ctx, "pair1:pair2", sdk.NewDec(123))
-	input.OracleKeeper.SetAggregateExchangeRatePrevote(input.Ctx, keeper.ValAddrs[0], types.NewAggregateExchangeRatePrevote(types.AggregateVoteHash{123}, keeper.ValAddrs[0], uint64(2)))
-	input.OracleKeeper.SetAggregateExchangeRateVote(input.Ctx, keeper.ValAddrs[0], types.NewAggregateExchangeRateVote(types.ExchangeRateTuples{{Pair: "foo", ExchangeRate: sdk.NewDec(123)}}, keeper.ValAddrs[0]))
-	input.OracleKeeper.SetPair(input.Ctx, "pair1:pair1")
-	input.OracleKeeper.SetPair(input.Ctx, "pair2:pair2")
-	input.OracleKeeper.SetMissCounter(input.Ctx, keeper.ValAddrs[0], 10)
-	input.OracleKeeper.SetPairReward(input.Ctx, &types.PairReward{
-		Pair: "pair1:pair2",
+	input.OracleKeeper.FeederDelegations.Insert(input.Ctx, keeper.ValAddrs[0], keeper.Addrs[1])
+	input.OracleKeeper.ExchangeRates.Insert(input.Ctx, "pair1:pair2", sdk.NewDec(123))
+	input.OracleKeeper.Prevotes.Insert(input.Ctx, keeper.ValAddrs[0], types.NewAggregateExchangeRatePrevote(types.AggregateVoteHash{123}, keeper.ValAddrs[0], uint64(2)))
+	input.OracleKeeper.Votes.Insert(input.Ctx, keeper.ValAddrs[0], types.NewAggregateExchangeRateVote(types.ExchangeRateTuples{{Pair: "foo", ExchangeRate: sdk.NewDec(123)}}, keeper.ValAddrs[0]))
+	input.OracleKeeper.Pairs.Insert(input.Ctx, "pair1:pair1")
+	input.OracleKeeper.Pairs.Insert(input.Ctx, "pair2:pair2")
+	input.OracleKeeper.MissCounters.Insert(input.Ctx, keeper.ValAddrs[0], 10)
+	input.OracleKeeper.PairRewards.Insert(input.Ctx, 0, types.PairReward{
+		Pair:        "pair1:pair2",
+		Id:          0,
+		VotePeriods: 100,
+		Coins:       sdk.NewCoins(sdk.NewInt64Coin("test", 1000)),
 	})
 	genesis := oracle.ExportGenesis(input.Ctx, input.OracleKeeper)
 

x/oracle/keeper/ballot.go

@@ -3,6 +3,8 @@ package keeper
 import (
 	"sort"
 
+	"github.com/NibiruChain/nibiru/collections"
+
 	"github.com/NibiruChain/nibiru/x/oracle/types"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -37,7 +39,9 @@ func (k Keeper) OrganizeBallotByPair(ctx sdk.Context, validatorsPerformance map[
 		return false
 	}
 
-	k.IterateAggregateExchangeRateVotes(ctx, aggregateHandler)
+	for _, vote := range k.Votes.Iterate(ctx, collections.Range[sdk.ValAddress]{}).KeyValues() {
+		aggregateHandler(vote.Key, vote.Value)
+	}
 
 	// sort created ballot
 	for pair, ballot := range ballots {
@@ -51,19 +55,22 @@ func (k Keeper) OrganizeBallotByPair(ctx sdk.Context, validatorsPerformance map[
 // ClearBallots clears all tallied prevotes and votes from the store
 func (k Keeper) ClearBallots(ctx sdk.Context, votePeriod uint64) {
 	// Clear all aggregate prevotes
-	k.IterateAggregateExchangeRatePrevotes(ctx, func(voterAddr sdk.ValAddress, aggregatePrevote types.AggregateExchangeRatePrevote) (stop bool) {
-		if ctx.BlockHeight() > int64(aggregatePrevote.SubmitBlock+votePeriod) {
-			k.DeleteAggregateExchangeRatePrevote(ctx, voterAddr)
+	for _, prevote := range k.Prevotes.Iterate(ctx, collections.Range[sdk.ValAddress]{}).KeyValues() {
+		if ctx.BlockHeight() > int64(prevote.Value.SubmitBlock+votePeriod) {
+			err := k.Prevotes.Delete(ctx, prevote.Key)
+			if err != nil {
+				panic(err)
+			}
 		}
-
-		return false
-	})
+	}
 
 	// Clear all aggregate votes
-	k.IterateAggregateExchangeRateVotes(ctx, func(voterAddr sdk.ValAddress, aggregateVote types.AggregateExchangeRateVote) (stop bool) {
-		k.DeleteAggregateExchangeRateVote(ctx, voterAddr)
-		return false
-	})
+	for _, voteKey := range k.Votes.Iterate(ctx, collections.Range[sdk.ValAddress]{}).Keys() {
+		err := k.Votes.Delete(ctx, voteKey)
+		if err != nil {
+			panic(err)
+		}
+	}
 }
 
 // ApplyWhitelist updates the whitelist by detecting possible changes between
@@ -86,9 +93,11 @@ func (k Keeper) ApplyWhitelist(ctx sdk.Context, whitelist types.PairList, voteTa
 	}
 
 	if updateRequired {
-		k.ClearPairs(ctx)
+		for _, p := range k.Pairs.Iterate(ctx, collections.Range[string]{}).Keys() {
+			k.Pairs.Delete(ctx, p)
+		}
 		for _, pair := range whitelist {
-			k.SetPair(ctx, pair.Name)
+			k.Pairs.Insert(ctx, pair.Name)
 		}
 	}
 }