Merge PR #4847: Sim refactor 1 move store decoders to modules

* move store decoders to modules

* fix

* module pattern

* compile

* update Decoders params

* fix

* address @colin-axner comments

* Update cmd_test.go

* simulation manager

* mino fixes

* cleanup

* Apply suggestions from code review

Co-Authored-By: frog power 4000 <rigel.rozanski@gmail.com>

* address @rigelrozanski comments

* changelog

* Apply suggestions from code review

Co-Authored-By: colin axner <colinaxner@berkeley.edu>

* restructure modules simulation pkgs

* address @alexanderbez comments

* fix

simapp/app.go

@@ -103,6 +103,9 @@ type SimApp struct {
 
 	// the module manager
 	mm *module.Manager
+
+	// simulation manager
+	sm *module.SimulationManager
 }
 
 // NewSimApp returns a reference to an initialized SimApp.
@@ -202,6 +205,9 @@ func NewSimApp(
 	app.mm.RegisterInvariants(&app.CrisisKeeper)
 	app.mm.RegisterRoutes(app.Router(), app.QueryRouter())
 
+	app.sm = module.NewSimulationManager(app.mm.Modules)
+	app.sm.RegisterStoreDecoders()
+
 	// initialize stores
 	app.MountKVStores(keys)
 	app.MountTransientStores(tkeys)

simapp/sim_test.go

@@ -20,20 +20,20 @@ import (
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
-	authsim "github.com/cosmos/cosmos-sdk/x/auth/simulation"
-	"github.com/cosmos/cosmos-sdk/x/bank"
+	authsimops "github.com/cosmos/cosmos-sdk/x/auth/simulation/operations"
+	banksimops "github.com/cosmos/cosmos-sdk/x/bank/simulation/operations"
 	distr "github.com/cosmos/cosmos-sdk/x/distribution"
-	distrsim "github.com/cosmos/cosmos-sdk/x/distribution/simulation"
+	distrsimops "github.com/cosmos/cosmos-sdk/x/distribution/simulation/operations"
 	"github.com/cosmos/cosmos-sdk/x/gov"
-	govsim "github.com/cosmos/cosmos-sdk/x/gov/simulation"
+	govsimops "github.com/cosmos/cosmos-sdk/x/gov/simulation/operations"
 	"github.com/cosmos/cosmos-sdk/x/mint"
 	"github.com/cosmos/cosmos-sdk/x/params"
-	paramsim "github.com/cosmos/cosmos-sdk/x/params/simulation"
+	paramsimops "github.com/cosmos/cosmos-sdk/x/params/simulation/operations"
 	"github.com/cosmos/cosmos-sdk/x/simulation"
 	"github.com/cosmos/cosmos-sdk/x/slashing"
-	slashingsim "github.com/cosmos/cosmos-sdk/x/slashing/simulation"
+	slashingsimops "github.com/cosmos/cosmos-sdk/x/slashing/simulation/operations"
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingsim "github.com/cosmos/cosmos-sdk/x/staking/simulation"
+	stakingsimops "github.com/cosmos/cosmos-sdk/x/staking/simulation/operations"
 	"github.com/cosmos/cosmos-sdk/x/supply"
 )
 
@@ -184,7 +184,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			authsim.SimulateDeductFee(app.AccountKeeper, app.SupplyKeeper),
+			authsimops.SimulateDeductFee(app.AccountKeeper, app.SupplyKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -195,7 +195,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			bank.SimulateMsgSend(app.AccountKeeper, app.BankKeeper),
+			banksimops.SimulateMsgSend(app.AccountKeeper, app.BankKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -206,7 +206,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			bank.SimulateSingleInputMsgMultiSend(app.AccountKeeper, app.BankKeeper),
+			banksimops.SimulateSingleInputMsgMultiSend(app.AccountKeeper, app.BankKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -217,7 +217,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			distrsim.SimulateMsgSetWithdrawAddress(app.AccountKeeper, app.DistrKeeper),
+			distrsimops.SimulateMsgSetWithdrawAddress(app.DistrKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -228,7 +228,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			distrsim.SimulateMsgWithdrawDelegatorReward(app.AccountKeeper, app.DistrKeeper),
+			distrsimops.SimulateMsgWithdrawDelegatorReward(app.DistrKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -239,7 +239,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			distrsim.SimulateMsgWithdrawValidatorCommission(app.AccountKeeper, app.DistrKeeper),
+			distrsimops.SimulateMsgWithdrawValidatorCommission(app.DistrKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -250,7 +250,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			govsim.SimulateSubmittingVotingAndSlashingForProposal(app.GovKeeper, govsim.SimulateTextProposalContent),
+			govsimops.SimulateSubmittingVotingAndSlashingForProposal(app.GovKeeper, govsimops.SimulateTextProposalContent),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -261,7 +261,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			govsim.SimulateSubmittingVotingAndSlashingForProposal(app.GovKeeper, distrsim.SimulateCommunityPoolSpendProposalContent(app.DistrKeeper)),
+			govsimops.SimulateSubmittingVotingAndSlashingForProposal(app.GovKeeper, distrsimops.SimulateCommunityPoolSpendProposalContent(app.DistrKeeper)),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -272,7 +272,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			govsim.SimulateSubmittingVotingAndSlashingForProposal(app.GovKeeper, paramsim.SimulateParamChangeProposalContent),
+			govsimops.SimulateSubmittingVotingAndSlashingForProposal(app.GovKeeper, paramsimops.SimulateParamChangeProposalContent),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -283,7 +283,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			govsim.SimulateMsgDeposit(app.GovKeeper),
+			govsimops.SimulateMsgDeposit(app.GovKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -294,7 +294,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			stakingsim.SimulateMsgCreateValidator(app.AccountKeeper, app.StakingKeeper),
+			stakingsimops.SimulateMsgCreateValidator(app.AccountKeeper, app.StakingKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -305,7 +305,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			stakingsim.SimulateMsgEditValidator(app.StakingKeeper),
+			stakingsimops.SimulateMsgEditValidator(app.StakingKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -316,7 +316,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			stakingsim.SimulateMsgDelegate(app.AccountKeeper, app.StakingKeeper),
+			stakingsimops.SimulateMsgDelegate(app.AccountKeeper, app.StakingKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -327,7 +327,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			stakingsim.SimulateMsgUndelegate(app.AccountKeeper, app.StakingKeeper),
+			stakingsimops.SimulateMsgUndelegate(app.AccountKeeper, app.StakingKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -338,7 +338,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			stakingsim.SimulateMsgBeginRedelegate(app.AccountKeeper, app.StakingKeeper),
+			stakingsimops.SimulateMsgBeginRedelegate(app.AccountKeeper, app.StakingKeeper),
 		},
 		{
 			func(_ *rand.Rand) int {
@@ -349,7 +349,7 @@ func testAndRunTxs(app *SimApp) []simulation.WeightedOperation {
 					})
 				return v
 			}(nil),
-			slashingsim.SimulateMsgUnjail(app.SlashingKeeper),
+			slashingsimops.SimulateMsgUnjail(app.SlashingKeeper),
 		},
 	}
 }
@@ -597,11 +597,15 @@ func TestAppImportExport(t *testing.T) {
 		storeKeyA := storeKeysPrefix.A
 		storeKeyB := storeKeysPrefix.B
 		prefixes := storeKeysPrefix.Prefixes
+
 		storeA := ctxA.KVStore(storeKeyA)
 		storeB := ctxB.KVStore(storeKeyB)
-		failedKVs := sdk.DiffKVStores(storeA, storeB, prefixes)
-		fmt.Printf("Compared %d key/value pairs between %s and %s\n", len(failedKVs)/2, storeKeyA, storeKeyB)
-		require.Len(t, failedKVs, 0, GetSimulationLog(storeKeyA.Name(), app.cdc, newApp.cdc, failedKVs))
+
+		failedKVAs, failedKVBs := sdk.DiffKVStores(storeA, storeB, prefixes)
+		require.Equal(t, len(failedKVAs), len(failedKVBs), "unequal sets of key-values to compare")
+
+		fmt.Printf("Compared %d key/value pairs between %s and %s\n", len(failedKVAs), storeKeyA, storeKeyB)
+		require.Len(t, failedKVAs, 0, GetSimulationLog(storeKeyA.Name(), app.sm.StoreDecoders, app.cdc, failedKVAs, failedKVBs))
 	}
 
 }

simapp/utils.go

@@ -2,8 +2,6 @@
 package simapp
 
 import (
-	"bytes"
-	"encoding/binary"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -11,7 +9,6 @@ import (
 	"math/rand"
 	"time"
 
-	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/secp256k1"
 	cmn "github.com/tendermint/tendermint/libs/common"
 	"github.com/tendermint/tendermint/libs/log"
@@ -500,242 +497,21 @@ func GenStakingGenesisState(
 
 // GetSimulationLog unmarshals the KVPair's Value to the corresponding type based on the
 // each's module store key and the prefix bytes of the KVPair's key.
-func GetSimulationLog(storeName string, cdcA, cdcB *codec.Codec, kvs []cmn.KVPair) (log string) {
-	var kvA, kvB cmn.KVPair
-	for i := 0; i < len(kvs); i += 2 {
-		kvA = kvs[i]
-		kvB = kvs[i+1]
+func GetSimulationLog(storeName string, sdr sdk.StoreDecoderRegistry, cdc *codec.Codec, kvAs, kvBs []cmn.KVPair) (log string) {
+	for i := 0; i < len(kvAs); i++ {
 
-		if len(kvA.Value) == 0 && len(kvB.Value) == 0 {
+		if len(kvAs[i].Value) == 0 && len(kvBs[i].Value) == 0 {
 			// skip if the value doesn't have any bytes
 			continue
 		}
 
-		switch storeName {
-		case auth.StoreKey:
-			log += DecodeAccountStore(cdcA, cdcB, kvA, kvB)
-		case mint.StoreKey:
-			log += DecodeMintStore(cdcA, cdcB, kvA, kvB)
-		case staking.StoreKey:
-			log += DecodeStakingStore(cdcA, cdcB, kvA, kvB)
-		case slashing.StoreKey:
-			log += DecodeSlashingStore(cdcA, cdcB, kvA, kvB)
-		case gov.StoreKey:
-			log += DecodeGovStore(cdcA, cdcB, kvA, kvB)
-		case distribution.StoreKey:
-			log += DecodeDistributionStore(cdcA, cdcB, kvA, kvB)
-		case supply.StoreKey:
-			log += DecodeSupplyStore(cdcA, cdcB, kvA, kvB)
-		default:
-			log += fmt.Sprintf("store A %X => %X\nstore B %X => %X\n", kvA.Key, kvA.Value, kvB.Key, kvB.Value)
+		decoder, ok := sdr[storeName]
+		if ok {
+			log += decoder(cdc, kvAs[i], kvBs[i])
+		} else {
+			log += fmt.Sprintf("store A %X => %X\nstore B %X => %X\n", kvAs[i].Key, kvAs[i].Value, kvBs[i].Key, kvBs[i].Value)
 		}
 	}
 
 	return
 }
-
-// DecodeAccountStore unmarshals the KVPair's Value to the corresponding auth type
-func DecodeAccountStore(cdcA, cdcB *codec.Codec, kvA, kvB cmn.KVPair) string {
-	switch {
-	case bytes.Equal(kvA.Key[:1], auth.AddressStoreKeyPrefix):
-		var accA, accB auth.Account
-		cdcA.MustUnmarshalBinaryBare(kvA.Value, &accA)
-		cdcB.MustUnmarshalBinaryBare(kvB.Value, &accB)
-		return fmt.Sprintf("%v\n%v", accA, accB)
-	case bytes.Equal(kvA.Key, auth.GlobalAccountNumberKey):
-		var globalAccNumberA, globalAccNumberB uint64
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &globalAccNumberA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &globalAccNumberB)
-		return fmt.Sprintf("GlobalAccNumberA: %d\nGlobalAccNumberB: %d", globalAccNumberA, globalAccNumberB)
-	default:
-		panic(fmt.Sprintf("invalid account key %X", kvA.Key))
-	}
-}
-
-// DecodeMintStore unmarshals the KVPair's Value to the corresponding mint type
-func DecodeMintStore(cdcA, cdcB *codec.Codec, kvA, kvB cmn.KVPair) string {
-	switch {
-	case bytes.Equal(kvA.Key, mint.MinterKey):
-		var minterA, minterB mint.Minter
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &minterA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &minterB)
-		return fmt.Sprintf("%v\n%v", minterA, minterB)
-	default:
-		panic(fmt.Sprintf("invalid mint key %X", kvA.Key))
-	}
-}
-
-// DecodeDistributionStore unmarshals the KVPair's Value to the corresponding distribution type
-func DecodeDistributionStore(cdcA, cdcB *codec.Codec, kvA, kvB cmn.KVPair) string {
-	switch {
-	case bytes.Equal(kvA.Key[:1], distribution.FeePoolKey):
-		var feePoolA, feePoolB distribution.FeePool
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &feePoolA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &feePoolB)
-		return fmt.Sprintf("%v\n%v", feePoolA, feePoolB)
-
-	case bytes.Equal(kvA.Key[:1], distribution.ProposerKey):
-		return fmt.Sprintf("%v\n%v", sdk.ConsAddress(kvA.Value), sdk.ConsAddress(kvB.Value))
-
-	case bytes.Equal(kvA.Key[:1], distribution.ValidatorOutstandingRewardsPrefix):
-		var rewardsA, rewardsB distribution.ValidatorOutstandingRewards
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &rewardsA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &rewardsB)
-		return fmt.Sprintf("%v\n%v", rewardsA, rewardsB)
-
-	case bytes.Equal(kvA.Key[:1], distribution.DelegatorWithdrawAddrPrefix):
-		return fmt.Sprintf("%v\n%v", sdk.AccAddress(kvA.Value), sdk.AccAddress(kvB.Value))
-
-	case bytes.Equal(kvA.Key[:1], distribution.DelegatorStartingInfoPrefix):
-		var infoA, infoB distribution.DelegatorStartingInfo
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &infoA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &infoB)
-		return fmt.Sprintf("%v\n%v", infoA, infoB)
-
-	case bytes.Equal(kvA.Key[:1], distribution.ValidatorHistoricalRewardsPrefix):
-		var rewardsA, rewardsB distribution.ValidatorHistoricalRewards
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &rewardsA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &rewardsB)
-		return fmt.Sprintf("%v\n%v", rewardsA, rewardsB)
-
-	case bytes.Equal(kvA.Key[:1], distribution.ValidatorCurrentRewardsPrefix):
-		var rewardsA, rewardsB distribution.ValidatorCurrentRewards
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &rewardsA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &rewardsB)
-		return fmt.Sprintf("%v\n%v", rewardsA, rewardsB)
-
-	case bytes.Equal(kvA.Key[:1], distribution.ValidatorAccumulatedCommissionPrefix):
-		var commissionA, commissionB distribution.ValidatorAccumulatedCommission
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &commissionA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &commissionB)
-		return fmt.Sprintf("%v\n%v", commissionA, commissionB)
-
-	case bytes.Equal(kvA.Key[:1], distribution.ValidatorSlashEventPrefix):
-		var eventA, eventB distribution.ValidatorSlashEvent
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &eventA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &eventB)
-		return fmt.Sprintf("%v\n%v", eventA, eventB)
-
-	default:
-		panic(fmt.Sprintf("invalid distribution key prefix %X", kvA.Key[:1]))
-	}
-}
-
-// DecodeStakingStore unmarshals the KVPair's Value to the corresponding staking type
-func DecodeStakingStore(cdcA, cdcB *codec.Codec, kvA, kvB cmn.KVPair) string {
-	switch {
-	case bytes.Equal(kvA.Key[:1], staking.LastTotalPowerKey):
-		var powerA, powerB sdk.Int
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &powerA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &powerB)
-		return fmt.Sprintf("%v\n%v", powerA, powerB)
-
-	case bytes.Equal(kvA.Key[:1], staking.ValidatorsKey):
-		var validatorA, validatorB staking.Validator
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &validatorA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &validatorB)
-		return fmt.Sprintf("%v\n%v", validatorA, validatorB)
-
-	case bytes.Equal(kvA.Key[:1], staking.LastValidatorPowerKey),
-		bytes.Equal(kvA.Key[:1], staking.ValidatorsByConsAddrKey),
-		bytes.Equal(kvA.Key[:1], staking.ValidatorsByPowerIndexKey):
-		return fmt.Sprintf("%v\n%v", sdk.ValAddress(kvA.Value), sdk.ValAddress(kvB.Value))
-
-	case bytes.Equal(kvA.Key[:1], staking.DelegationKey):
-		var delegationA, delegationB staking.Delegation
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &delegationA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &delegationB)
-		return fmt.Sprintf("%v\n%v", delegationA, delegationB)
-
-	case bytes.Equal(kvA.Key[:1], staking.UnbondingDelegationKey),
-		bytes.Equal(kvA.Key[:1], staking.UnbondingDelegationByValIndexKey):
-		var ubdA, ubdB staking.UnbondingDelegation
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &ubdA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &ubdB)
-		return fmt.Sprintf("%v\n%v", ubdA, ubdB)
-
-	case bytes.Equal(kvA.Key[:1], staking.RedelegationKey),
-		bytes.Equal(kvA.Key[:1], staking.RedelegationByValSrcIndexKey):
-		var redA, redB staking.Redelegation
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &redA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &redB)
-		return fmt.Sprintf("%v\n%v", redA, redB)
-
-	default:
-		panic(fmt.Sprintf("invalid staking key prefix %X", kvA.Key[:1]))
-	}
-}
-
-// DecodeSlashingStore unmarshals the KVPair's Value to the corresponding slashing type
-func DecodeSlashingStore(cdcA, cdcB *codec.Codec, kvA, kvB cmn.KVPair) string {
-	switch {
-	case bytes.Equal(kvA.Key[:1], slashing.ValidatorSigningInfoKey):
-		var infoA, infoB slashing.ValidatorSigningInfo
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &infoA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &infoB)
-		return fmt.Sprintf("%v\n%v", infoA, infoB)
-
-	case bytes.Equal(kvA.Key[:1], slashing.ValidatorMissedBlockBitArrayKey):
-		var missedA, missedB bool
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &missedA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &missedB)
-		return fmt.Sprintf("missedA: %v\nmissedB: %v", missedA, missedB)
-
-	case bytes.Equal(kvA.Key[:1], slashing.AddrPubkeyRelationKey):
-		var pubKeyA, pubKeyB crypto.PubKey
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &pubKeyA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &pubKeyB)
-		bechPKA := sdk.MustBech32ifyAccPub(pubKeyA)
-		bechPKB := sdk.MustBech32ifyAccPub(pubKeyB)
-		return fmt.Sprintf("PubKeyA: %s\nPubKeyB: %s", bechPKA, bechPKB)
-
-	default:
-		panic(fmt.Sprintf("invalid slashing key prefix %X", kvA.Key[:1]))
-	}
-}
-
-// DecodeGovStore unmarshals the KVPair's Value to the corresponding gov type
-func DecodeGovStore(cdcA, cdcB *codec.Codec, kvA, kvB cmn.KVPair) string {
-	switch {
-	case bytes.Equal(kvA.Key[:1], gov.ProposalsKeyPrefix):
-		var proposalA, proposalB gov.Proposal
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &proposalA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &proposalB)
-		return fmt.Sprintf("%v\n%v", proposalA, proposalB)
-
-	case bytes.Equal(kvA.Key[:1], gov.ActiveProposalQueuePrefix),
-		bytes.Equal(kvA.Key[:1], gov.InactiveProposalQueuePrefix),
-		bytes.Equal(kvA.Key[:1], gov.ProposalIDKey):
-		proposalIDA := binary.LittleEndian.Uint64(kvA.Value)
-		proposalIDB := binary.LittleEndian.Uint64(kvB.Value)
-		return fmt.Sprintf("proposalIDA: %d\nProposalIDB: %d", proposalIDA, proposalIDB)
-
-	case bytes.Equal(kvA.Key[:1], gov.DepositsKeyPrefix):
-		var depositA, depositB gov.Deposit
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &depositA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &depositB)
-		return fmt.Sprintf("%v\n%v", depositA, depositB)
-
-	case bytes.Equal(kvA.Key[:1], gov.VotesKeyPrefix):
-		var voteA, voteB gov.Vote
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &voteA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &voteB)
-		return fmt.Sprintf("%v\n%v", voteA, voteB)
-
-	default:
-		panic(fmt.Sprintf("invalid governance key prefix %X", kvA.Key[:1]))
-	}
-}
-
-// DecodeSupplyStore unmarshals the KVPair's Value to the corresponding supply type
-func DecodeSupplyStore(cdcA, cdcB *codec.Codec, kvA, kvB cmn.KVPair) string {
-	switch {
-	case bytes.Equal(kvA.Key[:1], supply.SupplyKey):
-		var supplyA, supplyB supply.Supply
-		cdcA.MustUnmarshalBinaryLengthPrefixed(kvA.Value, &supplyA)
-		cdcB.MustUnmarshalBinaryLengthPrefixed(kvB.Value, &supplyB)
-		return fmt.Sprintf("%v\n%v", supplyB, supplyB)
-	default:
-		panic(fmt.Sprintf("invalid supply key %X", kvA.Key))
-	}
-}

