chore(oracle): curate default oracle whitelist

NibiruChain · Nov 2, 2023 · 893c19a · 893c19a
1 parent 4a8c848
commit 893c19a
Show file tree

Hide file tree

Showing 7 changed files with 127 additions and 141 deletions.
diff --git a/wasmbinding/exec_oracle_test.go b/wasmbinding/exec_oracle_test.go
@@ -70,19 +70,19 @@ func (s *TestSuiteOracleExecutor) TestExecuteOracleParams() {
 	// Vote Period
 	params, err := s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(uint64(1_000), params.VotePeriod)
+	s.Equal(uint64(1_000), params.VotePeriod)
 
 	err = s.exec.SetOracleParams(cwMsg, s.ctx)
 	s.Require().NoError(err)
 
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(uint64(1234), params.VotePeriod)
+	s.Equal(uint64(1234), params.VotePeriod)
 
 	// Vote Threshold
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(sdk.OneDec().Quo(sdk.NewDec(3)), params.VoteThreshold)
+	s.Equal(sdk.OneDec().Quo(sdk.NewDec(3)), params.VoteThreshold)
 
 	threshold := sdk.MustNewDecFromStr("0.4")
 	cwMsg = &bindings.EditOracleParams{
@@ -94,12 +94,12 @@ func (s *TestSuiteOracleExecutor) TestExecuteOracleParams() {
 
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(threshold, params.VoteThreshold)
+	s.Equal(threshold, params.VoteThreshold)
 
 	// Reward Band
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(sdk.NewDecWithPrec(2, 2), params.RewardBand)
+	s.Equal(sdk.NewDecWithPrec(2, 2), params.RewardBand)
 
 	band := sdk.MustNewDecFromStr("0.5")
 	cwMsg = &bindings.EditOracleParams{
@@ -111,12 +111,12 @@ func (s *TestSuiteOracleExecutor) TestExecuteOracleParams() {
 
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(band, params.RewardBand)
+	s.Equal(band, params.RewardBand)
 
 	// White List
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(14, len(params.Whitelist))
+	s.Assert().Equal(6, len(params.Whitelist))
 
 	whitelist := []string{"aave:usdc", "sol:usdc"}
 	cwMsg = &bindings.EditOracleParams{
@@ -127,12 +127,12 @@ func (s *TestSuiteOracleExecutor) TestExecuteOracleParams() {
 
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(2, len(params.Whitelist))
+	s.Equal(2, len(params.Whitelist))
 
 	// Slash Fraction
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(sdk.NewDecWithPrec(5, 3), params.SlashFraction)
+	s.Equal(sdk.NewDecWithPrec(5, 3), params.SlashFraction)
 
 	slashFraction := sdk.MustNewDecFromStr("0.5")
 	cwMsg = &bindings.EditOracleParams{
@@ -144,12 +144,12 @@ func (s *TestSuiteOracleExecutor) TestExecuteOracleParams() {
 
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(slashFraction, params.SlashFraction)
+	s.Equal(slashFraction, params.SlashFraction)
 
 	// Slash Window
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(uint64(3600), params.SlashWindow)
+	s.Equal(uint64(3600), params.SlashWindow)
 
 	slashWindow := sdk.NewInt(2)
 	cwMsg = &bindings.EditOracleParams{
@@ -161,12 +161,12 @@ func (s *TestSuiteOracleExecutor) TestExecuteOracleParams() {
 
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(slashWindow.Uint64(), params.SlashWindow)
+	s.Equal(slashWindow.Uint64(), params.SlashWindow)
 
 	// Min valid per window
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(sdk.NewDecWithPrec(69, 2), params.MinValidPerWindow)
+	s.Equal(sdk.NewDecWithPrec(69, 2), params.MinValidPerWindow)
 
 	minValidPerWindow := sdk.MustNewDecFromStr("0.5")
 	cwMsg = &bindings.EditOracleParams{
@@ -178,12 +178,12 @@ func (s *TestSuiteOracleExecutor) TestExecuteOracleParams() {
 
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(minValidPerWindow, params.MinValidPerWindow)
+	s.Equal(minValidPerWindow, params.MinValidPerWindow)
 
 	// Twap lookback window
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(time.Minute*15, params.TwapLookbackWindow)
+	s.Equal(time.Minute*15, params.TwapLookbackWindow)
 
 	twapLookbackWindow := sdk.NewInt(int64(time.Second * 30))
 	cwMsg = &bindings.EditOracleParams{
@@ -195,12 +195,12 @@ func (s *TestSuiteOracleExecutor) TestExecuteOracleParams() {
 
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(time.Duration(twapLookbackWindow.Int64()), params.TwapLookbackWindow)
+	s.Equal(time.Duration(twapLookbackWindow.Int64()), params.TwapLookbackWindow)
 
 	// Min Voters
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(uint64(4), params.MinVoters)
+	s.Equal(uint64(4), params.MinVoters)
 
 	minVoters := sdk.NewInt(2)
 	cwMsg = &bindings.EditOracleParams{
@@ -212,12 +212,12 @@ func (s *TestSuiteOracleExecutor) TestExecuteOracleParams() {
 
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(minVoters.Uint64(), params.MinVoters)
+	s.Equal(minVoters.Uint64(), params.MinVoters)
 
 	// Validator Fee Ratio
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(sdk.NewDecWithPrec(5, 2), params.ValidatorFeeRatio)
+	s.Equal(sdk.NewDecWithPrec(5, 2), params.ValidatorFeeRatio)
 
 	validatorFeeRatio := sdk.MustNewDecFromStr("0.7")
 	cwMsg = &bindings.EditOracleParams{
@@ -229,5 +229,5 @@ func (s *TestSuiteOracleExecutor) TestExecuteOracleParams() {
 
 	params, err = s.nibiru.OracleKeeper.Params.Get(s.ctx)
 	s.Require().NoError(err)
-	s.Require().Equal(validatorFeeRatio, params.ValidatorFeeRatio)
+	s.Equal(validatorFeeRatio, params.ValidatorFeeRatio)
 }
diff --git a/x/oracle/abci_test.go b/x/oracle/abci_test.go
@@ -18,7 +18,7 @@ func TestOracleTallyTiming(t *testing.T) {
 	// all the Addrs vote for the block ... not last period block yet, so tally fails
 	for i := range keeper.Addrs[:4] {
 		keeper.MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{
-			{Pair: asset.Registry.Pair(denoms.BTC, denoms.NUSD), ExchangeRate: sdk.OneDec()},
+			{Pair: asset.Registry.Pair(denoms.BTC, denoms.USD), ExchangeRate: sdk.OneDec()},
 		}, i)
 	}
 
@@ -31,22 +31,22 @@ func TestOracleTallyTiming(t *testing.T) {
 	require.Equal(t, 1, int(input.Ctx.BlockHeight()))
 
 	EndBlocker(input.Ctx, input.OracleKeeper)
-	_, err = input.OracleKeeper.ExchangeRates.Get(input.Ctx, asset.Registry.Pair(denoms.BTC, denoms.NUSD))
+	_, err = input.OracleKeeper.ExchangeRates.Get(input.Ctx, asset.Registry.Pair(denoms.BTC, denoms.USD))
 	require.Error(t, err)
 
 	input.Ctx = input.Ctx.WithBlockHeight(int64(params.VotePeriod - 1))
 
 	EndBlocker(input.Ctx, input.OracleKeeper)
-	_, err = input.OracleKeeper.ExchangeRates.Get(input.Ctx, asset.Registry.Pair(denoms.BTC, denoms.NUSD))
+	_, err = input.OracleKeeper.ExchangeRates.Get(input.Ctx, asset.Registry.Pair(denoms.BTC, denoms.USD))
 	require.NoError(t, err)
 }
 
 // Set prices for 2 pairs, one that is updated and the other which is updated only once.
 // Ensure that the updated pair is not deleted and the other pair is deleted after a certain time.
 func TestOraclePriceExpiration(t *testing.T) {
 	input, h := keeper.Setup(t)
-	pair1 := asset.Registry.Pair(denoms.BTC, denoms.NUSD)
-	pair2 := asset.Registry.Pair(denoms.ETH, denoms.NUSD)
+	pair1 := asset.Registry.Pair(denoms.BTC, denoms.USD)
+	pair2 := asset.Registry.Pair(denoms.ETH, denoms.USD)
 
 	// Set prices for both pairs
 	for i := range keeper.Addrs[:4] {

diff --git a/x/oracle/keeper/msg_server_test.go b/x/oracle/keeper/msg_server_test.go
@@ -16,7 +16,7 @@ func TestFeederDelegation(t *testing.T) {
 
 	exchangeRates := types.ExchangeRateTuples{
 		{
-			Pair:         asset.Registry.Pair(denoms.BTC, denoms.NUSD),
+			Pair:         asset.Registry.Pair(denoms.BTC, denoms.USD),
 			ExchangeRate: testExchangeRate,
 		},
 	}
@@ -83,43 +83,43 @@ func TestAggregatePrevoteVote(t *testing.T) {
 	salt := "1"
 	exchangeRates := types.ExchangeRateTuples{
 		{
-			Pair:         asset.Registry.Pair(denoms.NIBI, denoms.NUSD),
+			Pair:         asset.Registry.Pair(denoms.ATOM, denoms.USD),
 			ExchangeRate: sdk.MustNewDecFromStr("1000.23"),
 		},
 		{
-			Pair:         asset.Registry.Pair(denoms.ETH, denoms.NUSD),
+			Pair:         asset.Registry.Pair(denoms.ETH, denoms.USD),
 			ExchangeRate: sdk.MustNewDecFromStr("0.29"),
 		},
 
 		{
-			Pair:         asset.Registry.Pair(denoms.BTC, denoms.NUSD),
+			Pair:         asset.Registry.Pair(denoms.BTC, denoms.USD),
 			ExchangeRate: sdk.MustNewDecFromStr("0.27"),
 		},
 	}
 
 	otherExchangeRate := types.ExchangeRateTuples{
 		{
-			Pair:         asset.Registry.Pair(denoms.NIBI, denoms.NUSD),
+			Pair:         asset.Registry.Pair(denoms.ATOM, denoms.USD),
 			ExchangeRate: sdk.MustNewDecFromStr("1000.23"),
 		},
 		{
-			Pair:         asset.Registry.Pair(denoms.ETH, denoms.NUSD),
+			Pair:         asset.Registry.Pair(denoms.ETH, denoms.USD),
 			ExchangeRate: sdk.MustNewDecFromStr("0.29"),
 		},
 
 		{
-			Pair:         asset.Registry.Pair(denoms.ETH, denoms.NUSD),
+			Pair:         asset.Registry.Pair(denoms.ETH, denoms.USD),
 			ExchangeRate: sdk.MustNewDecFromStr("0.27"),
 		},
 	}
 
 	unintendedExchangeRateStr := types.ExchangeRateTuples{
 		{
-			Pair:         asset.Registry.Pair(denoms.NIBI, denoms.NUSD),
+			Pair:         asset.Registry.Pair(denoms.ATOM, denoms.USD),
 			ExchangeRate: sdk.MustNewDecFromStr("1000.23"),
 		},
 		{
-			Pair:         asset.Registry.Pair(denoms.ETH, denoms.NUSD),
+			Pair:         asset.Registry.Pair(denoms.ETH, denoms.USD),
 			ExchangeRate: sdk.MustNewDecFromStr("0.29"),
 		},
 		{

diff --git a/x/oracle/keeper/reward_test.go b/x/oracle/keeper/reward_test.go
@@ -15,7 +15,7 @@ import (
 )
 
 func TestKeeperRewardsDistributionMultiVotePeriods(t *testing.T) {
-	// this simulates allocating rewards for the pair nibi:nusd
+	// this simulates allocating rewards for the pair atom:usd
 	// over 5 voting periods. It simulates rewards are correctly
 	// distributed over 5 voting periods to 5 validators.
 	// then we simulate that after the 5 voting periods are
@@ -39,7 +39,7 @@ func TestKeeperRewardsDistributionMultiVotePeriods(t *testing.T) {
 			// then changes the height to current height + vote period for the vote
 			MakeAggregatePrevoteAndVote(t, fixture, msgServer, fixture.Ctx.BlockHeight(), types.ExchangeRateTuples{
 				{
-					Pair:         asset.Registry.Pair(denoms.NIBI, denoms.NUSD),
+					Pair:         asset.Registry.Pair(denoms.ATOM, denoms.USD),
 					ExchangeRate: testExchangeRate,
 				},
 			}, valIndex)

diff --git a/x/oracle/keeper/slash_test.go b/x/oracle/keeper/slash_test.go
@@ -92,9 +92,9 @@ func TestInvalidVotesSlashing(t *testing.T) {
 	input, h := Setup(t)
 	params, err := input.OracleKeeper.Params.Get(input.Ctx)
 	require.NoError(t, err)
-	params.Whitelist = []asset.Pair{asset.Registry.Pair(denoms.NIBI, denoms.NUSD)}
+	params.Whitelist = []asset.Pair{asset.Registry.Pair(denoms.ATOM, denoms.USD)}
 	input.OracleKeeper.Params.Set(input.Ctx, params)
-	input.OracleKeeper.WhitelistedPairs.Insert(input.Ctx, asset.Registry.Pair(denoms.NIBI, denoms.NUSD))
+	input.OracleKeeper.WhitelistedPairs.Insert(input.Ctx, asset.Registry.Pair(denoms.ATOM, denoms.USD))
 
 	votePeriodsPerWindow := sdk.NewDec(int64(input.OracleKeeper.SlashWindow(input.Ctx))).QuoInt64(int64(input.OracleKeeper.VotePeriod(input.Ctx))).TruncateInt64()
 	slashFraction := input.OracleKeeper.SlashFraction(input.Ctx)
@@ -105,22 +105,22 @@ func TestInvalidVotesSlashing(t *testing.T) {
 
 		// Account 1, govstable
 		MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{
-			{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: testExchangeRate},
+			{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: testExchangeRate},
 		}, 0)
 
 		// Account 2, govstable, miss vote
 		MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{
-			{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: testExchangeRate.Add(sdk.NewDec(100000000000000))},
+			{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: testExchangeRate.Add(sdk.NewDec(100000000000000))},
 		}, 1)
 
 		// Account 3, govstable
 		MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{
-			{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: testExchangeRate},
+			{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: testExchangeRate},
 		}, 2)
 
 		// Account 4, govstable
 		MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{
-			{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: testExchangeRate},
+			{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: testExchangeRate},
 		}, 3)
 
 		input.OracleKeeper.UpdateExchangeRates(input.Ctx)
@@ -136,22 +136,22 @@ func TestInvalidVotesSlashing(t *testing.T) {
 	// one more miss vote will inccur ValAddrs[1] slashing
 	// Account 1, govstable
 	MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{
-		{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: testExchangeRate},
+		{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: testExchangeRate},
 	}, 0)
 
 	// Account 2, govstable, miss vote
 	MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{
-		{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: testExchangeRate.Add(sdk.NewDec(100000000000000))},
+		{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: testExchangeRate.Add(sdk.NewDec(100000000000000))},
 	}, 1)
 
 	// Account 3, govstable
 	MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{
-		{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: testExchangeRate},
+		{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: testExchangeRate},
 	}, 2)
 
 	// Account 4, govstable
 	MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{
-		{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: testExchangeRate},
+		{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: testExchangeRate},
 	}, 3)
 
 	input.Ctx = input.Ctx.WithBlockHeight(votePeriodsPerWindow - 1)
@@ -171,7 +171,7 @@ func TestWhitelistSlashing(t *testing.T) {
 	votePeriodsPerSlashWindow := sdk.NewDec(int64(input.OracleKeeper.SlashWindow(input.Ctx))).QuoInt64(int64(input.OracleKeeper.VotePeriod(input.Ctx))).TruncateInt64()
 	minValidVotePeriodsPerWindow := input.OracleKeeper.MinValidPerWindow(input.Ctx)
 
-	pair := asset.Registry.Pair(denoms.NIBI, denoms.NUSD)
+	pair := asset.Registry.Pair(denoms.ATOM, denoms.USD)
 	priceVoteFromVal := func(valIdx int, block int64, erate sdk.Dec) {
 		MakeAggregatePrevoteAndVote(t, input, msgServer, block,
 			types.ExchangeRateTuples{{Pair: pair, ExchangeRate: erate}},
@@ -207,19 +207,19 @@ func TestNotPassedBallotSlashing(t *testing.T) {
 	input, h := Setup(t)
 	params, err := input.OracleKeeper.Params.Get(input.Ctx)
 	require.NoError(t, err)
-	params.Whitelist = []asset.Pair{asset.Registry.Pair(denoms.NIBI, denoms.NUSD)}
+	params.Whitelist = []asset.Pair{asset.Registry.Pair(denoms.ATOM, denoms.USD)}
 	input.OracleKeeper.Params.Set(input.Ctx, params)
 
 	// clear tobin tax to reset vote targets
 	for _, p := range input.OracleKeeper.WhitelistedPairs.Iterate(input.Ctx, collections.Range[asset.Pair]{}).Keys() {
 		input.OracleKeeper.WhitelistedPairs.Delete(input.Ctx, p)
 	}
-	input.OracleKeeper.WhitelistedPairs.Insert(input.Ctx, asset.Registry.Pair(denoms.NIBI, denoms.NUSD))
+	input.OracleKeeper.WhitelistedPairs.Insert(input.Ctx, asset.Registry.Pair(denoms.ATOM, denoms.USD))
 
 	input.Ctx = input.Ctx.WithBlockHeight(input.Ctx.BlockHeight() + 1)
 
 	// Account 1, govstable
-	MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: testExchangeRate}}, 0)
+	MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: testExchangeRate}}, 0)
 
 	input.OracleKeeper.UpdateExchangeRates(input.Ctx)
 	input.OracleKeeper.SlashAndResetMissCounters(input.Ctx)
@@ -235,27 +235,27 @@ func TestAbstainSlashing(t *testing.T) {
 	// reset whitelisted pairs
 	params, err := input.OracleKeeper.Params.Get(input.Ctx)
 	require.NoError(t, err)
-	params.Whitelist = []asset.Pair{asset.Registry.Pair(denoms.NIBI, denoms.NUSD)}
+	params.Whitelist = []asset.Pair{asset.Registry.Pair(denoms.ATOM, denoms.USD)}
 	input.OracleKeeper.Params.Set(input.Ctx, params)
 	for _, p := range input.OracleKeeper.WhitelistedPairs.Iterate(input.Ctx, collections.Range[asset.Pair]{}).Keys() {
 		input.OracleKeeper.WhitelistedPairs.Delete(input.Ctx, p)
 	}
-	input.OracleKeeper.WhitelistedPairs.Insert(input.Ctx, asset.Registry.Pair(denoms.NIBI, denoms.NUSD))
+	input.OracleKeeper.WhitelistedPairs.Insert(input.Ctx, asset.Registry.Pair(denoms.ATOM, denoms.USD))
 
 	votePeriodsPerWindow := sdk.NewDec(int64(input.OracleKeeper.SlashWindow(input.Ctx))).QuoInt64(int64(input.OracleKeeper.VotePeriod(input.Ctx))).TruncateInt64()
 	minValidPerWindow := input.OracleKeeper.MinValidPerWindow(input.Ctx)
 
 	for i := uint64(0); i <= uint64(sdk.OneDec().Sub(minValidPerWindow).MulInt64(votePeriodsPerWindow).TruncateInt64()); i++ {
 		input.Ctx = input.Ctx.WithBlockHeight(input.Ctx.BlockHeight() + 1)
 
-		// Account 1, NIBI/NUSD
-		MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: testExchangeRate}}, 0)
+		// Account 1, ATOM/USD
+		MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: testExchangeRate}}, 0)
 
-		// Account 2, NIBI/NUSD, abstain vote
-		MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: sdk.OneDec().Neg()}}, 1)
+		// Account 2, ATOM/USD, abstain vote
+		MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: sdk.OneDec().Neg()}}, 1)
 
-		// Account 3, NIBI/NUSD
-		MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{{Pair: asset.Registry.Pair(denoms.NIBI, denoms.NUSD), ExchangeRate: testExchangeRate}}, 2)
+		// Account 3, ATOM/USD
+		MakeAggregatePrevoteAndVote(t, input, h, 0, types.ExchangeRateTuples{{Pair: asset.Registry.Pair(denoms.ATOM, denoms.USD), ExchangeRate: testExchangeRate}}, 2)
 
 		input.OracleKeeper.UpdateExchangeRates(input.Ctx)
 		input.OracleKeeper.SlashAndResetMissCounters(input.Ctx)