Merge remote-tracking branch 'origin/feat/oracle-module' into fix/sto…

…re-price-timestamp

app/app_test.go

@@ -6,10 +6,11 @@ import (
 
 	"cosmossdk.io/log"
 	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
-	"github.com/archway-network/archway/app/appconst"
 	tmdb "github.com/cosmos/cosmos-db"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/require"
+
+	"github.com/archway-network/archway/app/appconst"
 )
 
 // import (

e2e/ibchooks/ibchooks_test.go

@@ -7,12 +7,13 @@ import (
 	"testing"
 
 	wasmKeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
-	"github.com/archway-network/archway/app"
 	ibc_hooks "github.com/cosmos/ibc-apps/modules/ibc-hooks/v8"
 	ibchookskeeper "github.com/cosmos/ibc-apps/modules/ibc-hooks/v8/keeper"
 	"github.com/cosmos/ibc-apps/modules/ibc-hooks/v8/tests/unit/mocks"
 	"github.com/stretchr/testify/suite"
 
+	"github.com/archway-network/archway/app"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth/types"
 

e2e/ibchooks/setup.go

@@ -9,8 +9,6 @@ import (
 	"cosmossdk.io/log"
 	sdkmath "cosmossdk.io/math"
 	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
-	"github.com/archway-network/archway/app"
-	"github.com/archway-network/archway/app/appconst"
 	abci "github.com/cometbft/cometbft/abci/types"
 	cmttypes "github.com/cometbft/cometbft/types"
 	dbm "github.com/cosmos/cosmos-db"
@@ -29,6 +27,9 @@ import (
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 	"github.com/cosmos/ibc-go/v8/testing/mock"
 	"github.com/stretchr/testify/require"
+
+	"github.com/archway-network/archway/app"
+	"github.com/archway-network/archway/app/appconst"
 )
 
 type App = app.ArchwayApp
@@ -174,7 +175,6 @@ func GenesisStateWithValSet(
 		}
 		validators = append(validators, validator)
 		delegations = append(delegations, stakingtypes.NewDelegation(genAccs[0].GetAddress().String(), sdk.ValAddress(val.Address).String(), sdkmath.LegacyOneDec()))
-
 	}
 
 	// set validators and delegations

e2e/testing/client.go

@@ -40,7 +40,7 @@ func (c grpcClient) Invoke(ctx context.Context, method string, args, reply inter
 	}
 
 	if resp.Code != abci.CodeTypeOK {
-		return fmt.Errorf(resp.Log)
+		return fmt.Errorf("%s", resp.Log)
 	}
 
 	c.app.AppCodec().MustUnmarshal(resp.Value, reply.(proto.Message))

types/math/dec.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"cosmossdk.io/math"
+
 	"github.com/archway-network/archway/types/errors"
 )
 

types/math/dec_test.go