simapp/utils_test.go

@@ -1,10 +1,7 @@
 package simapp
 
 import (
-	"encoding/binary"
 	"fmt"
-	"time"
-
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -15,13 +12,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 
 	"github.com/cosmos/cosmos-sdk/x/auth"
-	"github.com/cosmos/cosmos-sdk/x/distribution"
-	distr "github.com/cosmos/cosmos-sdk/x/distribution"
-	"github.com/cosmos/cosmos-sdk/x/gov"
-	"github.com/cosmos/cosmos-sdk/x/mint"
-	"github.com/cosmos/cosmos-sdk/x/slashing"
-	"github.com/cosmos/cosmos-sdk/x/staking"
-	"github.com/cosmos/cosmos-sdk/x/supply"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -38,322 +28,40 @@ func makeTestCodec() (cdc *codec.Codec) {
 	sdk.RegisterCodec(cdc)
 	codec.RegisterCrypto(cdc)
 	auth.RegisterCodec(cdc)
-	distr.RegisterCodec(cdc)
-	gov.RegisterCodec(cdc)
-	staking.RegisterCodec(cdc)
-	supply.RegisterCodec(cdc)
 	return
 }
 
 func TestGetSimulationLog(t *testing.T) {
 	cdc := makeTestCodec()
 
+	decoders := make(sdk.StoreDecoderRegistry)
+	decoders[auth.StoreKey] = func(cdc *codec.Codec, kvAs, kvBs cmn.KVPair) string { return "10" }
+
 	tests := []struct {
-		store   string
-		kvPairs []cmn.KVPair
+		store       string
+		kvPairs     []cmn.KVPair
+		expectedLog string
 	}{
-		{auth.StoreKey, []cmn.KVPair{
-			{Key: auth.AddressStoreKey(delAddr1), Value: cdc.MustMarshalBinaryBare(auth.BaseAccount{})},
-			{Key: auth.AddressStoreKey(delAddr1), Value: cdc.MustMarshalBinaryBare(auth.BaseAccount{})},
-		}},
-		{mint.StoreKey, []cmn.KVPair{
-			{Key: mint.MinterKey, Value: cdc.MustMarshalBinaryLengthPrefixed(mint.Minter{})},
-			{Key: mint.MinterKey, Value: cdc.MustMarshalBinaryLengthPrefixed(mint.Minter{})},
-		}},
-		{staking.StoreKey, []cmn.KVPair{
-			{Key: staking.LastValidatorPowerKey, Value: valAddr1.Bytes()},
-			{Key: staking.LastValidatorPowerKey, Value: valAddr1.Bytes()},
-		}},
-		{gov.StoreKey, []cmn.KVPair{
-			{Key: gov.VoteKey(1, delAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(gov.Vote{})},
-			{Key: gov.VoteKey(1, delAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(gov.Vote{})},
-		}},
-		{distribution.StoreKey, []cmn.KVPair{
-			{Key: distr.ProposerKey, Value: consAddr1.Bytes()},
-			{Key: distr.ProposerKey, Value: consAddr1.Bytes()},
-		}},
-		{slashing.StoreKey, []cmn.KVPair{
-			{Key: slashing.GetValidatorMissedBlockBitArrayKey(consAddr1, 6), Value: cdc.MustMarshalBinaryLengthPrefixed(true)},
-			{Key: slashing.GetValidatorMissedBlockBitArrayKey(consAddr1, 6), Value: cdc.MustMarshalBinaryLengthPrefixed(true)},
-		}},
-		{supply.StoreKey, []cmn.KVPair{
-			{Key: supply.SupplyKey, Value: cdc.MustMarshalBinaryLengthPrefixed(supply.NewSupply(sdk.Coins{}))},
-			{Key: supply.SupplyKey, Value: cdc.MustMarshalBinaryLengthPrefixed(supply.NewSupply(sdk.Coins{}))},
-		}},
-		{"Empty", []cmn.KVPair{{}, {}}},
-		{"OtherStore", []cmn.KVPair{
-			{Key: []byte("key"), Value: []byte("value")},
-			{Key: []byte("key"), Value: []byte("other_value")},
-		}},
+		{
+			"Empty",
+			[]cmn.KVPair{{}},
+			"",
+		},
+		{
+			auth.StoreKey,
+			[]cmn.KVPair{{Key: auth.GlobalAccountNumberKey, Value: cdc.MustMarshalBinaryLengthPrefixed(uint64(10))}},
+			"10",
+		},
+		{
+			"OtherStore",
+			[]cmn.KVPair{{Key: []byte("key"), Value: []byte("value")}},
+			fmt.Sprintf("store A %X => %X\nstore B %X => %X\n", []byte("key"), []byte("value"), []byte("key"), []byte("value")),
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.store, func(t *testing.T) {
-			require.NotPanics(t, func() { GetSimulationLog(tt.store, cdc, cdc, tt.kvPairs) }, tt.store)
-		})
-	}
-}
-
-func TestDecodeAccountStore(t *testing.T) {
-	cdc := makeTestCodec()
-	acc := auth.NewBaseAccountWithAddress(delAddr1)
-	globalAccNumber := uint64(10)
-
-	kvPairs := cmn.KVPairs{
-		cmn.KVPair{Key: auth.AddressStoreKey(delAddr1), Value: cdc.MustMarshalBinaryBare(acc)},
-		cmn.KVPair{Key: auth.GlobalAccountNumberKey, Value: cdc.MustMarshalBinaryLengthPrefixed(globalAccNumber)},
-		cmn.KVPair{Key: []byte{0x99}, Value: []byte{0x99}},
-	}
-	tests := []struct {
-		name        string
-		expectedLog string
-	}{
-		{"Minter", fmt.Sprintf("%v\n%v", acc, acc)},
-		{"GlobalAccNumber", fmt.Sprintf("GlobalAccNumberA: %d\nGlobalAccNumberB: %d", globalAccNumber, globalAccNumber)},
-		{"other", ""},
-	}
-
-	for i, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch i {
-			case len(tests) - 1:
-				require.Panics(t, func() { DecodeAccountStore(cdc, cdc, kvPairs[i], kvPairs[i]) }, tt.name)
-			default:
-				require.Equal(t, tt.expectedLog, DecodeAccountStore(cdc, cdc, kvPairs[i], kvPairs[i]), tt.name)
-			}
-		})
-	}
-}
-
-func TestDecodeMintStore(t *testing.T) {
-	cdc := makeTestCodec()
-	minter := mint.NewMinter(sdk.OneDec(), sdk.NewDec(15))
-
-	kvPairs := cmn.KVPairs{
-		cmn.KVPair{Key: mint.MinterKey, Value: cdc.MustMarshalBinaryLengthPrefixed(minter)},
-		cmn.KVPair{Key: []byte{0x99}, Value: []byte{0x99}},
-	}
-	tests := []struct {
-		name        string
-		expectedLog string
-	}{
-		{"Minter", fmt.Sprintf("%v\n%v", minter, minter)},
-		{"other", ""},
-	}
-
-	for i, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch i {
-			case len(tests) - 1:
-				require.Panics(t, func() { DecodeMintStore(cdc, cdc, kvPairs[i], kvPairs[i]) }, tt.name)
-			default:
-				require.Equal(t, tt.expectedLog, DecodeMintStore(cdc, cdc, kvPairs[i], kvPairs[i]), tt.name)
-			}
-		})
-	}
-}
-
-func TestDecodeDistributionStore(t *testing.T) {
-	cdc := makeTestCodec()
-
-	decCoins := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, sdk.OneDec())}
-	feePool := distr.InitialFeePool()
-	feePool.CommunityPool = decCoins
-	info := distr.NewDelegatorStartingInfo(2, sdk.OneDec(), 200)
-	outstanding := distr.ValidatorOutstandingRewards{decCoins[0]}
-	commission := distr.ValidatorAccumulatedCommission{decCoins[0]}
-	historicalRewards := distr.NewValidatorHistoricalRewards(decCoins, 100)
-	currentRewards := distr.NewValidatorCurrentRewards(decCoins, 5)
-	slashEvent := distr.NewValidatorSlashEvent(10, sdk.OneDec())
-
-	kvPairs := cmn.KVPairs{
-		cmn.KVPair{Key: distr.FeePoolKey, Value: cdc.MustMarshalBinaryLengthPrefixed(feePool)},
-		cmn.KVPair{Key: distr.ProposerKey, Value: consAddr1.Bytes()},
-		cmn.KVPair{Key: distr.GetValidatorOutstandingRewardsKey(valAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(outstanding)},
-		cmn.KVPair{Key: distr.GetDelegatorWithdrawAddrKey(delAddr1), Value: delAddr1.Bytes()},
-		cmn.KVPair{Key: distr.GetDelegatorStartingInfoKey(valAddr1, delAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(info)},
-		cmn.KVPair{Key: distr.GetValidatorHistoricalRewardsKey(valAddr1, 100), Value: cdc.MustMarshalBinaryLengthPrefixed(historicalRewards)},
-		cmn.KVPair{Key: distr.GetValidatorCurrentRewardsKey(valAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(currentRewards)},
-		cmn.KVPair{Key: distr.GetValidatorAccumulatedCommissionKey(valAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(commission)},
-		cmn.KVPair{Key: distr.GetValidatorSlashEventKeyPrefix(valAddr1, 13), Value: cdc.MustMarshalBinaryLengthPrefixed(slashEvent)},
-		cmn.KVPair{Key: []byte{0x99}, Value: []byte{0x99}},
-	}
-
-	tests := []struct {
-		name        string
-		expectedLog string
-	}{
-		{"FeePool", fmt.Sprintf("%v\n%v", feePool, feePool)},
-		{"Proposer", fmt.Sprintf("%v\n%v", consAddr1, consAddr1)},
-		{"ValidatorOutstandingRewards", fmt.Sprintf("%v\n%v", outstanding, outstanding)},
-		{"DelegatorWithdrawAddr", fmt.Sprintf("%v\n%v", delAddr1, delAddr1)},
-		{"DelegatorStartingInfo", fmt.Sprintf("%v\n%v", info, info)},
-		{"ValidatorHistoricalRewards", fmt.Sprintf("%v\n%v", historicalRewards, historicalRewards)},
-		{"ValidatorCurrentRewards", fmt.Sprintf("%v\n%v", currentRewards, currentRewards)},
-		{"ValidatorAccumulatedCommission", fmt.Sprintf("%v\n%v", commission, commission)},
-		{"ValidatorSlashEvent", fmt.Sprintf("%v\n%v", slashEvent, slashEvent)},
-		{"other", ""},
-	}
-	for i, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch i {
-			case len(tests) - 1:
-				require.Panics(t, func() { DecodeDistributionStore(cdc, cdc, kvPairs[i], kvPairs[i]) }, tt.name)
-			default:
-				require.Equal(t, tt.expectedLog, DecodeDistributionStore(cdc, cdc, kvPairs[i], kvPairs[i]), tt.name)
-			}
-		})
-	}
-}
-
-func TestDecodeStakingStore(t *testing.T) {
-	cdc := makeTestCodec()
-
-	bondTime := time.Now().UTC()
-
-	val := staking.NewValidator(valAddr1, delPk1, staking.NewDescription("test", "test", "test", "test", "test"))
-	del := staking.NewDelegation(delAddr1, valAddr1, sdk.OneDec())
-	ubd := staking.NewUnbondingDelegation(delAddr1, valAddr1, 15, bondTime, sdk.OneInt())
-	red := staking.NewRedelegation(delAddr1, valAddr1, valAddr1, 12, bondTime, sdk.OneInt(), sdk.OneDec())
-
-	kvPairs := cmn.KVPairs{
-		cmn.KVPair{Key: staking.LastTotalPowerKey, Value: cdc.MustMarshalBinaryLengthPrefixed(sdk.OneInt())},
-		cmn.KVPair{Key: staking.GetValidatorKey(valAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(val)},
-		cmn.KVPair{Key: staking.LastValidatorPowerKey, Value: valAddr1.Bytes()},
-		cmn.KVPair{Key: staking.GetDelegationKey(delAddr1, valAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(del)},
-		cmn.KVPair{Key: staking.GetUBDKey(delAddr1, valAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(ubd)},
-		cmn.KVPair{Key: staking.GetREDKey(delAddr1, valAddr1, valAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(red)},
-		cmn.KVPair{Key: []byte{0x99}, Value: []byte{0x99}},
-	}
-
-	tests := []struct {
-		name        string
-		expectedLog string
-	}{
-		{"LastTotalPower", fmt.Sprintf("%v\n%v", sdk.OneInt(), sdk.OneInt())},
-		{"Validator", fmt.Sprintf("%v\n%v", val, val)},
-		{"LastValidatorPower/ValidatorsByConsAddr/ValidatorsByPowerIndex", fmt.Sprintf("%v\n%v", valAddr1, valAddr1)},
-		{"Delegation", fmt.Sprintf("%v\n%v", del, del)},
-		{"UnbondingDelegation", fmt.Sprintf("%v\n%v", ubd, ubd)},
-		{"Redelegation", fmt.Sprintf("%v\n%v", red, red)},
-		{"other", ""},
-	}
-	for i, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch i {
-			case len(tests) - 1:
-				require.Panics(t, func() { DecodeStakingStore(cdc, cdc, kvPairs[i], kvPairs[i]) }, tt.name)
-			default:
-				require.Equal(t, tt.expectedLog, DecodeStakingStore(cdc, cdc, kvPairs[i], kvPairs[i]), tt.name)
-			}
-		})
-	}
-}
-
-func TestDecodeSlashingStore(t *testing.T) {
-	cdc := makeTestCodec()
-
-	info := slashing.NewValidatorSigningInfo(consAddr1, 0, 1, time.Now().UTC(), false, 0)
-	bechPK := sdk.MustBech32ifyAccPub(delPk1)
-	missed := true
-
-	kvPairs := cmn.KVPairs{
-		cmn.KVPair{Key: slashing.GetValidatorSigningInfoKey(consAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(info)},
-		cmn.KVPair{Key: slashing.GetValidatorMissedBlockBitArrayKey(consAddr1, 6), Value: cdc.MustMarshalBinaryLengthPrefixed(missed)},
-		cmn.KVPair{Key: slashing.GetAddrPubkeyRelationKey(delAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(delPk1)},
-		cmn.KVPair{Key: []byte{0x99}, Value: []byte{0x99}},
-	}
-
-	tests := []struct {
-		name        string
-		expectedLog string
-	}{
-		{"ValidatorSigningInfo", fmt.Sprintf("%v\n%v", info, info)},
-		{"ValidatorMissedBlockBitArray", fmt.Sprintf("missedA: %v\nmissedB: %v", missed, missed)},
-		{"AddrPubkeyRelation", fmt.Sprintf("PubKeyA: %s\nPubKeyB: %s", bechPK, bechPK)},
-		{"other", ""},
-	}
-	for i, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch i {
-			case len(tests) - 1:
-				require.Panics(t, func() { DecodeSlashingStore(cdc, cdc, kvPairs[i], kvPairs[i]) }, tt.name)
-			default:
-				require.Equal(t, tt.expectedLog, DecodeSlashingStore(cdc, cdc, kvPairs[i], kvPairs[i]), tt.name)
-			}
-		})
-	}
-}
-
-func TestDecodeGovStore(t *testing.T) {
-	cdc := makeTestCodec()
-
-	endTime := time.Now().UTC()
-
-	content := gov.ContentFromProposalType("test", "test", gov.ProposalTypeText)
-	proposal := gov.NewProposal(content, 1, endTime, endTime.Add(24*time.Hour))
-	proposalIDBz := make([]byte, 8)
-	binary.LittleEndian.PutUint64(proposalIDBz, 1)
-	deposit := gov.NewDeposit(1, delAddr1, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.OneInt())))
-	vote := gov.NewVote(1, delAddr1, gov.OptionYes)
-
-	kvPairs := cmn.KVPairs{
-		cmn.KVPair{Key: gov.ProposalKey(1), Value: cdc.MustMarshalBinaryLengthPrefixed(proposal)},
-		cmn.KVPair{Key: gov.InactiveProposalQueueKey(1, endTime), Value: proposalIDBz},
-		cmn.KVPair{Key: gov.DepositKey(1, delAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(deposit)},
-		cmn.KVPair{Key: gov.VoteKey(1, delAddr1), Value: cdc.MustMarshalBinaryLengthPrefixed(vote)},
-		cmn.KVPair{Key: []byte{0x99}, Value: []byte{0x99}},
-	}
-
-	tests := []struct {
-		name        string
-		expectedLog string
-	}{
-		{"proposals", fmt.Sprintf("%v\n%v", proposal, proposal)},
-		{"proposal IDs", "proposalIDA: 1\nProposalIDB: 1"},
-		{"deposits", fmt.Sprintf("%v\n%v", deposit, deposit)},
-		{"votes", fmt.Sprintf("%v\n%v", vote, vote)},
-		{"other", ""},
-	}
-
-	for i, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch i {
-			case len(tests) - 1:
-				require.Panics(t, func() { DecodeGovStore(cdc, cdc, kvPairs[i], kvPairs[i]) }, tt.name)
-			default:
-				require.Equal(t, tt.expectedLog, DecodeGovStore(cdc, cdc, kvPairs[i], kvPairs[i]), tt.name)
-			}
-		})
-	}
-}
-
-func TestDecodeSupplyStore(t *testing.T) {
-	cdc := makeTestCodec()
-
-	totalSupply := supply.NewSupply(sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1000)))
-
-	kvPairs := cmn.KVPairs{
-		cmn.KVPair{Key: supply.SupplyKey, Value: cdc.MustMarshalBinaryLengthPrefixed(totalSupply)},
-		cmn.KVPair{Key: []byte{0x99}, Value: []byte{0x99}},
-	}
-
-	tests := []struct {
-		name        string
-		expectedLog string
-	}{
-		{"Supply", fmt.Sprintf("%v\n%v", totalSupply, totalSupply)},
-		{"other", ""},
-	}
-
-	for i, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			switch i {
-			case len(tests) - 1:
-				require.Panics(t, func() { DecodeSupplyStore(cdc, cdc, kvPairs[i], kvPairs[i]) }, tt.name)
-			default:
-				require.Equal(t, tt.expectedLog, DecodeSupplyStore(cdc, cdc, kvPairs[i], kvPairs[i]), tt.name)
-			}
+			require.Equal(t, tt.expectedLog, GetSimulationLog(tt.store, decoders, cdc, tt.kvPairs, tt.kvPairs), tt.store)
 		})
 	}
 }