@@ -7,8 +7,9 @@ import (
 
 	"cosmossdk.io/math"
 
-	"github.com/archway-network/archway/types/errors"
 	"github.com/stretchr/testify/assert"
+
+	"github.com/archway-network/archway/types/errors"
 )
 
 func TestSqrtBigInt(t *testing.T) {

x/oracle/abci_test.go

@@ -6,15 +6,16 @@ import (
 	"cosmossdk.io/math"
 	"github.com/stretchr/testify/require"
 
+	cmTypes "github.com/cometbft/cometbft/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
 	e2eTesting "github.com/archway-network/archway/e2e/testing"
 	"github.com/archway-network/archway/x/oracle"
 	"github.com/archway-network/archway/x/oracle/asset"
 	"github.com/archway-network/archway/x/oracle/denoms"
 	"github.com/archway-network/archway/x/oracle/keeper"
 	"github.com/archway-network/archway/x/oracle/types"
 	oracletypes "github.com/archway-network/archway/x/oracle/types"
-	cmTypes "github.com/cometbft/cometbft/types"
-	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
 // TODO (spekalsg3): duplicated from `package keeper_test`
@@ -55,7 +56,7 @@ func TestOracleTallyTiming(t *testing.T) {
 	params, err := keepers.OracleKeeper.Params.Get(ctx)
 	require.NoError(t, err)
 	params.VotePeriod = 1
-	keepers.OracleKeeper.Params.Set(ctx, params)
+	require.NoError(t, keepers.OracleKeeper.Params.Set(ctx, params))
 
 	// all the Addrs vote for the block ... not last period block yet, so tally fails
 	for _, val := range chain.GetCurrentValSet().Validators {
@@ -66,15 +67,15 @@ func TestOracleTallyTiming(t *testing.T) {
 
 	params.VotePeriod = 10 // set vote period to 10 for now, for convenience
 	params.ExpirationBlocks = 100
-	keepers.OracleKeeper.Params.Set(ctx, params)
+	require.NoError(t, keepers.OracleKeeper.Params.Set(ctx, params))
 	require.Equal(t, 1, int(ctx.BlockHeight()))
 
-	oracle.EndBlocker(ctx, keepers.OracleKeeper)
+	require.NoError(t, oracle.EndBlocker(ctx, keepers.OracleKeeper))
 	_, err = keepers.OracleKeeper.ExchangeRates.Get(ctx, asset.Registry.Pair(denoms.BTC, denoms.USD))
 	require.Error(t, err)
 
 	ctx = ctx.WithBlockHeight(int64(params.VotePeriod))
-	oracle.EndBlocker(ctx, keepers.OracleKeeper)
+	require.NoError(t, oracle.EndBlocker(ctx, keepers.OracleKeeper))
 
 	_, err = keepers.OracleKeeper.ExchangeRates.Get(ctx, asset.Registry.Pair(denoms.BTC, denoms.USD))
 	require.NoError(t, err)
@@ -95,7 +96,7 @@ func TestOraclePriceExpiration(t *testing.T) {
 	params, err := keepers.OracleKeeper.Params.Get(ctx)
 	require.NoError(t, err)
 	params.VotePeriod = 1
-	keepers.OracleKeeper.Params.Set(ctx, params)
+	require.NoError(t, keepers.OracleKeeper.Params.Set(ctx, params))
 
 	// Set prices for both pairs
 	for _, val := range chain.GetCurrentValSet().Validators {
@@ -107,11 +108,11 @@ func TestOraclePriceExpiration(t *testing.T) {
 
 	params.VotePeriod = 10
 	params.ExpirationBlocks = 10
-	keepers.OracleKeeper.Params.Set(ctx, params)
+	require.NoError(t, keepers.OracleKeeper.Params.Set(ctx, params))
 
 	// Wait for prices to set
 	ctx = ctx.WithBlockHeight(int64(params.VotePeriod))
-	oracle.EndBlocker(ctx, keepers.OracleKeeper)
+	require.NoError(t, oracle.EndBlocker(ctx, keepers.OracleKeeper))
 
 	// Check if both prices are set
 	_, err = keepers.OracleKeeper.ExchangeRates.Get(ctx, pair1)
@@ -129,12 +130,12 @@ func TestOraclePriceExpiration(t *testing.T) {
 
 	// Set price
 	ctx = ctx.WithBlockHeight(voteHeight)
-	oracle.EndBlocker(ctx, keepers.OracleKeeper)
+	require.NoError(t, oracle.EndBlocker(ctx, keepers.OracleKeeper))
 
 	// Set the block height to the expiration height
 	// End blocker should delete the price of pair2
 	ctx = ctx.WithBlockHeight(int64(params.ExpirationBlocks + params.VotePeriod))
-	oracle.EndBlocker(ctx, keepers.OracleKeeper)
+	require.NoError(t, oracle.EndBlocker(ctx, keepers.OracleKeeper))
 
 	_, err = keepers.OracleKeeper.ExchangeRates.Get(ctx, pair1)
 	require.NoError(t, err)

x/oracle/asset/pair.go

@@ -177,7 +177,6 @@ func (pke pairKeyEncoder) EncodeNonTerminal(buffer []byte, key Pair) (int, error
 }
 func (pke pairKeyEncoder) DecodeNonTerminal(buffer []byte) (int, Pair, error) {
 	return pke.Decode(buffer)
-
 }
 func (pairKeyEncoder) SizeNonTerminal(key Pair) int {
 	return key.Size()

x/oracle/client/cli/gen_pricefeeder_delegation_test.go

@@ -6,9 +6,10 @@ import (
 
 	"github.com/archway-network/archway/x/oracle/client/cli"
 
-	e2eTesting "github.com/archway-network/archway/e2e/testing"
 	"github.com/cosmos/cosmos-sdk/client/flags"
 	"github.com/stretchr/testify/require"
+
+	e2eTesting "github.com/archway-network/archway/e2e/testing"
 )
 
 func TestAddGenesisPricefeederDelegation(t *testing.T) {

x/oracle/genesis.go

@@ -24,7 +24,10 @@ func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, data *types.GenesisState
 			panic(err)
 		}
 
-		keeper.FeederDelegations.Set(ctx, voter, feeder)
+		err = keeper.FeederDelegations.Set(ctx, voter, feeder)
+		if err != nil {
+			panic(err)
+		}
 	}
 
 	for _, ex := range data.ExchangeRates {
@@ -37,7 +40,10 @@ func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, data *types.GenesisState
 			panic(err)
 		}
 
-		keeper.MissCounters.Set(ctx, operator, missCounter.MissCounter)
+		err = keeper.MissCounters.Set(ctx, operator, missCounter.MissCounter)
+		if err != nil {
+			panic(err)
+		}
 	}
 
 	for _, aggregatePrevote := range data.AggregateExchangeRatePrevotes {
@@ -46,7 +52,10 @@ func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, data *types.GenesisState
 			panic(err)
 		}
 
-		keeper.Prevotes.Set(ctx, valAddr, aggregatePrevote)
+		err = keeper.Prevotes.Set(ctx, valAddr, aggregatePrevote)
+		if err != nil {
+			panic(err)
+		}
 	}
 
 	for _, aggregateVote := range data.AggregateExchangeRateVotes {
@@ -55,28 +64,46 @@ func InitGenesis(ctx sdk.Context, keeper keeper.Keeper, data *types.GenesisState
 			panic(err)
 		}
 
-		keeper.Votes.Set(ctx, valAddr, aggregateVote)
+		err = keeper.Votes.Set(ctx, valAddr, aggregateVote)
+		if err != nil {
+			panic(err)
+		}
 	}
 
 	if len(data.Pairs) > 0 {
 		for _, tt := range data.Pairs {
-			keeper.WhitelistedPairs.Set(ctx, tt)
+			err := keeper.WhitelistedPairs.Set(ctx, tt)
+			if err != nil {
+				panic(err)
+			}
 		}
 	} else {
 		for _, item := range data.Params.Whitelist {
-			keeper.WhitelistedPairs.Set(ctx, item)
+			err := keeper.WhitelistedPairs.Set(ctx, item)
+			if err != nil {
+				panic(err)
+			}
 		}
 	}
 
 	for _, pr := range data.Rewards {
-		keeper.Rewards.Set(ctx, pr.Id, pr)
+		err := keeper.Rewards.Set(ctx, pr.Id, pr)
+		if err != nil {
+			panic(err)
+		}
 	}
 
 	// set last ID based on the last pair reward
 	if len(data.Rewards) != 0 {
-		keeper.RewardsID.Set(ctx, data.Rewards[len(data.Rewards)-1].Id)
+		err := keeper.RewardsID.Set(ctx, data.Rewards[len(data.Rewards)-1].Id)
+		if err != nil {
+			panic(err)
+		}
+	}
+	err := keeper.Params.Set(ctx, data.Params)
+	if err != nil {
+		panic(err)
 	}
-	keeper.Params.Set(ctx, data.Params)
 
 	// check if the module account exists
 	moduleAcc := keeper.AccountKeeper.GetModuleAccount(ctx, types.ModuleName)
@@ -95,31 +122,40 @@ func ExportGenesis(ctx sdk.Context, keeper keeper.Keeper) *types.GenesisState {
 	}
 
 	feederDelegations := []types.FeederDelegation{}
-	keeper.FeederDelegations.Walk(ctx, nil, func(valBytes []byte, accBytes []byte) (bool, error) {
+	err = keeper.FeederDelegations.Walk(ctx, nil, func(valBytes []byte, accBytes []byte) (bool, error) {
 		feederDelegations = append(feederDelegations, types.FeederDelegation{
 			FeederAddress:    sdk.AccAddress(accBytes).String(),
 			ValidatorAddress: sdk.ValAddress(valBytes).String(),
 		})
 		return false, nil
 	})
+	if err != nil {
+		panic(err)
+	}
 
 	exchangeRates := []types.ExchangeRateTuple{}
-	keeper.ExchangeRates.Walk(ctx, nil, func(pair asset.Pair, price types.DatedPrice) (bool, error) {
+	err = keeper.ExchangeRates.Walk(ctx, nil, func(pair asset.Pair, price types.DatedPrice) (bool, error) {
 		exchangeRates = append(exchangeRates, types.ExchangeRateTuple{
 			Pair:         pair,
 			ExchangeRate: price.ExchangeRate,
 		})
 		return false, nil
 	})
+	if err != nil {
+		panic(err)
+	}
 
 	missCounters := []types.MissCounter{}
-	keeper.MissCounters.Walk(ctx, nil, func(valAddrBytes []byte, counter uint64) (bool, error) {
+	err = keeper.MissCounters.Walk(ctx, nil, func(valAddrBytes []byte, counter uint64) (bool, error) {
 		missCounters = append(missCounters, types.MissCounter{
 			ValidatorAddress: sdk.ValAddress(valAddrBytes).String(),
 			MissCounter:      counter,
 		})
 		return false, nil
 	})
+	if err != nil {
+		panic(err)
+	}
 
 	var pairs []asset.Pair
 	iter, err := keeper.WhitelistedPairs.Iterate(ctx, nil)

x/oracle/keeper/ballot.go

@@ -1,7 +1,7 @@
 package keeper
 
 import (
- 	"fmt"
+	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
@@ -63,7 +63,7 @@ func (k Keeper) GroupVotesByPair(
 // ClearVotesAndPrevotes clears all tallied prevotes and votes from the store
 func (k Keeper) ClearVotesAndPrevotes(ctx sdk.Context, votePeriod uint64) {
 	// Clear all aggregate prevotes
-	k.Prevotes.Walk(ctx, nil, func(valAddrBytes []byte, aggregatePrevote types.AggregateExchangeRatePrevote) (bool, error) {
+	_ = k.Prevotes.Walk(ctx, nil, func(valAddrBytes []byte, aggregatePrevote types.AggregateExchangeRatePrevote) (bool, error) {
 		valAddr := sdk.ValAddress(valAddrBytes)
 		if ctx.BlockHeight() >= int64(aggregatePrevote.SubmitBlock+votePeriod) {
 			err := k.Prevotes.Remove(ctx, valAddr)

x/oracle/keeper/ballot_test.go

@@ -34,7 +34,8 @@ func TestGroupVotesByPair(t *testing.T) {
 		ValAddrs[i] = sdk.ValAddress(vals[i].Address)
 	}
 
-	keepers.StakingKeeper.EndBlocker(ctx)
+	_, err := keepers.StakingKeeper.EndBlocker(ctx)
+	require.NoError(t, err)
 
 	pairBtc := asset.Registry.Pair(denoms.BTC, denoms.NUSD)
 	pairEth := asset.Registry.Pair(denoms.ETH, denoms.NUSD)
@@ -50,7 +51,7 @@ func TestGroupVotesByPair(t *testing.T) {
 	}
 
 	for i, v := range btcVotes {
-		keepers.OracleKeeper.Votes.Set(
+		require.NoError(t, keepers.OracleKeeper.Votes.Set(
 			ctx,
 			ValAddrs[i],
 			types.NewAggregateExchangeRateVote(
@@ -60,7 +61,7 @@ func TestGroupVotesByPair(t *testing.T) {
 				},
 				ValAddrs[i],
 			),
-		)
+		))
 	}
 
 	// organize votes by pair
@@ -105,7 +106,8 @@ func TestClearVotesAndPrevotes(t *testing.T) {
 		ValAddrs[i] = sdk.ValAddress(vals[i].Address)
 	}
 
-	keepers.StakingKeeper.EndBlocker(ctx)
+	_, err := keepers.StakingKeeper.EndBlocker(ctx)
+	require.NoError(t, err)
 
 	btcVotes := types.ExchangeRateVotes{
 		types.NewExchangeRateVote(math.LegacyNewDec(17), asset.Registry.Pair(denoms.BTC, denoms.NUSD), ValAddrs[0], power),
@@ -119,17 +121,17 @@ func TestClearVotesAndPrevotes(t *testing.T) {
 	}
 
 	for i := range btcVotes {
-		keepers.OracleKeeper.Prevotes.Set(ctx, ValAddrs[i], types.AggregateExchangeRatePrevote{
+		require.NoError(t, keepers.OracleKeeper.Prevotes.Set(ctx, ValAddrs[i], types.AggregateExchangeRatePrevote{
 			Hash:        "",
 			Voter:       ValAddrs[i].String(),
 			SubmitBlock: uint64(ctx.BlockHeight()),
-		})
+		}))
 
-		keepers.OracleKeeper.Votes.Set(ctx, ValAddrs[i],
+		require.NoError(t, keepers.OracleKeeper.Votes.Set(ctx, ValAddrs[i],
 			types.NewAggregateExchangeRateVote(types.ExchangeRateTuples{
 				{Pair: btcVotes[i].Pair, ExchangeRate: btcVotes[i].ExchangeRate},
 				{Pair: ethVotes[i].Pair, ExchangeRate: ethVotes[i].ExchangeRate},
-			}, ValAddrs[i]))
+			}, ValAddrs[i])))
 	}
 
 	keepers.OracleKeeper.ClearVotesAndPrevotes(ctx, 10)