Repository: osmosis-labs/osmosis
Pull request #2070 (2022-07-14 20:52:45)

fix(e2e): upgrade proposals
<!-- < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < ☺
v                               ✰  Thanks for creating a PR! ✰    
v    Before smashing the submit button please review the checkboxes.
v    If a checkbox is n/a - please still include it but + a little note why
v    If your PR doesn't close an issue, that's OK!  Just remove the Closes: #XXX line!
☺ > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >  -->

Related to: https://github.com/osmosis-labs/osmosis/issues/2039

## What is the purpose of the change


Discovered that upgrade proposals were broken after trying to upgrade our SDK.

I think the reason the CI was passing before is that despite switching v10 to v11 containers during the upgrade, the state machine was compatible so it was able to continue.

However, upon upgrading SDK, that wasn't the case anymore so the CI started failing.

The problem was that each node on a chain was submitting and voting on its own proposal. As a result, none of them would eventually be accepted.

This change makes only one node to submit a proposal and all other nodes vote on the unified proposal.

The tests passed with this change + SDK upgraded. The actual upgrade is coming in a separate PR.
## Passthrough Change

- Formatted command logs consistently to improve the UX

## Testing and Verifying

This change is a trivial rework / code cleanup without any test coverage.

## Documentation and Release Note

  - Does this pull request introduce a new feature or user-facing behavior changes? no
  - Is a relevant changelog entry added to the `Unreleased` section in `CHANGELOG.md`? no
  - How is the feature or change documented? not applicable


Patch:
diff --git a/.github/labeler.yml b/.github/labeler.yml
index 49370713b..f2e92a956 100644
--- a/.github/labeler.yml
+++ b/.github/labeler.yml
@@ -9,6 +9,13 @@
   - app/upgrades/**/*
   # Also match any module.go update
   - x/**/module.go
+"C:simulator":
+  # Match all of simulation & tests/simulator folder
+  - simulation/**/*
+  - simulation/**/**/*
+  - tests/simulator/**
+  # Match any module update
+  - x/**/simulation/*.go
 "C:wasm":
   - app/wasm/**/*
 "C:x/claim":
diff --git a/osmomath/math.go b/osmomath/math.go
index def0f5014..d8f341bb6 100644
--- a/osmomath/math.go
+++ b/osmomath/math.go
@@ -84,6 +84,10 @@ func Pow(base sdk.Dec, exp sdk.Dec) sdk.Dec {
 // Contract: 0 < base <= 2
 // 0 <= exp < 1.
 func PowApprox(base sdk.Dec, exp sdk.Dec, precision sdk.Dec) sdk.Dec {
+	if !base.IsPositive() {
+		panic(fmt.Errorf("base must be greater than 0"))
+	}
+
 	if exp.IsZero() {
 		return sdk.OneDec()
 	}
diff --git a/simulation/executor/event_stats.go b/simulation/executor/event_stats.go
index cd2d01a06..8b3f06e9b 100644
--- a/simulation/executor/event_stats.go
+++ b/simulation/executor/event_stats.go
@@ -48,7 +48,7 @@ func (es EventStats) ExportJSON(path string) {
 		panic(err)
 	}
 
-	err = ioutil.WriteFile(path, bz, 0600)
+	err = ioutil.WriteFile(path, bz, 0o600)
 	if err != nil {
 		panic(err)
 	}
diff --git a/simulation/executor/expected_keepers.go b/simulation/executor/expected_keepers.go
deleted file mode 100644
index c54831b8a..000000000
--- a/simulation/executor/expected_keepers.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package simulation
-
-import (
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/auth/types"
-)
-
-// AccountKeeper defines the expected account keeper used for simulations (noalias)
-type AccountKeeper interface {
-	GetAccount(ctx sdk.Context, addr sdk.AccAddress) types.AccountI
-}
-
-// BankKeeper defines the expected interface needed to retrieve account balances.
-type BankKeeper interface {
-	SpendableCoins(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins
-}
diff --git a/simulation/executor/log.go b/simulation/executor/log.go
index df563cc18..d429497a4 100644
--- a/simulation/executor/log.go
+++ b/simulation/executor/log.go
@@ -44,7 +44,6 @@ func (lw *StandardLogWriter) PrintLogs() {
 	for i := 0; i < len(lw.OpEntries); i++ {
 		writeEntry := fmt.Sprintf("%s\n", (lw.OpEntries[i]).MustMarshal())
 		_, err := f.WriteString(writeEntry)
-
 		if err != nil {
 			panic("Failed to write logs to file")
 		}
diff --git a/simulation/executor/mock_tendermint.go b/simulation/executor/mock_tendermint.go
index e4f096db1..e840c39c1 100644
--- a/simulation/executor/mock_tendermint.go
+++ b/simulation/executor/mock_tendermint.go
@@ -126,18 +126,33 @@ func updateValidators(
 func RandomRequestBeginBlock(r *rand.Rand, params Params,
 	validators mockValidators, pastTimes []time.Time,
 	pastVoteInfos [][]abci.VoteInfo,
-	event func(route, op, evResult string), header tmproto.Header) abci.RequestBeginBlock {
+	event func(route, op, evResult string), header tmproto.Header,
+) abci.RequestBeginBlock {
 	if len(validators) == 0 {
 		return abci.RequestBeginBlock{
 			Header: header,
 		}
 	}
 
+	voteInfos := randomVoteInfos(r, params, validators, event)
+	evidence := randomDoubleSignEvidence(r, params, validators, pastTimes, pastVoteInfos, event, header, voteInfos)
+
+	return abci.RequestBeginBlock{
+		Header: header,
+		LastCommitInfo: abci.LastCommitInfo{
+			Votes: voteInfos,
+		},
+		ByzantineValidators: evidence,
+	}
+}
+
+func randomVoteInfos(r *rand.Rand, simParams Params, validators mockValidators, event func(route, op, evResult string),
+) []abci.VoteInfo {
 	voteInfos := make([]abci.VoteInfo, len(validators))
 
 	for i, key := range validators.getKeys() {
 		mVal := validators[key]
-		mVal.livenessState = params.LivenessTransitionMatrix().NextState(r, mVal.livenessState)
+		mVal.livenessState = simParams.LivenessTransitionMatrix().NextState(r, mVal.livenessState)
 		signed := true
 
 		if mVal.livenessState == 1 {
@@ -170,18 +185,19 @@ func RandomRequestBeginBlock(r *rand.Rand, params Params,
 		}
 	}
 
+	return voteInfos
+}
+
+func randomDoubleSignEvidence(r *rand.Rand, params Params,
+	validators mockValidators, pastTimes []time.Time,
+	pastVoteInfos [][]abci.VoteInfo,
+	event func(route, op, evResult string), header tmproto.Header, voteInfos []abci.VoteInfo) []abci.Evidence {
+	evidence := []abci.Evidence{}
 	// return if no past times
 	if len(pastTimes) == 0 {
-		return abci.RequestBeginBlock{
-			Header: header,
-			LastCommitInfo: abci.LastCommitInfo{
-				Votes: voteInfos,
-			},
-		}
+		return evidence
 	}
 
-	// TODO: Determine capacity before allocation
-	evidence := make([]abci.Evidence, 0)
 	// TODO: Change this to be markov based & clean this up
 	for r.Float64() < params.EvidenceFraction() {
 		height := header.Height
@@ -214,12 +230,5 @@ func RandomRequestBeginBlock(r *rand.Rand, params Params,
 
 		event("begin_block", "evidence", "ok")
 	}
-
-	return abci.RequestBeginBlock{
-		Header: header,
-		LastCommitInfo: abci.LastCommitInfo{
-			Votes: voteInfos,
-		},
-		ByzantineValidators: evidence,
-	}
+	return evidence
 }
diff --git a/simulation/executor/operation.go b/simulation/executor/operation.go
index 38a018a61..fcc301352 100644
--- a/simulation/executor/operation.go
+++ b/simulation/executor/operation.go
@@ -1,14 +1,14 @@
 package simulation
 
+// TODO: Figure out how to delete everything in this file OR migrate to improved logging concepts
+
 import (
 	"encoding/json"
 	"math/rand"
-	"sort"
 
 	"github.com/cosmos/cosmos-sdk/types/simulation"
 
 	simtypes "github.com/osmosis-labs/osmosis/v7/simulation/types"
-	// simtypes "github.com/osmosis-labs/osmosis/simulation/types"
 )
 
 // entry kinds for use within OperationEntry
@@ -77,37 +77,21 @@ func NewOperationQueue() OperationQueue {
 
 // queueOperations adds all future operations into the operation queue.
 // TODO: Change FutureOperation to FutureAction
-func queueOperations(queuedOps OperationQueue, queuedTimeOps []simulation.FutureOperation, futureOps []simulation.FutureOperation) {
-	if futureOps == nil {
-		return
-	}
-
+func (simState *simState) queueOperations(futureOps []simulation.FutureOperation) {
 	for _, futureOp := range futureOps {
 		futureOp := futureOp
 		if futureOp.BlockHeight != 0 {
-			if val, ok := queuedOps[futureOp.BlockHeight]; ok {
-				queuedOps[futureOp.BlockHeight] = append(val, futureOp.Op)
+			if val, ok := simState.operationQueue[futureOp.BlockHeight]; ok {
+				simState.operationQueue[futureOp.BlockHeight] = append(val, futureOp.Op)
 			} else {
-				queuedOps[futureOp.BlockHeight] = []simulation.Operation{futureOp.Op}
+				simState.operationQueue[futureOp.BlockHeight] = []simulation.Operation{futureOp.Op}
 			}
 
 			continue
 		}
-
-		// TODO: Replace with proper sorted data structure, so don't have the
-		// copy entire slice
-		index := sort.Search(
-			len(queuedTimeOps),
-			func(i int) bool {
-				return queuedTimeOps[i].BlockTime.After(futureOp.BlockTime)
-			},
-		)
-
-		queuedTimeOps = append(queuedTimeOps, simulation.FutureOperation{})
-		copy(queuedTimeOps[index+1:], queuedTimeOps[index:])
-		queuedTimeOps[index] = futureOp
 	}
 }
+
 func totalWeight(actions []simtypes.Action) int {
 	totalWeight := 0
 	for _, action := range actions {
diff --git a/simulation/executor/params.go b/simulation/executor/params.go
index ccf226334..19a21f9fe 100644
--- a/simulation/executor/params.go
+++ b/simulation/executor/params.go
@@ -89,69 +89,6 @@ func RandomParams(r *rand.Rand) Params {
 	}
 }
 
-// Param change proposals
-
-// ParamChange defines the object used for simulating parameter change proposals
-type ParamChange struct {
-	subspace string
-	key      string
-	simValue simulation.SimValFn
-}
-
-func (spc ParamChange) Subspace() string {
-	return spc.subspace
-}
-
-func (spc ParamChange) Key() string {
-	return spc.key
-}
-
-func (spc ParamChange) SimValue() simulation.SimValFn {
-	return spc.simValue
-}
-
-// NewSimParamChange creates a new ParamChange instance
-func NewSimParamChange(subspace, key string, simVal simulation.SimValFn) simulation.ParamChange {
-	return ParamChange{
-		subspace: subspace,
-		key:      key,
-		simValue: simVal,
-	}
-}
-
-// ComposedKey creates a new composed key for the param change proposal
-func (spc ParamChange) ComposedKey() string {
-	return spc.Subspace() + "/" + spc.Key()
-}
-
-// Proposal Contents
-
-// WeightedProposalContent defines a common struct for proposal contents defined by
-// external modules (i.e outside gov)
-type WeightedProposalContent struct {
-	appParamsKey       string                        // key used to retrieve the value of the weight from the simulation application params
-	defaultWeight      int                           // default weight
-	contentSimulatorFn simulation.ContentSimulatorFn // content simulator function
-}
-
-func NewWeightedProposalContent(appParamsKey string, defaultWeight int, contentSimulatorFn simulation.ContentSimulatorFn) simulation.WeightedProposalContent {
-	return &WeightedProposalContent{appParamsKey: appParamsKey, defaultWeight: defaultWeight, contentSimulatorFn: contentSimulatorFn}
-}
-
-func (w WeightedProposalContent) AppParamsKey() string {
-	return w.appParamsKey
-}
-
-func (w WeightedProposalContent) DefaultWeight() int {
-	return w.defaultWeight
-}
-
-func (w WeightedProposalContent) ContentSimulatorFn() simulation.ContentSimulatorFn {
-	return w.contentSimulatorFn
-}
-
-// Param change proposals
-
 // randomConsensusParams returns random simulation consensus parameters, it extracts the Evidence from the Staking genesis state.
 func randomConsensusParams(r *rand.Rand, appState json.RawMessage, cdc codec.JSONCodec) *abci.ConsensusParams {
 	var genesisState map[string]json.RawMessage
diff --git a/simulation/executor/simulate.go b/simulation/executor/simulate.go
index 13f2b932a..527d87909 100644
--- a/simulation/executor/simulate.go
+++ b/simulation/executor/simulate.go
@@ -31,11 +31,11 @@ func initChain(
 	accounts []simulation.Account,
 	app simtypes.App,
 	appStateFn simulation.AppStateFn,
-	config simulation.Config,
+	config *simulation.Config,
 	cdc codec.JSONCodec,
-) (mockValidators, time.Time, []simulation.Account, string) {
+) (mockValidators, time.Time, []simulation.Account) {
 	// TODO: Cleanup the whole config dependency with appStateFn
-	appState, accounts, chainID, genesisTimestamp := appStateFn(r, accounts, config)
+	appState, accounts, chainID, genesisTimestamp := appStateFn(r, accounts, *config)
 	consensusParams := randomConsensusParams(r, appState, cdc)
 	req := abci.RequestInitChain{
 		AppStateBytes:   appState,
@@ -48,7 +48,13 @@ func initChain(
 	res := app.GetBaseApp().InitChain(req)
 	validators := newMockValidators(r, res.Validators, params)
 
-	return validators, genesisTimestamp, accounts, chainID
+	// update config
+	config.ChainID = chainID
+	if config.InitialBlockHeight == 0 {
+		config.InitialBlockHeight = 1
+	}
+
+	return validators, genesisTimestamp, accounts
 }
 
 // SimulateFromSeedLegacy tests an application by running the provided
@@ -79,6 +85,8 @@ func initChain(
 // * SimManager for module configs
 // * Config file for params
 // * whatever is needed for logging (tb + w rn)
+// OR: Could be a struct or something with options,
+//     to give caller ability to step through / instrument benchmarking if they wanted to, and add a cleanup function.
 func SimulateFromSeed(
 	tb testing.TB,
 	w io.Writer,
@@ -87,43 +95,16 @@ func SimulateFromSeed(
 	actions []simtypes.Action,
 	config simulation.Config,
 	cdc codec.JSONCodec,
-) (stopEarly bool, exportedParams Params, err error) {
+) (stopEarly bool, err error) {
 	// in case we have to end early, don't os.Exit so that we can run cleanup code.
-	testingMode, _, b := getTestingMode(tb)
-
-	fmt.Fprintf(w, "Starting SimulateFromSeed with randomness created with seed %d\n", int(config.Seed))
-	r := rand.New(rand.NewSource(config.Seed))
-	simParams := RandomParams(r)
-	fmt.Fprintf(w, "Randomized simulation params: \n%s\n", mustMarshalJSONIndent(simParams))
-
-	accs := initFunctions.RandomAccountFn(r, simParams.NumKeys())
-	if len(accs) == 0 {
-		return true, simParams, fmt.Errorf("must have greater than zero genesis accounts")
-	}
-
-	validators, genesisTimestamp, accs, chainID := initChain(r, simParams, accs, app, initFunctions.AppInitialStateFn, config, cdc)
-
-	config.ChainID = chainID
-	if config.InitialBlockHeight == 0 {
-		config.InitialBlockHeight = 1
-	}
-
-	fmt.Printf(
-		"Starting the simulation from time %v (unixtime %v)\n",
-		genesisTimestamp.UTC().Format(time.UnixDate), genesisTimestamp.Unix(),
-	)
+	// TODO: Understand exit pattern, this is so screwed up. Then delete ^
 
-	initialHeader := tmproto.Header{
-		ChainID:         chainID,
-		Height:          int64(config.InitialBlockHeight),
-		Time:            genesisTimestamp,
-		ProposerAddress: validators.randomProposer(r),
+	// Encapsulate the bizarre initialization logic that must be cleaned.
+	simCtx, simState, simParams, err := cursedInitializationLogic(tb, w, app, initFunctions, &config, cdc)
+	if err != nil {
+		return true, err
 	}
 
-	simState := newSimulatorState(simParams, initialHeader, tb, w, validators).WithLogParam(config.Lean)
-
-	simCtx := simtypes.NewSimCtx(r, app, accs, simState.header.ChainID)
-
 	// Setup code to catch SIGTERM's
 	c := make(chan os.Signal, 1)
 	signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGINT)
@@ -135,6 +116,7 @@ func SimulateFromSeed(
 		stopEarly = true
 	}()
 
+	testingMode, _, b := getTestingMode(tb)
 	blockSimulator := createBlockSimulator(testingMode, w, simParams, actions, simState, config)
 
 	if !testingMode {
@@ -152,33 +134,56 @@ func SimulateFromSeed(
 		}()
 	}
 
-	// set exported params to the initial state
-	if config.ExportParamsPath != "" && config.ExportParamsHeight == 0 {
-		exportedParams = simParams
-	}
+	stopEarly = simState.SimulateAllBlocks(w, simCtx, blockSimulator, config)
 
-	for height := config.InitialBlockHeight; height < config.NumBlocks+config.InitialBlockHeight && !stopEarly; height++ {
-		stopEarly = simState.SimulateBlock(simCtx, blockSimulator)
-		if stopEarly {
-			break
-		}
+	simState.eventStats.exportEvents(config.ExportStatsPath, w)
+	return stopEarly, nil
+}
 
-		if config.Commit {
-			simCtx.App.GetBaseApp().Commit()
-		}
+// The goal of this function is to group the extremely badly abstracted genesis logic,
+// into a single function we can target continuing to improve / abstract better.
+// It outputs SimCtx and SimState which are "cleaner" interface abstractions for the rest of the simulator.
+// It also outputs SimParams which is not great.
+// It also can modify config.
+func cursedInitializationLogic(
+	tb testing.TB,
+	w io.Writer,
+	app simtypes.App,
+	initFunctions simtypes.InitFunctions,
+	config *simulation.Config,
+	cdc codec.JSONCodec) (*simtypes.SimCtx, *simState, Params, error) {
+	fmt.Fprintf(w, "Starting SimulateFromSeed with randomness created with seed %d\n", int(config.Seed))
+
+	r := rand.New(rand.NewSource(config.Seed))
+	simParams := RandomParams(r)
+	fmt.Fprintf(w, "Randomized simulation params: \n%s\n", mustMarshalJSONIndent(simParams))
+
+	accs := initFunctions.RandomAccountFn(r, simParams.NumKeys())
+	if len(accs) == 0 {
+		return nil, nil, simParams, fmt.Errorf("must have greater than zero genesis accounts")
 	}
 
-	if !stopEarly {
-		fmt.Fprintf(
-			w,
-			"\nSimulation complete; Final height (blocks): %d, final time (seconds): %v, operations ran: %d\n",
-			simState.header.Height, simState.header.Time, simState.opCount,
-		)
-		simState.logWriter.PrintLogs()
+	validators, genesisTimestamp, accs := initChain(r, simParams, accs, app, initFunctions.AppInitialStateFn, config, cdc)
+
+	fmt.Printf(
+		"Starting the simulation from time %v (unixtime %v)\n",
+		genesisTimestamp.UTC().Format(time.UnixDate), genesisTimestamp.Unix(),
+	)
+
+	simCtx := simtypes.NewSimCtx(r, app, accs, config.ChainID)
+
+	initialHeader := tmproto.Header{
+		ChainID:         config.ChainID,
+		Height:          int64(config.InitialBlockHeight),
+		Time:            genesisTimestamp,
+		ProposerAddress: validators.randomProposer(r),
 	}
 
-	simState.eventStats.exportEvents(config.ExportStatsPath, w)
-	return stopEarly, exportedParams, nil
+	simState := newSimulatorState(simParams, initialHeader, tb, w, validators).WithLogParam(config.Lean)
+
+	// TODO: If simulation has a param export path configured, export params here.
+
+	return simCtx, simState, simParams, nil
 }
 
 //nolint:deadcode,unused
@@ -205,7 +210,8 @@ type blockSimFn func(simCtx *simtypes.SimCtx, ctx sdk.Context, header tmproto.He
 // Returns a function to simulate blocks. Written like this to avoid constant
 // parameters being passed everytime, to minimize memory overhead.
 func createBlockSimulator(testingMode bool, w io.Writer, params Params, actions []simtypes.Action,
-	simState *simState, config simulation.Config) blockSimFn {
+	simState *simState, config simulation.Config,
+) blockSimFn {
 	lastBlockSizeState := 0 // state for [4 * uniform distribution]
 	blocksize := 0
 	selectAction := getSelectActionFn(actions)
@@ -214,50 +220,54 @@ func createBlockSimulator(testingMode bool, w io.Writer, params Params, actions
 		simCtx *simtypes.SimCtx, ctx sdk.Context, header tmproto.Header,
 	) (opCount int) {
 		_, _ = fmt.Fprintf(
-			w, "\rSimulating... block %d/%d, operation %d/%d.",
-			header.Height, config.NumBlocks, opCount, blocksize,
+			w, "\rSimulating... block %d/%d, operation 0/%d.",
+			header.Height, config.NumBlocks, blocksize,
 		)
 		lastBlockSizeState, blocksize = getBlockSize(simCtx, params, lastBlockSizeState, config.BlockSize)
 
-		// TODO: Fix according to the r plans
-		// Predetermine the blocksize slice so that we can do things like block
-		// out certain operations without changing the ops that follow.
-		// NOTE: This is poor mans seeding, it will improve in our simctx plans =)
-		blockActions := make([]simtypes.Action, 0, blocksize)
+		blockNumStr := fmt.Sprintf("block %d", header.Height)
 		for i := 0; i < blocksize; i++ {
-			blockActions = append(blockActions, selectAction(simCtx.GetRand()))
-		}
+			// Sample and execute every action using independent randomness.
+			// Thus any change within one action's randomness won't waterfall
+			// to every other action and the overall order of txs.
+			// We can also use this to limit which operations we run, in debugging a simulator run.
+			actionSeed := fmt.Sprintf("%s operation %d", blockNumStr, i)
+			actionSimCtx, cleanup := simCtx.WrapRand(actionSeed)
 
-		for i := 0; i < blocksize; i++ {
-			action := blockActions[i]
-			// TODO: We need to make a simCtx.WithSeededRand, that replaces the rand map internally
-			// but allows updates to accounts.
-			opMsg, futureOps, err := action.Execute(simCtx, ctx)
-			opMsg.LogEvent(simState.eventStats.Tally)
-
-			if !simState.leanLogs || opMsg.OK {
-				simState.logWriter.AddEntry(MsgEntry(header.Height, int64(i), opMsg))
-			}
+			// Select and execute tx
+			action := selectAction(actionSimCtx.GetSeededRand("action select"))
+			opMsg, futureOps, err := action.Execute(actionSimCtx, ctx)
+			cleanup()
 
-			if err != nil {
-				simState.logWriter.PrintLogs()
-				simState.tb.Fatalf(`error on block  %d/%d, operation (%d/%d) from x/%s:
-%v
-Comment: %s`,
-					header.Height, config.NumBlocks, opCount, blocksize, opMsg.Route, err, opMsg.Comment)
-			}
+			simState.logActionResult(header, i, config, blocksize, opMsg, err)
 
-			queueOperations(simState.operationQueue, simState.timeOperationQueue, futureOps)
+			simState.queueOperations(futureOps)
 
-			if testingMode && opCount%50 == 0 {
+			if testingMode && i%50 == 0 {
 				fmt.Fprintf(w, "\rSimulating... block %d/%d, operation %d/%d. ",
-					header.Height, config.NumBlocks, opCount, blocksize)
+					header.Height, config.NumBlocks, i, blocksize)
 			}
-
-			opCount++
 		}
 
-		return opCount
+		return blocksize
+	}
+}
+
+// This is inheriting old functionality. We should break this as part of making logging be usable / make sense.
+func (simState *simState) logActionResult(
+	header tmproto.Header, actionIndex int, config simulation.Config, blocksize int,
+	opMsg simulation.OperationMsg, actionErr error) {
+	opMsg.LogEvent(simState.eventStats.Tally)
+	if !simState.leanLogs || opMsg.OK {
+		simState.logWriter.AddEntry(MsgEntry(header.Height, int64(actionIndex), opMsg))
+	}
+
+	if actionErr != nil {
+		simState.logWriter.PrintLogs()
+		simState.tb.Fatalf(`error on block  %d/%d, operation (%d/%d) from x/%s:
+%v
+Comment: %s`,
+			header.Height, config.NumBlocks, actionIndex, blocksize, opMsg.Route, actionErr, opMsg.Comment)
 	}
 }
 
@@ -277,7 +287,7 @@ func (simState *simState) runQueuedOperations(simCtx *simtypes.SimCtx, ctx sdk.C
 		// For now, queued operations cannot queue more operations.
 		// If a need arises for us to support queued messages to queue more messages, this can
 		// be changed.
-		opMsg, _, err := queuedOp[i](r, simCtx.App.GetBaseApp(), ctx, simCtx.Accounts, simCtx.ChainID)
+		opMsg, _, err := queuedOp[i](r, simCtx.BaseApp(), ctx, simCtx.Accounts, simCtx.ChainID())
 		opMsg.LogEvent(simState.eventStats.Tally)
 
 		if !simState.leanLogs || opMsg.OK {
@@ -286,6 +296,10 @@ func (simState *simState) runQueuedOperations(simCtx *simtypes.SimCtx, ctx sdk.C
 
 		if err != nil {
 			simState.logWriter.PrintLogs()
+			simState.tb.Fatalf(`error on block  %d, height queued operation (%d/%d) from x/%s:
+%v
+Comment: %s`,
+				simState.header.Height, i, numOpsRan, opMsg.Route, err, opMsg.Comment)
 			simState.tb.FailNow()
 		}
 	}
@@ -293,34 +307,3 @@ func (simState *simState) runQueuedOperations(simCtx *simtypes.SimCtx, ctx sdk.C
 
 	return numOpsRan
 }
-
-func (simState *simState) runQueuedTimeOperations(simCtx *simtypes.SimCtx, ctx sdk.Context) (
-	numOpsRan int) {
-	queueOps := simState.timeOperationQueue
-	currentTime := simState.header.Time
-	numOpsRan = 0
-	for len(queueOps) > 0 && currentTime.After(queueOps[0].BlockTime) {
-		// TODO: Fix according to the r plans
-		r := simCtx.GetRand()
-
-		// For now, queued operations cannot queue more operations.
-		// If a need arises for us to support queued messages to queue more messages, this can
-		// be changed.
-		opMsg, _, err := queueOps[0].Op(r, simCtx.App.GetBaseApp(), ctx, simCtx.Accounts, simCtx.ChainID)
-		opMsg.LogEvent(simState.eventStats.Tally)
-
-		if !simState.leanLogs || opMsg.OK {
-			simState.logWriter.AddEntry(QueuedMsgEntry(simState.header.Height, opMsg))
-		}
-
-		if err != nil {
-			simState.logWriter.PrintLogs()
-			simState.tb.FailNow()
-		}
-
-		queueOps = queueOps[1:]
-		numOpsRan++
-	}
-	simState.timeOperationQueue = queueOps
-	return numOpsRan
-}
diff --git a/simulation/executor/simulate_dev.go b/simulation/executor/simulate_dev.go
index 8f14b7da0..20ab9bf4d 100644
--- a/simulation/executor/simulate_dev.go
+++ b/simulation/executor/simulate_dev.go
@@ -20,8 +20,7 @@ type simState struct {
 
 	// These are operations which have been queued by previous operations
 	// TODO: Replace with new action syntax
-	operationQueue     map[int][]simulation.Operation
-	timeOperationQueue []simulation.FutureOperation
+	operationQueue map[int][]simulation.Operation
 
 	curValidators  mockValidators
 	nextValidators mockValidators
@@ -49,19 +48,18 @@ type simState struct {
 
 func newSimulatorState(simParams Params, initialHeader tmproto.Header, tb testing.TB, w io.Writer, validators mockValidators) *simState {
 	return &simState{
-		simParams:          simParams,
-		header:             initialHeader,
-		operationQueue:     NewOperationQueue(),
-		timeOperationQueue: []simulation.FutureOperation{},
-		curValidators:      validators.Clone(),
-		nextValidators:     validators.Clone(),
-		tb:                 tb,
-		pastTimes:          []time.Time{},
-		pastVoteInfos:      [][]abci.VoteInfo{},
-		logWriter:          NewLogWriter(tb),
-		w:                  w,
-		eventStats:         NewEventStats(),
-		opCount:            0,
+		simParams:      simParams,
+		header:         initialHeader,
+		operationQueue: NewOperationQueue(),
+		curValidators:  validators.Clone(),
+		nextValidators: validators.Clone(),
+		tb:             tb,
+		pastTimes:      []time.Time{},
+		pastVoteInfos:  [][]abci.VoteInfo{},
+		logWriter:      NewLogWriter(tb),
+		w:              w,
+		eventStats:     NewEventStats(),
+		opCount:        0,
 	}
 }
 
@@ -70,6 +68,34 @@ func (simState *simState) WithLogParam(leanLogs bool) *simState {
 	return simState
 }
 
+func (simState *simState) SimulateAllBlocks(
+	w io.Writer,
+	simCtx *simtypes.SimCtx,
+	blockSimulator blockSimFn,
+	config simulation.Config) (stopEarly bool) {
+	stopEarly = false
+	for height := config.InitialBlockHeight; height < config.NumBlocks+config.InitialBlockHeight && !stopEarly; height++ {
+		stopEarly = simState.SimulateBlock(simCtx, blockSimulator)
+		if stopEarly {
+			break
+		}
+
+		if config.Commit {
+			simCtx.BaseApp().Commit()
+		}
+	}
+
+	if !stopEarly {
+		fmt.Fprintf(
+			w,
+			"\nSimulation complete; Final height (blocks): %d, final time (seconds): %v, operations ran: %d\n",
+			simState.header.Height, simState.header.Time, simState.opCount,
+		)
+		simState.logWriter.PrintLogs()
+	}
+	return stopEarly
+}
+
 // simulate a block, update state
 func (simState *simState) SimulateBlock(simCtx *simtypes.SimCtx, blockSimulator blockSimFn) (stopEarly bool) {
 	if simState.header.ProposerAddress == nil {
@@ -78,16 +104,16 @@ func (simState *simState) SimulateBlock(simCtx *simtypes.SimCtx, blockSimulator
 	}
 
 	requestBeginBlock := simState.beginBlock(simCtx)
-	ctx := simCtx.App.GetBaseApp().NewContext(false, simState.header)
+	ctx := simCtx.BaseApp().NewContext(false, simState.header)
 
 	// Run queued operations. Ignores blocksize if blocksize is too small
 	numQueuedOpsRan := simState.runQueuedOperations(simCtx, ctx)
-	numQueuedTimeOpsRan := simState.runQueuedTimeOperations(simCtx, ctx)
+	// numQueuedTimeOpsRan := simState.runQueuedTimeOperations(simCtx, ctx)
 
 	// run standard operations
 	// TODO: rename blockSimulator arg
 	operations := blockSimulator(simCtx, ctx, simState.header)
-	simState.opCount += operations + numQueuedOpsRan + numQueuedTimeOpsRan
+	simState.opCount += operations + numQueuedOpsRan // + numQueuedTimeOpsRan
 
 	responseEndBlock := simState.endBlock(simCtx)
 
@@ -101,12 +127,12 @@ func (simState *simState) beginBlock(simCtx *simtypes.SimCtx) abci.RequestBeginB
 	requestBeginBlock := RandomRequestBeginBlock(simCtx.GetRand(), simState.simParams, simState.curValidators, simState.pastTimes, simState.pastVoteInfos, simState.eventStats.Tally, simState.header)
 	// Run the BeginBlock handler
 	simState.logWriter.AddEntry(BeginBlockEntry(simState.header.Height))
-	simCtx.App.GetBaseApp().BeginBlock(requestBeginBlock)
+	simCtx.BaseApp().BeginBlock(requestBeginBlock)
 	return requestBeginBlock
 }
 
 func (simState *simState) endBlock(simCtx *simtypes.SimCtx) abci.ResponseEndBlock {
-	res := simCtx.App.GetBaseApp().EndBlock(abci.RequestEndBlock{})
+	res := simCtx.BaseApp().EndBlock(abci.RequestEndBlock{})
 	simState.logWriter.AddEntry(EndBlockEntry(simState.header.Height))
 	return res
 }
diff --git a/simulation/executor/util.go b/simulation/executor/util.go
index e21849d4d..f15a9b5aa 100644
--- a/simulation/executor/util.go
+++ b/simulation/executor/util.go
@@ -3,15 +3,8 @@ package simulation
 import (
 	"encoding/json"
 	"fmt"
-	"math/rand"
 	"testing"
 
-	"github.com/cosmos/cosmos-sdk/baseapp"
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	simulation "github.com/cosmos/cosmos-sdk/types/simulation"
-
 	simtypes "github.com/osmosis-labs/osmosis/v7/simulation/types"
 )
 
@@ -63,19 +56,3 @@ func mustMarshalJSONIndent(o interface{}) []byte {
 
 	return bz
 }
-
-// OperationInput is a struct that holds all the needed values to generate a tx and deliver it
-type OperationInput struct {
-	R               *rand.Rand
-	App             *baseapp.BaseApp
-	TxGen           client.TxConfig
-	Cdc             *codec.ProtoCodec
-	Msg             sdk.Msg
-	MsgType         string
-	CoinsSpentInMsg sdk.Coins
-	Context         sdk.Context
-	SimAccount      simulation.Account
-	AccountKeeper   AccountKeeper
-	Bankkeeper      BankKeeper
-	ModuleName      string
-}
diff --git a/simulation/types/account.go b/simulation/types/account.go
index dcde70d08..670c345f1 100644
--- a/simulation/types/account.go
+++ b/simulation/types/account.go
@@ -65,7 +65,7 @@ func (sim *SimCtx) FindAccount(address sdk.Address) (simulation.Account, bool) {
 
 func (sim *SimCtx) RandomSimAccountWithBalance(ctx sdk.Context) (simulation.Account, error) {
 	accHasBal := func(acc simulation.Account) bool {
-		return len(sim.App.GetBankKeeper().SpendableCoins(ctx, acc.Address)) != 0
+		return len(sim.BankKeeper().SpendableCoins(ctx, acc.Address)) != 0
 	}
 	acc, found := sim.RandomSimAccountWithConstraint(accHasBal)
 	if !found {
@@ -80,7 +80,7 @@ func (sim *SimCtx) RandomSimAccountWithBalance(ctx sdk.Context) (simulation.Acco
 func (sim *SimCtx) SelAddrWithDenoms(ctx sdk.Context, denoms []string) (simulation.Account, sdk.Coins, bool) {
 	accHasDenoms := func(acc simulation.Account) bool {
 		for _, denom := range denoms {
-			if sim.App.GetBankKeeper().GetBalance(ctx, acc.Address, denom).Amount.IsZero() {
+			if sim.BankKeeper().GetBalance(ctx, acc.Address, denom).Amount.IsZero() {
 				return false
 			}
 		}
@@ -100,7 +100,7 @@ func (sim *SimCtx) SelAddrWithDenoms(ctx sdk.Context, denoms []string) (simulati
 // (Meaning that on average it samples 10% of the chosen balance)
 // Pre-condition: Addr must have a spendable balance
 func (sim *SimCtx) RandExponentialCoin(ctx sdk.Context, addr sdk.AccAddress) sdk.Coin {
-	balances := sim.App.GetBankKeeper().SpendableCoins(ctx, addr)
+	balances := sim.BankKeeper().SpendableCoins(ctx, addr)
 	if len(balances) == 0 {
 		panic("precondition for RandExponentialCoin broken: Addr has 0 spendable balance")
 	}
@@ -124,7 +124,7 @@ func (sim *SimCtx) RandExponentialCoin(ctx sdk.Context, addr sdk.AccAddress) sdk
 func (sim *SimCtx) RandCoinSubset(ctx sdk.Context, addr sdk.AccAddress, denoms []string) sdk.Coins {
 	subsetCoins := sdk.Coins{}
 	for _, denom := range denoms {
-		bal := sim.App.GetBankKeeper().GetBalance(ctx, addr, denom)
+		bal := sim.BankKeeper().GetBalance(ctx, addr, denom)
 		amt, err := sim.RandPositiveInt(bal.Amount)
 		if err != nil {
 			panic(err)
diff --git a/simulation/types/action.go b/simulation/types/action.go
index 64eaac5a9..0d1830556 100644
--- a/simulation/types/action.go
+++ b/simulation/types/action.go
@@ -28,20 +28,26 @@ type Action interface {
 }
 
 type weightedOperationAction struct {
-	op simulation.WeightedOperation
+	moduleName string
+	op         simulation.WeightedOperation
 }
 
-func (a weightedOperationAction) Name() string   { return "weighted_op" }
+func (a weightedOperationAction) Name() string   { return fmt.Sprintf("%s: weighted_op", a.moduleName) }
 func (a weightedOperationAction) Weight() Weight { return Weight(a.op.Weight()) }
 func (a weightedOperationAction) Execute(sim *SimCtx, ctx sdk.Context) (
-	simulation.OperationMsg, []simulation.FutureOperation, error) {
-	return a.op.Op()(sim.GetRand(), sim.App.GetBaseApp(), ctx, sim.Accounts, sim.ChainID)
+	simulation.OperationMsg, []simulation.FutureOperation, error,
+) {
+	return a.op.Op()(sim.GetRand(), sim.BaseApp(), ctx, sim.Accounts, sim.ChainID())
 }
 
 func ActionsFromWeightedOperations(ops legacysimexec.WeightedOperations) []Action {
+	return actionsFromWeightedOperations("no module name", ops)
+}
+
+func actionsFromWeightedOperations(moduleName string, ops legacysimexec.WeightedOperations) []Action {
 	actions := make([]Action, 0, len(ops))
 	for _, op := range ops {
-		actions = append(actions, weightedOperationAction{op: op})
+		actions = append(actions, weightedOperationAction{moduleName: moduleName, op: op})
 	}
 	return actions
 }
@@ -85,7 +91,8 @@ func (m msgBasedAction) WithWeight(weight Weight) msgBasedAction {
 func (m msgBasedAction) Name() string   { return m.name }
 func (m msgBasedAction) Weight() Weight { return m.weight }
 func (m msgBasedAction) Execute(sim *SimCtx, ctx sdk.Context) (
-	OperationMsg simulation.OperationMsg, futureOps []simulation.FutureOperation, err error) {
+	OperationMsg simulation.OperationMsg, futureOps []simulation.FutureOperation, err error,
+) {
 	msg, err := m.msgGenerator(sim, ctx)
 	if err != nil {
 		return simulation.NoOpMsg(m.name, m.name, fmt.Sprintf("unable to build msg due to: %v", err)), nil, nil
diff --git a/simulation/types/manager.go b/simulation/types/manager.go
index 063f693b6..335490fc5 100644
--- a/simulation/types/manager.go
+++ b/simulation/types/manager.go
@@ -19,15 +19,16 @@ import (
 type AppModuleSimulationV2 interface {
 	module.AppModule
 
-	// randomized genesis states
-	// TODO: Come back and improve SimulationState interface
-	// TODO: Move this to an extension interface
-	// default: simState.GenState[types.ModuleName] = app.DefaultGenesis(simState.Cdc)
-	GenerateGenesisState(*module.SimulationState, *SimCtx)
 	Actions() []Action
 	// PropertyTests()
 }
 
+type AppModuleSimulationV2WithRandGenesis interface {
+	AppModuleSimulationV2
+	// TODO: Come back and improve SimulationState interface
+	RandomGenesisState(*module.SimulationState, *SimCtx)
+}
+
 // SimulationManager defines a simulation manager that provides the high level utility
 // for managing and executing simulation functionalities for a group of modules
 type Manager struct {
@@ -100,13 +101,14 @@ func (m Manager) legacyActions(seed int64, cdc codec.JSONCodec) []Action {
 		}
 	}
 	// second pass generate actions
-	weightedOps := []simulation.WeightedOperation{}
+	actions := []Action{}
 	for _, moduleName := range m.moduleManager.OrderInitGenesis {
 		if simModule, ok := m.legacyModules[moduleName]; ok {
-			weightedOps = append(weightedOps, simModule.WeightedOperations(simState)...)
+			weightedOps := simModule.WeightedOperations(simState)
+			actions = append(actions, actionsFromWeightedOperations(moduleName, weightedOps)...)
 		}
 	}
-	return ActionsFromWeightedOperations(weightedOps)
+	return actions
 }
 
 // TODO: Can we use sim here instead? Perhaps by passing in the simulation module manager to the simulator.
@@ -137,7 +139,12 @@ func (m Manager) Actions(seed int64, cdc codec.JSONCodec) []Action {
 func (m Manager) GenerateGenesisStates(simState *module.SimulationState, sim *SimCtx) {
 	for _, moduleName := range m.moduleManager.OrderInitGenesis {
 		if simModule, ok := m.Modules[moduleName]; ok {
-			simModule.GenerateGenesisState(simState, sim)
+			// if we define a random genesis function use it, otherwise use default genesis
+			if mod, ok := simModule.(AppModuleSimulationV2WithRandGenesis); ok {
+				mod.RandomGenesisState(simState, sim)
+			} else {
+				simState.GenState[simModule.Name()] = simModule.DefaultGenesis(simState.Cdc)
+			}
 		}
 		if simModule, ok := m.legacyModules[moduleName]; ok {
 			simModule.GenerateGenesisState(simState)
diff --git a/simulation/types/random/sdkrand.go b/simulation/types/random/sdkrand.go
index a2ab78b86..89c950ef3 100644
--- a/simulation/types/random/sdkrand.go
+++ b/simulation/types/random/sdkrand.go
@@ -53,7 +53,7 @@ func RandPositiveInt(r *rand.Rand, max sdk.Int) (sdk.Int, error) {
 // RandomAmount generates a random amount
 // Note: The range of RandomAmount includes max, and is, in fact, biased to return max as well as 0.
 func RandomAmount(r *rand.Rand, max sdk.Int) sdk.Int {
-	var randInt = big.NewInt(0)
+	randInt := big.NewInt(0)
 
 	switch r.Intn(10) {
 	case 0:
@@ -70,7 +70,7 @@ func RandomAmount(r *rand.Rand, max sdk.Int) sdk.Int {
 // RandomDecAmount generates a random decimal amount
 // Note: The range of RandomDecAmount includes max, and is, in fact, biased to return max as well as 0.
 func RandomDecAmount(r *rand.Rand, max sdk.Dec) sdk.Dec {
-	var randInt = big.NewInt(0)
+	randInt := big.NewInt(0)
 
 	switch r.Intn(10) {
 	case 0:
diff --git a/simulation/types/simctx.go b/simulation/types/simctx.go
index b78267877..fb3b8c1ee 100644
--- a/simulation/types/simctx.go
+++ b/simulation/types/simctx.go
@@ -1,8 +1,12 @@
 package simulation
 
 import (
+	"crypto/sha256"
+	"encoding/binary"
+	"fmt"
 	"math/rand"
 
+	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/cosmos/cosmos-sdk/codec"
@@ -12,44 +16,146 @@ import (
 //nolint:structcheck
 //TODO: Contemplate name better
 type SimCtx struct {
-	r *rand.Rand
-	// TODO: delete this, once we cleanup simulator initialization logic,
-	// and can then setup SimCtx with base seed.
-	internalSeed int64
-	rCounter     int64
-	seededMap    map[string]*rand.Rand
+	rm randManager
 
-	App      App
 	Accounts []simulation.Account
 	Cdc      codec.JSONCodec // application codec
-	ChainID  string
+
+	app     App
+	chainID string
 
 	txbuilder func(ctx sdk.Context, msg sdk.Msg, msgName string) (sdk.Tx, error)
 }
 
 func NewSimCtx(r *rand.Rand, app App, accounts []simulation.Account, chainID string) *SimCtx {
 	sim := &SimCtx{
-		r:            r,
-		internalSeed: r.Int63(),
-		rCounter:     0,
-		seededMap:    map[string]*rand.Rand{},
-
-		App:      app,
+		rm:       newRandManager(r),
+		app:      app,
 		Accounts: accounts,
-		ChainID:  chainID,
+		chainID:  chainID,
 	}
 	sim.txbuilder = sim.defaultTxBuilder
 	return sim
 }
 
+// TODO: Consider rename to Rand()
 func (sim *SimCtx) GetRand() *rand.Rand {
-	sim.rCounter += 1
-	r := rand.New(rand.NewSource(sim.internalSeed + sim.rCounter))
-	return r
+	return sim.rm.GetRand()
 }
 
-// TODO: Refactor to eventually seed a new prng from seed
-// and maintain a cache of seed -> rand
+// TODO: Consider rename to SeededRand()
+// or DomainSeparatedRand
 func (sim *SimCtx) GetSeededRand(seed string) *rand.Rand {
-	return sim.r
+	return sim.rm.GetSeededRand(seed)
+}
+
+// WrapRand returns a new sim object and a cleanup function to write
+// Accounts changes to the parent (and invalidate the prior)
+func (sim *SimCtx) WrapRand(domainSeparator string) (wrappedSim *SimCtx, cleanup func()) {
+	wrappedSim = &SimCtx{
+		rm:        sim.rm.WrapRand(domainSeparator),
+		app:       sim.app,
+		Accounts:  sim.Accounts,
+		Cdc:       sim.Cdc,
+		chainID:   sim.chainID,
+		txbuilder: sim.txbuilder,
+	}
+	cleanup = func() {
+		sim.Accounts = wrappedSim.Accounts
+		wrappedSim.Accounts = nil
+	}
+	return wrappedSim, cleanup
+}
+
+func (sim SimCtx) ChainID() string {
+	return sim.chainID
+}
+
+func (sim SimCtx) BaseApp() *baseapp.BaseApp {
+	return sim.app.GetBaseApp()
+}
+
+func (sim SimCtx) AppCodec() codec.Codec {
+	return sim.app.AppCodec()
+}
+
+func (sim SimCtx) AccountKeeper() AccountKeeper {
+	return sim.app.GetAccountKeeper()
+}
+
+func (sim SimCtx) BankKeeper() BankKeeper {
+	return sim.app.GetBankKeeper()
+}
+
+// randManager is built to give API's for randomness access
+// which allow the caller to avoid "butterfly effects".
+// e.g. in the Simulator, I don't want adding one new rand call to a message
+// to create an entirely new "run" shape.
+type randManager struct {
+	// TODO: delete this, once we cleanup simulator initialization logic,
+	// and can then setup SimCtx with base seed.
+	internalSeed int64
+	rCounter     int64
+	seededMap    map[string]*rand.Rand
+
+	// if debug = true, we maintain a list of "seen" calls to Wrap,
+	// to ensure no duplicates ever get made.
+	// TODO: Find a way to expose this to executor.
+	// Perhaps we move this to an internal package?
+	debug     bool
+	seenWraps map[string]bool
+}
+
+// TODO: Refactor to take in seed as API's improve
+func newRandManager(r *rand.Rand) randManager {
+	return randManager{
+		internalSeed: r.Int63(),
+		rCounter:     0,
+		seededMap:    map[string]*rand.Rand{},
+		debug:        false,
+		seenWraps:    map[string]bool{},
+	}
+}
+
+func stringToSeed(s string) int64 {
+	// take first 8 bytes of the sha256 hash of s.
+	// We use this for seeding our rand instances.
+	// We use a hash just for convenience, we don't need cryptographic collision resistance,
+	// just simple collisions being unlikely.
+	bz := sha256.Sum256([]byte(s))
+	seedInt := binary.BigEndian.Uint64(bz[:8])
+	return int64(seedInt)
+}
+
+func (rm *randManager) WrapRand(domainSeparator string) randManager {
+	if rm.debug {
+		if _, found := rm.seenWraps[domainSeparator]; found {
+			panic(fmt.Sprintf("domain separator %s reused!", domainSeparator))
+		}
+		rm.seenWraps[domainSeparator] = true
+	}
+
+	sepInt := stringToSeed(domainSeparator)
+	newSeed := rm.internalSeed + sepInt
+	r := rand.New(rand.NewSource(newSeed))
+	return newRandManager(r)
+}
+
+func (rm *randManager) GetRand() *rand.Rand {
+	rm.rCounter += 1
+	r := rand.New(rand.NewSource(rm.internalSeed + rm.rCounter))
+	return r
+}
+
+// TODO: Consider rename to DomainSeparatedRand
+func (rm *randManager) GetSeededRand(seed string) *rand.Rand {
+	// use value in map if present
+	if r, ok := rm.seededMap[seed]; ok {
+		return r
+	}
+	seedInt := stringToSeed(seed)
+	newSeed := rm.internalSeed + seedInt
+	r := rand.New(rand.NewSource(newSeed))
+	rm.seededMap[seed] = r
+	return r
 }
diff --git a/simulation/types/txbuilder.go b/simulation/types/txbuilder.go
index 05c9c47fb..f7d07d1c5 100644
--- a/simulation/types/txbuilder.go
+++ b/simulation/types/txbuilder.go
@@ -32,7 +32,7 @@ func (sim *SimCtx) defaultTxBuilder(
 	if !found {
 		return nil, errors.New("unable to generate mock tx: sim acct not found")
 	}
-	authAcc := sim.App.GetAccountKeeper().GetAccount(ctx, account.Address)
+	authAcc := sim.AccountKeeper().GetAccount(ctx, account.Address)
 	txConfig := params.MakeEncodingConfig().TxConfig // TODO: unhardcode
 	// TODO: Consider making a default tx builder that charges some random fees
 	// Low value for amount of work right now though.
@@ -56,7 +56,7 @@ func (sim *SimCtx) defaultTxBuilder(
 // TODO: Fix these args
 func (sim *SimCtx) deliverTx(tx sdk.Tx, msg sdk.Msg, msgName string) (simulation.OperationMsg, []simulation.FutureOperation, error) {
 	txConfig := params.MakeEncodingConfig().TxConfig // TODO: unhardcode
-	_, results, err := sim.App.GetBaseApp().Deliver(txConfig.TxEncoder(), tx)
+	_, results, err := sim.BaseApp().Deliver(txConfig.TxEncoder(), tx)
 	if err != nil {
 		return simulation.NoOpMsg(msgName, msgName, fmt.Sprintf("unable to deliver tx. \nreason: %v\n results: %v\n msg: %s\n tx: %s", err, results, msg, tx)), nil, err
 	}
diff --git a/x/gamm/module.go b/x/gamm/module.go
index df389ae70..ce1f7ae38 100644
--- a/x/gamm/module.go
+++ b/x/gamm/module.go
@@ -158,9 +158,6 @@ func (am AppModule) EndBlock(ctx sdk.Context, _ abci.RequestEndBlock) []abci.Val
 func (AppModule) ConsensusVersion() uint64 { return 1 }
 
 // **** simulation implementation ****
-func (am AppModule) GenerateGenesisState(m *module.SimulationState, s *simulation.SimCtx) {
-	m.GenState[types.ModuleName] = am.DefaultGenesis(m.Cdc)
-}
 
 func (am AppModule) Actions() []simulation.Action {
 	return []simulation.Action{
diff --git a/x/lockup/module.go b/x/lockup/module.go
index 05de92c6c..f5665e275 100644
--- a/x/lockup/module.go
+++ b/x/lockup/module.go
@@ -185,11 +185,6 @@ func (AppModule) ConsensusVersion() uint64 { return 1 }
 
 // AppModuleSimulationV2 functions
 
-// GenerateGenesisState creates a randomized GenState of the pool-incentives module.
-func (am AppModule) GenerateGenesisState(simState *module.SimulationState, s *simulation.SimCtx) {
-	simState.GenState[types.ModuleName] = am.DefaultGenesis(simState.Cdc)
-}
-
 // WeightedOperations returns the all the lockup module operations with their respective weights.
 func (am AppModule) Actions() []simulation.Action {
 	return []simulation.Action{


Test patch:
diff --git a/osmomath/math_test.go b/osmomath/math_test.go
index c01caf80e..b369db336 100644
--- a/osmomath/math_test.go
+++ b/osmomath/math_test.go
@@ -1,10 +1,13 @@
 package osmomath
 
 import (
+	"fmt"
 	"testing"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
+	"github.com/osmosis-labs/osmosis/v7/osmoutils"
+
 	"github.com/stretchr/testify/require"
 )
 
@@ -23,50 +26,143 @@ func TestAbsDifferenceWithSign(t *testing.T) {
 }
 
 func TestPowApprox(t *testing.T) {
-	base, err := sdk.NewDecFromStr("0.8")
-	require.NoError(t, err)
-	exp, err := sdk.NewDecFromStr("0.32")
-	require.NoError(t, err)
-
-	s := PowApprox(base, exp, powPrecision)
-	expectedDec, err := sdk.NewDecFromStr("0.93108385")
-	require.NoError(t, err)
-
-	require.True(
-		t,
-		expectedDec.Sub(s).Abs().LTE(powPrecision),
-		"expected value & actual value's difference should less than precision",
-	)
+	testCases := []struct {
+		base           sdk.Dec
+		exp            sdk.Dec
+		powPrecision   sdk.Dec
+		expectedResult sdk.Dec
+	}{
+		{
+			// medium base, small exp
+			base:           sdk.MustNewDecFromStr("0.8"),
+			exp:            sdk.MustNewDecFromStr("0.32"),
+			powPrecision:   sdk.MustNewDecFromStr("0.00000001"),
+			expectedResult: sdk.MustNewDecFromStr("0.93108385"),
+		},
+		{
+			// zero exp
+			base:           sdk.MustNewDecFromStr("0.8"),
+			exp:            sdk.ZeroDec(),
+			powPrecision:   sdk.MustNewDecFromStr("0.00001"),
+			expectedResult: sdk.OneDec(),
+		},
+		{
+			// zero base, this should panic
+			base:           sdk.ZeroDec(),
+			exp:            sdk.OneDec(),
+			powPrecision:   sdk.MustNewDecFromStr("0.00001"),
+			expectedResult: sdk.ZeroDec(),
+		},
+		{
+			// large base, small exp
+			base:           sdk.MustNewDecFromStr("1.9999"),
+			exp:            sdk.MustNewDecFromStr("0.23"),
+			powPrecision:   sdk.MustNewDecFromStr("0.000000001"),
+			expectedResult: sdk.MustNewDecFromStr("1.172821461"),
+		},
+		{
+			// large base, large integer exp
+			base:           sdk.MustNewDecFromStr("1.777"),
+			exp:            sdk.MustNewDecFromStr("20"),
+			powPrecision:   sdk.MustNewDecFromStr("0.000000000001"),
+			expectedResult: sdk.MustNewDecFromStr("98570.862372081602"),
+		},
+		{
+			// medium base, large exp, high precision
+			base:           sdk.MustNewDecFromStr("1.556"),
+			exp:            sdk.MustNewDecFromStr("20.9123"),
+			powPrecision:   sdk.MustNewDecFromStr("0.0000000000000001"),
+			expectedResult: sdk.MustNewDecFromStr("10360.058421529811344618"),
+		},
+		{
+			// high base, large exp, high precision
+			base:           sdk.MustNewDecFromStr("1.886"),
+			exp:            sdk.MustNewDecFromStr("31.9123"),
+			powPrecision:   sdk.MustNewDecFromStr("0.00000000000001"),
+			expectedResult: sdk.MustNewDecFromStr("621110716.84727942280335811"),
+		},
+		{
+			// base equal one
+			base:           sdk.MustNewDecFromStr("1"),
+			exp:            sdk.MustNewDecFromStr("123"),
+			powPrecision:   sdk.MustNewDecFromStr("0.00000001"),
+			expectedResult: sdk.OneDec(),
+		},
+	}
 
-	base, err = sdk.NewDecFromStr("0.8")
-	require.NoError(t, err)
-	exp = sdk.ZeroDec()
-	require.NoError(t, err)
-
-	s = PowApprox(base, exp, powPrecision)
-	expectedDec = sdk.OneDec()
-	require.NoError(t, err)
-
-	require.True(
-		t,
-		expectedDec.Sub(s).Abs().LTE(powPrecision),
-		"expected value & actual value's difference should less than precision",
-	)
+	for i, tc := range testCases {
+		var actualResult sdk.Dec
+		osmoutils.ConditionalPanic(t, tc.base.Equal(sdk.ZeroDec()), func() {
+			fmt.Println(tc.base)
+			actualResult = PowApprox(tc.base, tc.exp, tc.powPrecision)
+			require.True(
+				t,
+				tc.expectedResult.Sub(actualResult).Abs().LTE(tc.powPrecision),
+				fmt.Sprintf("test %d failed: expected value & actual value's difference should be less than precision", i),
+			)
+		})
+	}
 }
 
 func TestPow(t *testing.T) {
-	base, err := sdk.NewDecFromStr("1.68")
-	require.NoError(t, err)
-	exp, err := sdk.NewDecFromStr("0.32")
-	require.NoError(t, err)
-
-	s := Pow(base, exp)
-	expectedDec, err := sdk.NewDecFromStr("1.18058965")
-	require.NoError(t, err)
+	testCases := []struct {
+		base           sdk.Dec
+		exp            sdk.Dec
+		expectedResult sdk.Dec
+	}{
+		{
+			// medium base, small exp
+			base:           sdk.MustNewDecFromStr("0.8"),
+			exp:            sdk.MustNewDecFromStr("0.32"),
+			expectedResult: sdk.MustNewDecFromStr("0.93108385"),
+		},
+		{
+			// zero exp
+			base:           sdk.MustNewDecFromStr("0.8"),
+			exp:            sdk.ZeroDec(),
+			expectedResult: sdk.OneDec(),
+		},
+		{
+			// zero base, this should panic
+			base:           sdk.ZeroDec(),
+			exp:            sdk.OneDec(),
+			expectedResult: sdk.ZeroDec(),
+		},
+		{
+			// large base, small exp
+			base:           sdk.MustNewDecFromStr("1.9999"),
+			exp:            sdk.MustNewDecFromStr("0.23"),
+			expectedResult: sdk.MustNewDecFromStr("1.172821461"),
+		},
+		{
+			// small base, large exp
+			base:           sdk.MustNewDecFromStr("0.0000123"),
+			exp:            sdk.MustNewDecFromStr("123"),
+			expectedResult: sdk.ZeroDec(),
+		},
+		{
+			// large base, large exp
+			base:           sdk.MustNewDecFromStr("1.777"),
+			exp:            sdk.MustNewDecFromStr("20"),
+			expectedResult: sdk.MustNewDecFromStr("98570.862372081602"),
+		},
+		{
+			// base equal one
+			base:           sdk.MustNewDecFromStr("1"),
+			exp:            sdk.MustNewDecFromStr("123"),
+			expectedResult: sdk.OneDec(),
+		},
+	}
 
-	require.True(
-		t,
-		expectedDec.Sub(s).Abs().LTE(powPrecision),
-		"expected value & actual value's difference should less than precision",
-	)
+	for i, tc := range testCases {
+		var actualResult sdk.Dec
+		osmoutils.ConditionalPanic(t, tc.base.Equal(sdk.ZeroDec()), func() {
+			actualResult = Pow(tc.base, tc.exp)
+			require.True(
+				t,
+				tc.expectedResult.Sub(actualResult).Abs().LTE(powPrecision),
+				fmt.Sprintf("test %d failed: expected value & actual value's difference should be less than precision", i),
+			)
+		})
+	}
 }
diff --git a/simulation/executor/params_test.go b/simulation/executor/params_test.go
deleted file mode 100644
index 3eb3ad8bc..000000000
--- a/simulation/executor/params_test.go
+++ /dev/null
@@ -1,56 +0,0 @@
-package simulation
-
-import (
-	"fmt"
-	"math/rand"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
-
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
-)
-
-func TestParamChange(t *testing.T) {
-	subspace, key := "theSubspace", "key"
-	f := func(r *rand.Rand) string {
-		return "theResult"
-	}
-
-	pChange := NewSimParamChange(subspace, key, f)
-
-	require.Equal(t, subspace, pChange.Subspace())
-	require.Equal(t, key, pChange.Key())
-	require.Equal(t, f(nil), pChange.SimValue()(nil))
-	require.Equal(t, fmt.Sprintf("%s/%s", subspace, key), pChange.ComposedKey())
-}
-
-func TestNewWeightedProposalContent(t *testing.T) {
-	key := "theKey"
-	weight := 1
-	content := &testContent{}
-	f := func(r *rand.Rand, ctx sdk.Context, accs []simtypes.Account) simtypes.Content {
-		return content
-	}
-
-	pContent := NewWeightedProposalContent(key, weight, f)
-
-	require.Equal(t, key, pContent.AppParamsKey())
-	require.Equal(t, weight, pContent.DefaultWeight())
-
-	ctx := sdk.NewContext(nil, tmproto.Header{}, true, nil)
-	require.Equal(t, content, pContent.ContentSimulatorFn()(nil, ctx, nil))
-}
-
-type testContent struct {
-}
-
-func (t testContent) GetTitle() string                { return "" }
-func (t testContent) GetDescription() string          { return "" }
-func (t testContent) GetIsExpedited() bool            { return false }
-func (t testContent) SetIsExpedited(isExpedited bool) {}
-func (t testContent) ProposalRoute() string           { return "" }
-func (t testContent) ProposalType() string            { return "" }
-func (t testContent) ValidateBasic() error            { return nil }
-func (t testContent) String() string                  { return "" }
diff --git a/simulation/types/randmanager_test.go b/simulation/types/randmanager_test.go
new file mode 100644
index 000000000..4e7fa116d
--- /dev/null
+++ b/simulation/types/randmanager_test.go
@@ -0,0 +1,87 @@
+package simulation
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+var defaultSeed = int64(10)
+
+func getDefaultRandInstance() *rand.Rand {
+	return rand.New(rand.NewSource(defaultSeed))
+}
+
+func getKDefaultRandManager(k int) []randManager {
+	rms := make([]randManager, k)
+	for i := 0; i < k; i++ {
+		rms[i] = newRandManager(getDefaultRandInstance())
+	}
+	return rms
+}
+
+func randInstancesEqual(rands []*rand.Rand) bool {
+	value := rands[0].Int()
+	for i := 1; i < len(rands); i++ {
+		if rands[i].Int() != value {
+			return false
+		}
+	}
+	return true
+}
+
+// Test that the rand manager GetRand() are all independent of one another.
+func TestRandManagerGetRandIndependence(t *testing.T) {
+	rms := getKDefaultRandManager(3)
+	expectedEqualRands := []*rand.Rand{}
+	// We want to test that in each of the the following three scenarios, r2 is equal:
+	// 1) r1 := rm.GetRand(); r2 := rm.GetRand();
+	// 2) r1 := rm.GetRand(); r2 := rm.GetRand(); _ = r1.Int()
+	// 3) r1 := rm.GetRand(); r1.Int(); r2 := rm.GetRand();
+	scenario1RM := rms[0]
+	scenario1RM.GetRand()
+	r2 := scenario1RM.GetRand()
+	expectedEqualRands = append(expectedEqualRands, r2)
+
+	scenario2RM := rms[1]
+	r1 := scenario2RM.GetRand()
+	r2 = scenario2RM.GetRand()
+	r1.Int()
+	expectedEqualRands = append(expectedEqualRands, r2)
+
+	scenario3RM := rms[2]
+	r1 = scenario3RM.GetRand()
+	r1.Int()
+	r2 = scenario3RM.GetRand()
+	expectedEqualRands = append(expectedEqualRands, r2)
+	require.True(t, randInstancesEqual(expectedEqualRands))
+}
+
+// Test that the rand manager GetSeededRand() for the same seed are all returning the same rand instance.
+func TestRandManagerSameSeedGetSeededRand(t *testing.T) {
+	rms := getKDefaultRandManager(3)
+	seed := "test seed"
+	// We want to test that in each of the the following three scenarios, we generated the same 'trace' of values.
+	// 1) r1 := rm.GetSeededRand(seed); r1.Int(); r2 := rm.GetSeededRand(seed); r2.Int();
+	// 2) r1 := rm.GetSeededRand(seed); r2 := rm.GetSeededRand(seed); r1.Int(); r2.Int();
+	// 3) r1 := rm.GetSeededRand(seed); r2 := rm.GetSeededRand(seed); r2.Int(); r1.Int();
+	scenario1RM := rms[0]
+	r1 := scenario1RM.GetSeededRand(seed)
+	v1 := r1.Int()
+	r2 := scenario1RM.GetSeededRand(seed)
+	scenario1Trace := []int{v1, r2.Int()}
+
+	scenario2RM := rms[1]
+	r1 = scenario2RM.GetSeededRand(seed)
+	r2 = scenario2RM.GetSeededRand(seed)
+	scenario2Trace := []int{r1.Int(), r2.Int()}
+
+	scenario3RM := rms[2]
+	r1 = scenario3RM.GetSeededRand(seed)
+	r2 = scenario3RM.GetSeededRand(seed)
+	scenario3Trace := []int{r2.Int(), r1.Int()}
+
+	require.Equal(t, scenario1Trace, scenario2Trace)
+	require.Equal(t, scenario1Trace, scenario3Trace)
+}
diff --git a/tests/e2e/configurer/chain/commands.go b/tests/e2e/configurer/chain/commands.go
index 488ccd76d..5de83568a 100644
--- a/tests/e2e/configurer/chain/commands.go
+++ b/tests/e2e/configurer/chain/commands.go
@@ -10,7 +10,7 @@ import (
 )
 
 func (n *NodeConfig) CreatePool(poolFile, from string) {
-	n.t.Logf("creating pool for chain-id: %s", n.chainId)
+	n.t.Logf("creating pool from file %s from container %s", poolFile, n.Name)
 	cmd := []string{"osmosisd", "tx", "gamm", "create-pool", fmt.Sprintf("--pool-file=/osmosis/%s", poolFile), fmt.Sprintf("--from=%s", from)}
 	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
 	require.NoError(n.t, err)
@@ -18,7 +18,7 @@ func (n *NodeConfig) CreatePool(poolFile, from string) {
 }
 
 func (n *NodeConfig) SubmitUpgradeProposal(upgradeVersion string, upgradeHeight int64) {
-	n.t.Logf("submitting upgrade proposal on container: %s", n.Name)
+	n.t.Logf("submitting upgrade proposal %s for height %d, from container: %s", upgradeVersion, upgradeHeight, n.Name)
 	cmd := []string{"osmosisd", "tx", "gov", "submit-proposal", "software-upgrade", upgradeVersion, fmt.Sprintf("--title=\"%s upgrade\"", upgradeVersion), "--description=\"upgrade proposal submission\"", fmt.Sprintf("--upgrade-height=%d", upgradeHeight), "--upgrade-info=\"\"", "--from=val"}
 	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
 	require.NoError(n.t, err)
@@ -30,43 +30,43 @@ func (n *NodeConfig) SubmitSuperfluidProposal(asset string) {
 	cmd := []string{"osmosisd", "tx", "gov", "submit-proposal", "set-superfluid-assets-proposal", fmt.Sprintf("--superfluid-assets=%s", asset), fmt.Sprintf("--title=\"%s superfluid asset\"", asset), fmt.Sprintf("--description=\"%s superfluid asset\"", asset), "--from=val"}
 	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
 	require.NoError(n.t, err)
-	n.t.Log("successfully submitted superfluid proposal")
+	n.t.Logf("successfully submitted superfluid proposal for asset %s on container: %s", asset, n.Name)
 }
 
 func (n *NodeConfig) SubmitTextProposal(text string) {
-	n.t.Logf("submitting text proposal on container: %s", n.Name)
+	n.t.Logf("submitting text proposal from container: %s", n.Name)
 	cmd := []string{"osmosisd", "tx", "gov", "submit-proposal", "--type=text", fmt.Sprintf("--title=\"%s\"", text), "--description=\"test text proposal\"", "--from=val"}
 	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
 	require.NoError(n.t, err)
-	n.t.Log("successfully submitted text proposal")
+	n.t.Logf("successfully submitted from container: %s", n.Name)
 }
 
 func (n *NodeConfig) DepositProposal(proposalNumber int) {
-	n.t.Logf("depositing to proposal from container: %s", n.Name)
+	n.t.Logf("depositing to proposal from container %s, on proposal: %d", n.Name, proposalNumber)
 	cmd := []string{"osmosisd", "tx", "gov", "deposit", fmt.Sprintf("%d", proposalNumber), "500000000uosmo", "--from=val"}
 	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
 	require.NoError(n.t, err)
-	n.t.Log("successfully deposited to proposal")
+	n.t.Logf("successfully deposited from container %s, on proposal: %d", n.Name, proposalNumber)
 }
 
 func (n *NodeConfig) VoteYesProposal(from string, proposalNumber int) {
-	n.t.Logf("voting yes on proposal for chain-id: %s", n.chainId)
+	n.t.Logf("voting yes on proposal from node container: %s, on proposal: %d", n.Name, proposalNumber)
 	cmd := []string{"osmosisd", "tx", "gov", "vote", fmt.Sprintf("%d", proposalNumber), "yes", fmt.Sprintf("--from=%s", from)}
 	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
 	require.NoError(n.t, err)
-	n.t.Logf("successfully voted yes on proposal from container: %s", n.Name)
+	n.t.Logf("successfully voted yes from node container: %s, on proposal: %d", n.Name, proposalNumber)
 }
 
 func (n *NodeConfig) VoteNoProposal(from string, proposalNumber int) {
-	n.t.Logf("voting no on proposal for chain-id: %s", n.chainId)
+	n.t.Logf("voting no on proposal from node container: %s, on proposal: %d", n.Name, proposalNumber)
 	cmd := []string{"osmosisd", "tx", "gov", "vote", fmt.Sprintf("%d", proposalNumber), "no", fmt.Sprintf("--from=%s", from)}
 	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
 	require.NoError(n.t, err)
-	n.t.Logf("successfully voted no for proposal from container: %s", n.Name)
+	n.t.Logf("successfully voted no from node container: %s, on proposal: %d", n.Name, proposalNumber)
 }
 
 func (n *NodeConfig) LockTokens(tokens string, duration string, from string) {
-	n.t.Logf("locking %s for %s on chain-id: %s", tokens, duration, n.chainId)
+	n.t.Logf("locking %s for %s on from container %s", tokens, duration, n.Name)
 	cmd := []string{"osmosisd", "tx", "lockup", "lock-tokens", tokens, fmt.Sprintf("--duration=%s", duration), fmt.Sprintf("--from=%s", from)}
 	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
 	require.NoError(n.t, err)
@@ -75,27 +75,29 @@ func (n *NodeConfig) LockTokens(tokens string, duration string, from string) {
 
 func (n *NodeConfig) SuperfluidDelegate(lockNumber int, valAddress string, from string) {
 	lockStr := strconv.Itoa(lockNumber)
-	n.t.Logf("superfluid delegating lock %s to %s on chain-id: %s", lockStr, valAddress, n.chainId)
+	n.t.Logf("superfluid delegating lock %s to %s from container %s", lockStr, valAddress, n.Name)
 	cmd := []string{"osmosisd", "tx", "superfluid", "delegate", lockStr, valAddress, fmt.Sprintf("--from=%s", from)}
 	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
 	require.NoError(n.t, err)
-	n.t.Logf("successfully superfluid delegated from container: %s", n.Name)
+	n.t.Logf("successfully superfluid delegated lock %s to %s from container: %s", lockStr, valAddress, n.Name)
 }
 
 func (n *NodeConfig) BankSend(amount string, sendAddress string, receiveAddress string) {
-	n.t.Logf("bank sending %s from %s to %s on chain-id: %s", amount, sendAddress, receiveAddress, n.chainId)
+	n.t.Logf("bank sending %s from address %s to %s, from container %s", amount, sendAddress, receiveAddress, n.Name)
 	cmd := []string{"osmosisd", "tx", "bank", "send", sendAddress, receiveAddress, amount, "--from=val"}
 	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
 	require.NoError(n.t, err)
-	n.t.Logf("successfully sent tx from container: %s", n.Name)
+	n.t.Logf("successfully sent bank sent %s from address %s to %s, from container %s", amount, sendAddress, receiveAddress, n.Name)
 }
 
 func (n *NodeConfig) CreateWallet(walletName string) string {
+	n.t.Logf("creating wallet %s, from container %s", walletName, n.Name)
 	cmd := []string{"osmosisd", "keys", "add", walletName, "--keyring-backend=test"}
 	outBuf, _, err := n.containerManager.ExecCmd(n.t, n.Name, cmd, "")
 	require.NoError(n.t, err)
 	re := regexp.MustCompile("osmo1(.{38})")
 	walletAddr := fmt.Sprintf("%s\n", re.FindString(outBuf.String()))
 	walletAddr = strings.TrimSuffix(walletAddr, "\n")
+	n.t.Logf("created wallet %s, waller address - %s from container %s", walletName, walletAddr, n.Name)
 	return walletAddr
 }
diff --git a/tests/e2e/configurer/chain/queries.go b/tests/e2e/configurer/chain/queries.go
index 3e44415e6..672ecebdb 100644
--- a/tests/e2e/configurer/chain/queries.go
+++ b/tests/e2e/configurer/chain/queries.go
@@ -26,24 +26,15 @@ func (n *NodeConfig) QueryGRPCGateway(path string) ([]byte, error) {
 	fullQueryPath := fmt.Sprintf("%s/%s", endpoint, path)
 
 	var resp *http.Response
-	retriesLeft := 5
-	for {
+	require.Eventually(n.t, func() bool {
 		resp, err = http.Get(fullQueryPath)
-
-		if resp.StatusCode == http.StatusServiceUnavailable {
-			retriesLeft--
-			if retriesLeft == 0 {
-				return nil, err
-			}
-			time.Sleep(10 * time.Second)
-		} else {
-			break
+		if err != nil {
+			n.t.Logf("error while executing HTTP request: %s", err.Error())
+			return false
 		}
-	}
 
-	if err != nil {
-		return nil, fmt.Errorf("failed to execute HTTP request: %w", err)
-	}
+		return resp.StatusCode != http.StatusServiceUnavailable
+	}, time.Minute, time.Second*10, "failed to execute HTTP request")
 
 	defer resp.Body.Close()
 
diff --git a/tests/e2e/configurer/upgrade.go b/tests/e2e/configurer/upgrade.go
index b4c9f73b2..3131a52d5 100644
--- a/tests/e2e/configurer/upgrade.go
+++ b/tests/e2e/configurer/upgrade.go
@@ -71,7 +71,6 @@ func (uc *UpgradeConfigurer) ConfigureChain(chainConfig *chain.Config) error {
 	}
 
 	chainInitResource, err := uc.containerManager.RunChainInitResource(chainConfig.Id, int(chainConfig.VotingPeriod), validatorConfigBytes, tmpDir, int(forkHeight))
-
 	if err != nil {
 		return err
 	}
@@ -143,21 +142,19 @@ func (uc *UpgradeConfigurer) runProposalUpgrade() error {
 	// submit, deposit, and vote for upgrade proposal
 	// prop height = current height + voting period + time it takes to submit proposal + small buffer
 	for _, chainConfig := range uc.chainConfigs {
-		node, err := chainConfig.GetDefaultNode()
-		if err != nil {
-			return err
-		}
-		currentHeight, err := node.QueryCurrentHeight()
-		if err != nil {
-			return err
+		for validatorIdx, node := range chainConfig.NodeConfigs {
+			if validatorIdx == 0 {
+				currentHeight, err := node.QueryCurrentHeight()
+				if err != nil {
+					return err
+				}
+				chainConfig.UpgradePropHeight = currentHeight + int64(chainConfig.VotingPeriod) + int64(config.PropSubmitBlocks) + int64(config.PropBufferBlocks)
+				node.SubmitUpgradeProposal(uc.upgradeVersion, chainConfig.UpgradePropHeight)
+				chainConfig.LatestProposalNumber += 1
+				node.DepositProposal(chainConfig.LatestProposalNumber)
+			}
+			node.VoteYesProposal(initialization.ValidatorWalletName, chainConfig.LatestProposalNumber)
 		}
-
-		chainConfig.UpgradePropHeight = currentHeight + int64(chainConfig.VotingPeriod) + int64(config.PropSubmitBlocks) + int64(config.PropBufferBlocks)
-		node.SubmitUpgradeProposal(uc.upgradeVersion, chainConfig.UpgradePropHeight)
-		chainConfig.LatestProposalNumber += 1
-
-		node.DepositProposal(chainConfig.LatestProposalNumber)
-		node.VoteYesProposal(initialization.ValidatorWalletName, chainConfig.LatestProposalNumber)
 	}
 
 	// wait till all chains halt at upgrade height
diff --git a/tests/simulator/sim_test.go b/tests/simulator/sim_test.go
index 195e3455b..af74440d8 100644
--- a/tests/simulator/sim_test.go
+++ b/tests/simulator/sim_test.go
@@ -95,7 +95,7 @@ func fullAppSimulation(tb testing.TB, is_testing bool) {
 	}
 
 	// Run randomized simulation:
-	_, simParams, simErr := osmosim.SimulateFromSeed(
+	_, simErr := osmosim.SimulateFromSeed(
 		tb,
 		os.Stdout,
 		osmosis,
@@ -104,11 +104,6 @@ func fullAppSimulation(tb testing.TB, is_testing bool) {
 		config,
 		osmosis.AppCodec(),
 	)
-	simParams = simParams
-	// export state and simParams before the simulation error is checked
-	// if err = sdkSimapp.CheckExportSimulation(osmosis, config, simParams); err != nil {
-	// 	tb.Fatal(err)
-	// }
 
 	if simErr != nil {
 		tb.Fatal(simErr)
@@ -186,7 +181,7 @@ func TestAppStateDeterminism(t *testing.T) {
 			}
 
 			// Run randomized simulation:
-			_, _, simErr := osmosim.SimulateFromSeed(
+			_, simErr := osmosim.SimulateFromSeed(
 				t,
 				os.Stdout,
 				osmosis,
diff --git a/x/gamm/keeper/internal/events/emit_test.go b/x/gamm/keeper/internal/events/emit_test.go
index dcaa845b4..15d60dc5d 100644
--- a/x/gamm/keeper/internal/events/emit_test.go
+++ b/x/gamm/keeper/internal/events/emit_test.go
@@ -29,7 +29,6 @@ func TestGammEventsTestSuite(t *testing.T) {
 }
 
 func (suite *GammEventsTestSuite) TestEmitSwapEvent() {
-
 	testcases := map[string]struct {
 		ctx             sdk.Context
 		testAccountAddr sdk.AccAddress
diff --git a/x/gamm/keeper/pool_service_test.go b/x/gamm/keeper/pool_service_test.go
index 343aded9f..2e8492ee9 100644
--- a/x/gamm/keeper/pool_service_test.go
+++ b/x/gamm/keeper/pool_service_test.go
@@ -579,10 +579,10 @@ func (suite *KeeperTestSuite) TestJoinPoolExitPool_InverseRelationship() {
 			poolId, err := suite.App.GAMMKeeper.CreatePool(suite.Ctx, tc.pool)
 			suite.Require().NoError(err)
 
-		  balanceBeforeJoin := suite.App.BankKeeper.GetAllBalances(suite.Ctx, joinPoolAcc)
+			balanceBeforeJoin := suite.App.BankKeeper.GetAllBalances(suite.Ctx, joinPoolAcc)
 
-		  _, _, err = suite.App.GAMMKeeper.JoinPoolNoSwap(suite.Ctx, joinPoolAcc, poolId, tc.joinPoolShareAmt, sdk.Coins{})
-		  suite.Require().NoError(err)
+			_, _, err = suite.App.GAMMKeeper.JoinPoolNoSwap(suite.Ctx, joinPoolAcc, poolId, tc.joinPoolShareAmt, sdk.Coins{})
+			suite.Require().NoError(err)
 
 			_, err = suite.App.GAMMKeeper.ExitPool(suite.Ctx, joinPoolAcc, poolId, tc.joinPoolShareAmt, sdk.Coins{})
 
diff --git a/x/incentives/client/cli/cli_test.go b/x/incentives/client/cli/cli_test.go
index fce100e12..719307651 100644
--- a/x/incentives/client/cli/cli_test.go
+++ b/x/incentives/client/cli/cli_test.go
@@ -78,7 +78,6 @@ func (s *IntegrationTestSuite) SetupSuite() {
 
 	_, err = s.network.WaitForHeight(1)
 	s.Require().NoError(err)
-
 }
 
 func (s *IntegrationTestSuite) TearDownSuite() {
diff --git a/x/incentives/keeper/distribute_test.go b/x/incentives/keeper/distribute_test.go
index 9699cf05a..59077e2fb 100644
--- a/x/incentives/keeper/distribute_test.go
+++ b/x/incentives/keeper/distribute_test.go
@@ -174,7 +174,6 @@ func (suite *KeeperTestSuite) TestSyntheticDistribute() {
 			suite.Require().Equal(tc.expectedRewards[i].String(), rewards, "test %v, person %d", tc.name, i)
 		}
 	}
-
 }
 
 // TestGetModuleToDistributeCoins tests the sum of coins yet to be distributed for all of the module is correct.
diff --git a/x/incentives/keeper/gauge_test.go b/x/incentives/keeper/gauge_test.go
index 653202ad1..e46fb22cb 100644
--- a/x/incentives/keeper/gauge_test.go
+++ b/x/incentives/keeper/gauge_test.go
@@ -236,5 +236,4 @@ func (suite *KeeperTestSuite) TestGaugeOperations() {
 			suite.Require().Len(gaugeIdsByDenom, 1)
 		}
 	}
-
 }
diff --git a/x/mint/keeper/keeper_test.go b/x/mint/keeper/keeper_test.go
index 3483eb790..73baaa8c3 100644
--- a/x/mint/keeper/keeper_test.go
+++ b/x/mint/keeper/keeper_test.go
@@ -168,7 +168,8 @@ func (suite *KeeperTestSuite) TestDistributeMintedCoin_ToDeveloperRewardsAddr()
 				{
 					Address: testAddressOne.String(),
 					Weight:  sdk.NewDec(1),
-				}},
+				},
+			},
 			mintCoin: sdk.NewCoin("stake", sdk.NewInt(10000)),
 		},
 		{
@@ -181,7 +182,8 @@ func (suite *KeeperTestSuite) TestDistributeMintedCoin_ToDeveloperRewardsAddr()
 				{
 					Address: testAddressFour.String(),
 					Weight:  sdk.NewDecWithPrec(4, 1),
-				}},
+				},
+			},
 			mintCoin: sdk.NewCoin("stake", sdk.NewInt(100000)),
 		},
 		{
@@ -236,7 +238,7 @@ func (suite *KeeperTestSuite) TestDistributeMintedCoin_ToDeveloperRewardsAddr()
 					feePool.CommunityPool.AmountOf("stake"))
 			} else {
 				suite.Equal(
-					//distribution go to community pool because nil dev reward addresses.
+					// distribution go to community pool because nil dev reward addresses.
 					tc.mintCoin.Amount.ToDec().Mul((params.DistributionProportions.DeveloperRewards).Add(params.DistributionProportions.CommunityPool)),
 					feePool.CommunityPool.AmountOf("stake"))
 			}
diff --git a/x/superfluid/keeper/distribution_test.go b/x/superfluid/keeper/distribution_test.go
index dad228dc5..1e77f51c8 100644
--- a/x/superfluid/keeper/distribution_test.go
+++ b/x/superfluid/keeper/distribution_test.go
@@ -63,16 +63,13 @@ func (suite *KeeperTestSuite) TestMoveSuperfluidDelegationRewardToGauges() {
 		suite.Run(tc.name, func() {
 			suite.SetupTest()
 
-			// Generate delegator addresses
-			delAddrs := CreateRandomAccounts(tc.delegatorNumber)
-
 			// setup validators
 			valAddrs := suite.SetupValidators(tc.validatorStats)
 
 			denoms, _ := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20), sdk.NewDec(20)})
 
 			// setup superfluid delegations
-			intermediaryAccs, _ := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, tc.superDelegations, denoms)
+			_, intermediaryAccs, _ := suite.setupSuperfluidDelegations(valAddrs, tc.superDelegations, denoms)
 			unbondingDuration := suite.App.StakingKeeper.GetParams(suite.Ctx).UnbondingTime
 
 			// allocate rewards to first validator
diff --git a/x/superfluid/keeper/edge_case_test.go b/x/superfluid/keeper/edge_case_test.go
index c4ba9287a..a03a17883 100644
--- a/x/superfluid/keeper/edge_case_test.go
+++ b/x/superfluid/keeper/edge_case_test.go
@@ -6,6 +6,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	evidencetypes "github.com/cosmos/cosmos-sdk/x/evidence/types"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+
 	lockuptypes "github.com/osmosis-labs/osmosis/v7/x/lockup/types"
 )
 
@@ -49,7 +50,7 @@ func (suite *KeeperTestSuite) TestSuperfluidDelegatedValidatorJailed() {
 			for _, del := range tc.superDelegations {
 				valAddr := valAddrs[del.valIndex]
 				delAddr := delAddrs[del.delIndex]
-				lock := suite.SetupSuperfluidDelegate(delAddr, valAddr, denoms[del.lpIndex], del.lpAmount)
+				lock := suite.setupSuperfluidDelegate(delAddr, valAddr, denoms[del.lpIndex], del.lpAmount)
 
 				// save accounts and locks for future use
 				locks = append(locks, lock)
@@ -125,8 +126,6 @@ func (suite *KeeperTestSuite) TestTryUnbondingSuperfluidLockupDirectly() {
 		tc := tc
 		suite.Run(tc.name, func() {
 			suite.SetupTest()
-			// Generate delegator addresses
-			delAddrs := CreateRandomAccounts(tc.delegatorNumber)
 
 			// setup validators
 			valAddrs := suite.SetupValidators(tc.validatorStats)
@@ -134,8 +133,7 @@ func (suite *KeeperTestSuite) TestTryUnbondingSuperfluidLockupDirectly() {
 			denoms, _ := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20), sdk.NewDec(20)})
 
 			// setup superfluid delegations
-			_, _, _ = delAddrs, valAddrs, denoms
-			_, locks := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, tc.superDelegations, denoms)
+			_, _, locks := suite.setupSuperfluidDelegations(valAddrs, tc.superDelegations, denoms)
 
 			for _, lock := range locks {
 				err := suite.App.LockupKeeper.BeginUnlock(suite.Ctx, lock.ID, sdk.Coins{})
diff --git a/x/superfluid/keeper/grpc_query_test.go b/x/superfluid/keeper/grpc_query_test.go
index 8b027179e..cd9f6aabe 100644
--- a/x/superfluid/keeper/grpc_query_test.go
+++ b/x/superfluid/keeper/grpc_query_test.go
@@ -43,9 +43,6 @@ func (suite *KeeperTestSuite) TestGRPCSuperfluidAsset() {
 func (suite *KeeperTestSuite) TestGRPCQuerySuperfluidDelegations() {
 	suite.SetupTest()
 
-	// Generate delegator addresses
-	delAddrs := CreateRandomAccounts(2)
-
 	// setup 2 validators
 	valAddrs := suite.SetupValidators([]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded})
 
@@ -60,13 +57,13 @@ func (suite *KeeperTestSuite) TestGRPCQuerySuperfluidDelegations() {
 	}
 
 	// setup superfluid delegations
-	_, locks := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, superfluidDelegations, denoms)
+	delegatorAddresses, _, locks := suite.setupSuperfluidDelegations(valAddrs, superfluidDelegations, denoms)
 
 	// for each superfluid delegation, query the amount and make sure it is 1000000
 	for _, delegation := range superfluidDelegations {
 		lpDenom := denoms[delegation.lpIndex]
 		res, err := suite.queryClient.SuperfluidDelegationAmount(sdk.WrapSDKContext(suite.Ctx), &types.SuperfluidDelegationAmountRequest{
-			DelegatorAddress: delAddrs[delegation.delIndex].String(),
+			DelegatorAddress: delegatorAddresses[delegation.delIndex].String(),
 			ValidatorAddress: valAddrs[delegation.valIndex].String(),
 			Denom:            lpDenom,
 		})
@@ -75,7 +72,7 @@ func (suite *KeeperTestSuite) TestGRPCQuerySuperfluidDelegations() {
 	}
 
 	// for each delegator, query all their superfluid delegations and make sure they have 2 delegations
-	for _, delegator := range delAddrs {
+	for _, delegator := range delegatorAddresses {
 		res, err := suite.queryClient.SuperfluidDelegationsByDelegator(sdk.WrapSDKContext(suite.Ctx), &types.SuperfluidDelegationsByDelegatorRequest{
 			DelegatorAddress: delegator.String(),
 		})
@@ -139,12 +136,8 @@ func (suite *KeeperTestSuite) TestGRPCQuerySuperfluidDelegations() {
 func (suite *KeeperTestSuite) TestGRPCQuerySuperfluidDelegationsDontIncludeUnbonding() {
 	suite.SetupTest()
 
-	// Generate delegator addresses
-	delAddrs := CreateRandomAccounts(2)
-
 	// setup 2 validators
 	valAddrs := suite.SetupValidators([]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded})
-
 	denoms, _ := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20), sdk.NewDec(20)})
 
 	// create a delegation of 1000000 for every combination of 2 delegations, 2 validators, and 2 superfluid denoms
@@ -156,7 +149,7 @@ func (suite *KeeperTestSuite) TestGRPCQuerySuperfluidDelegationsDontIncludeUnbon
 	}
 
 	// setup superfluid delegations
-	_, locks := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, superfluidDelegations, denoms)
+	delegatorAddresses, _, locks := suite.setupSuperfluidDelegations(valAddrs, superfluidDelegations, denoms)
 
 	// start unbonding the superfluid delegations of denom0 from delegator0 to validator0
 	err := suite.querier.SuperfluidUndelegate(suite.Ctx, locks[0].Owner, locks[0].ID)
@@ -164,7 +157,7 @@ func (suite *KeeperTestSuite) TestGRPCQuerySuperfluidDelegationsDontIncludeUnbon
 
 	// query to make sure that the amount delegated for the now unbonding delegation is 0
 	res, err := suite.queryClient.SuperfluidDelegationAmount(sdk.WrapSDKContext(suite.Ctx), &types.SuperfluidDelegationAmountRequest{
-		DelegatorAddress: delAddrs[0].String(),
+		DelegatorAddress: delegatorAddresses[0].String(),
 		ValidatorAddress: valAddrs[0].String(),
 		Denom:            denoms[0],
 	})
@@ -173,7 +166,7 @@ func (suite *KeeperTestSuite) TestGRPCQuerySuperfluidDelegationsDontIncludeUnbon
 
 	// query to make sure that the unbonding delegation is not included in delegator query
 	res2, err := suite.queryClient.SuperfluidDelegationsByDelegator(sdk.WrapSDKContext(suite.Ctx), &types.SuperfluidDelegationsByDelegatorRequest{
-		DelegatorAddress: delAddrs[0].String(),
+		DelegatorAddress: delegatorAddresses[0].String(),
 	})
 	suite.Require().NoError(err)
 	suite.Require().Len(res2.SuperfluidDelegationRecords, 1)
@@ -206,9 +199,6 @@ func (suite *KeeperTestSuite) TestGRPCQuerySuperfluidDelegationsDontIncludeUnbon
 func (suite *KeeperTestSuite) TestGRPCQueryTotalDelegationByDelegator() {
 	suite.SetupTest()
 
-	// Generate delegator addresses
-	delAddrs := CreateRandomAccounts(2)
-
 	// setup 2 validators
 	valAddrs := suite.SetupValidators([]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded})
 
@@ -223,13 +213,13 @@ func (suite *KeeperTestSuite) TestGRPCQueryTotalDelegationByDelegator() {
 	}
 
 	// setup superfluid delegations
-	suite.SetupSuperfluidDelegations(delAddrs, valAddrs, superfluidDelegations, denoms)
+	delegatorAddresses, _, _ := suite.setupSuperfluidDelegations(valAddrs, superfluidDelegations, denoms)
 
 	// setup normal delegations
-	bond0to0 := stakingtypes.NewDelegation(delAddrs[0], valAddrs[0], sdk.NewDec(9000000))
-	bond0to1 := stakingtypes.NewDelegation(delAddrs[0], valAddrs[1], sdk.NewDec(9000000))
-	bond1to0 := stakingtypes.NewDelegation(delAddrs[1], valAddrs[0], sdk.NewDec(9000000))
-	bond1to1 := stakingtypes.NewDelegation(delAddrs[1], valAddrs[1], sdk.NewDec(9000000))
+	bond0to0 := stakingtypes.NewDelegation(delegatorAddresses[0], valAddrs[0], sdk.NewDec(9000000))
+	bond0to1 := stakingtypes.NewDelegation(delegatorAddresses[0], valAddrs[1], sdk.NewDec(9000000))
+	bond1to0 := stakingtypes.NewDelegation(delegatorAddresses[1], valAddrs[0], sdk.NewDec(9000000))
+	bond1to1 := stakingtypes.NewDelegation(delegatorAddresses[1], valAddrs[1], sdk.NewDec(9000000))
 
 	suite.App.StakingKeeper.SetDelegation(suite.Ctx, bond0to0)
 	suite.App.StakingKeeper.SetDelegation(suite.Ctx, bond0to1)
@@ -245,7 +235,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryTotalDelegationByDelegator() {
 
 	// for each delegator, query all their superfluid delegations and normal delegations. Making sure they have 4 delegations
 	// Making sure TotalEquivalentStakedAmount is equal to converted amount + normal delegations
-	for _, delegator := range delAddrs {
+	for _, delegator := range delegatorAddresses {
 		res, err := suite.queryClient.TotalDelegationByDelegator(sdk.WrapSDKContext(suite.Ctx), &types.QueryTotalDelegationByDelegatorRequest{
 			DelegatorAddress: delegator.String(),
 		})
diff --git a/x/superfluid/keeper/hooks_test.go b/x/superfluid/keeper/hooks_test.go
index ecfc0ff37..901746735 100644
--- a/x/superfluid/keeper/hooks_test.go
+++ b/x/superfluid/keeper/hooks_test.go
@@ -49,8 +49,7 @@ func (suite *KeeperTestSuite) TestSuperfluidAfterEpochEnd() {
 			denoms, poolIds := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20)})
 
 			// Generate delegator addresses
-			delAddrs := CreateRandomAccounts(tc.delegatorNumber)
-			intermediaryAccs, locks := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, tc.superDelegations, denoms)
+			delAddrs, intermediaryAccs, locks := suite.setupSuperfluidDelegations(valAddrs, tc.superDelegations, denoms)
 			suite.checkIntermediaryAccountDelegations(intermediaryAccs)
 
 			// run swap and set spot price
@@ -257,16 +256,13 @@ func (suite *KeeperTestSuite) TestBeforeSlashingUnbondingDelegationHook() {
 
 			slashFactor := sdk.NewDecWithPrec(5, 2)
 
-			// Generate delegator addresses
-			delAddrs := CreateRandomAccounts(tc.delegatorNumber)
-
 			// setup validators
 			valAddrs := suite.SetupValidators(tc.validatorStats)
 
 			denoms, _ := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20), sdk.NewDec(20)})
 
 			// setup superfluid delegations
-			intermediaryAccs, _ := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, tc.superDelegations, denoms)
+			_, intermediaryAccs, _ := suite.setupSuperfluidDelegations(valAddrs, tc.superDelegations, denoms)
 			suite.checkIntermediaryAccountDelegations(intermediaryAccs)
 
 			for _, lockId := range tc.superUnbondingLockIds {
diff --git a/x/superfluid/keeper/intermediary_account_test.go b/x/superfluid/keeper/intermediary_account_test.go
index ee86ab52e..29cbe67a3 100644
--- a/x/superfluid/keeper/intermediary_account_test.go
+++ b/x/superfluid/keeper/intermediary_account_test.go
@@ -52,7 +52,7 @@ func (suite *KeeperTestSuite) TestIntermediaryAccountCreation() {
 				suite.Require().Equal(uint64(0), interAcc.GaugeId)
 				suite.Require().Equal("", interAcc.ValAddr)
 
-				lock := suite.SetupSuperfluidDelegate(delAddr, valAddr, denom, superDelegation.lpAmount)
+				lock := suite.setupSuperfluidDelegate(delAddr, valAddr, denom, superDelegation.lpAmount)
 
 				// check that intermediary Account connection is established
 				interAccConnection := suite.App.SuperfluidKeeper.GetLockIdIntermediaryAccountConnection(suite.Ctx, lock.ID)
diff --git a/x/superfluid/keeper/keeper_test.go b/x/superfluid/keeper/keeper_test.go
index a6bd2272c..fa5a73d1f 100644
--- a/x/superfluid/keeper/keeper_test.go
+++ b/x/superfluid/keeper/keeper_test.go
@@ -14,6 +14,7 @@ import (
 	epochtypes "github.com/osmosis-labs/osmosis/v7/x/epochs/types"
 	"github.com/osmosis-labs/osmosis/v7/x/gamm/pool-models/balancer"
 	gammtypes "github.com/osmosis-labs/osmosis/v7/x/gamm/types"
+	lockuptypes "github.com/osmosis-labs/osmosis/v7/x/lockup/types"
 	minttypes "github.com/osmosis-labs/osmosis/v7/x/mint/types"
 	"github.com/osmosis-labs/osmosis/v7/x/superfluid/keeper"
 	"github.com/osmosis-labs/osmosis/v7/x/superfluid/types"
@@ -152,6 +153,98 @@ func (suite *KeeperTestSuite) SetupGammPoolsAndSuperfluidAssets(multipliers []sd
 	return denoms, poolIds
 }
 
+func (suite *KeeperTestSuite) setupSuperfluidDelegations(valAddrs []sdk.ValAddress, superDelegations []superfluidDelegation, denoms []string) ([]sdk.AccAddress, []types.SuperfluidIntermediaryAccount, []lockuptypes.PeriodLock) {
+	flagIntermediaryAcc := make(map[string]bool)
+	intermediaryAccs := []types.SuperfluidIntermediaryAccount{}
+	locks := []lockuptypes.PeriodLock{}
+	delAddrs := []sdk.AccAddress{}
+
+	// we do sanity check on the test cases.
+	// if superfluid staking is happening with single val and multiple superfluid delegations,
+	// we should be running `AddTokensToLockByID`, instead of creating new locks
+	delegatorAddressMap := make(map[int64]sdk.AccAddress)
+	for _, superDelegation := range superDelegations {
+		// either create or use existing delegator address
+		var delAddr sdk.AccAddress
+		if cachedAddr, ok := delegatorAddressMap[superDelegation.delIndex]; ok {
+			delAddr = cachedAddr
+		} else {
+			pk := ed25519.GenPrivKey().PubKey()
+			delAddr = sdk.AccAddress(pk.Address())
+			delegatorAddressMap[superDelegation.delIndex] = delAddr
+			delAddrs = append(delAddrs, delAddr)
+		}
+
+		valAddr := valAddrs[superDelegation.valIndex]
+		lock := suite.setupSuperfluidDelegate(delAddr, valAddr, denoms[superDelegation.lpIndex], superDelegation.lpAmount)
+		address := suite.App.SuperfluidKeeper.GetLockIdIntermediaryAccountConnection(suite.Ctx, lock.ID)
+		gotAcc := suite.App.SuperfluidKeeper.GetIntermediaryAccount(suite.Ctx, address)
+
+		// save accounts for future use
+		if flagIntermediaryAcc[gotAcc.String()] == false {
+			flagIntermediaryAcc[gotAcc.String()] = true
+			intermediaryAccs = append(intermediaryAccs, gotAcc)
+		}
+		// save locks for future use
+		locks = append(locks, lock)
+	}
+	return delAddrs, intermediaryAccs, locks
+}
+
+func (suite *KeeperTestSuite) checkIntermediaryAccountDelegations(intermediaryAccs []types.SuperfluidIntermediaryAccount) {
+	for _, acc := range intermediaryAccs {
+		valAddr, err := sdk.ValAddressFromBech32(acc.ValAddr)
+		suite.Require().NoError(err)
+
+		// check delegation from intermediary account to validator
+		delegation, found := suite.App.StakingKeeper.GetDelegation(suite.Ctx, acc.GetAccAddress(), valAddr)
+		suite.Require().True(found)
+		suite.Require().True(delegation.Shares.GTE(sdk.NewDec(10000000)))
+
+		// check delegated tokens
+		validator, found := suite.App.StakingKeeper.GetValidator(suite.Ctx, valAddr)
+		suite.Require().True(found)
+		delegatedTokens := validator.TokensFromShares(delegation.Shares).TruncateInt()
+		suite.Require().True(delegatedTokens.GTE(sdk.NewInt(10000000)))
+	}
+}
+
+func (suite *KeeperTestSuite) setupSuperfluidDelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, denom string, amount int64) lockuptypes.PeriodLock {
+	unbondingDuration := suite.App.StakingKeeper.GetParams(suite.Ctx).UnbondingTime
+
+	// create lockup of LP token
+	coins := sdk.Coins{sdk.NewInt64Coin(denom, amount)}
+	lastLockID := suite.App.LockupKeeper.GetLastLockID(suite.Ctx)
+
+	lockID := suite.LockTokens(delAddr, coins, unbondingDuration)
+	lock, err := suite.App.LockupKeeper.GetLockByID(suite.Ctx, lockID)
+	suite.Require().NoError(err)
+
+	// here we check if check `LockTokens` added to existing locks or created a new lock.
+	// if `LockTokens` created a new lock, we continue SuperfluidDelegate
+	// if lock has been existing before, we wouldn't have to call SuperfluidDelegate separately, as hooks on LockTokens would have automatically called IncreaseSuperfluidDelegation
+	if lastLockID != lockID {
+		err = suite.App.SuperfluidKeeper.SuperfluidDelegate(suite.Ctx, lock.Owner, lock.ID, valAddr.String())
+		suite.Require().NoError(err)
+	} else {
+		// here we handle two cases.
+		// 1. the lock has existed before but has not been superflud staking
+		// 2. the lock has existed before and has been superfluid staking
+
+		// we check if synth lock that has existed before, if it did, it means that the lock has been superfluid staked
+		// we do not care about unbonding synthlocks, as superfluid delegation has no effect
+
+		_, err := suite.App.LockupKeeper.GetSyntheticLockup(suite.Ctx, lockID, keeper.StakingSyntheticDenom(lock.Coins[0].Denom, valAddr.String()))
+		// if lock has existed before but has not been superfluid staked, we do initial superfluid staking
+		if err != nil {
+			err = suite.App.SuperfluidKeeper.SuperfluidDelegate(suite.Ctx, lock.Owner, lock.ID, valAddr.String())
+			suite.Require().NoError(err)
+		}
+	}
+
+	return *lock
+}
+
 func TestKeeperTestSuite(t *testing.T) {
 	suite.Run(t, new(KeeperTestSuite))
 }
diff --git a/x/superfluid/keeper/slash_test.go b/x/superfluid/keeper/slash_test.go
index 8f09c51bc..bbe302047 100644
--- a/x/superfluid/keeper/slash_test.go
+++ b/x/superfluid/keeper/slash_test.go
@@ -72,7 +72,7 @@ func (suite *KeeperTestSuite) TestBeforeValidatorSlashed() {
 			for _, del := range tc.superDelegations {
 				valAddr := valAddrs[del.valIndex]
 				delAddr := delAddrs[del.delIndex]
-				lock := suite.SetupSuperfluidDelegate(delAddr, valAddr, denoms[del.lpIndex], del.lpAmount)
+				lock := suite.setupSuperfluidDelegate(delAddr, valAddr, denoms[del.lpIndex], del.lpAmount)
 
 				// save accounts and locks for future use
 				locks = append(locks, lock)
@@ -145,16 +145,13 @@ func (suite *KeeperTestSuite) TestSlashLockupsForUnbondingDelegationSlash() {
 		suite.Run(tc.name, func() {
 			suite.SetupTest()
 
-			// Generate delegator addresses
-			delAddrs := CreateRandomAccounts(tc.delegatorNumber)
-
 			// setup validators
 			valAddrs := suite.SetupValidators(tc.validatorStats)
 
 			denoms, _ := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20), sdk.NewDec(20)})
 
 			// setup superfluid delegations
-			intermediaryAccs, _ := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, tc.superDelegations, denoms)
+			_, intermediaryAccs, _ := suite.setupSuperfluidDelegations(valAddrs, tc.superDelegations, denoms)
 			suite.checkIntermediaryAccountDelegations(intermediaryAccs)
 
 			for _, lockId := range tc.superUnbondingLockIds {
diff --git a/x/superfluid/keeper/stake_test.go b/x/superfluid/keeper/stake_test.go
index 9a4b487ce..f72ce7162 100644
--- a/x/superfluid/keeper/stake_test.go
+++ b/x/superfluid/keeper/stake_test.go
@@ -1,13 +1,11 @@
 package keeper_test
 
 import (
-	"fmt"
 	"time"
 
 	abci "github.com/tendermint/tendermint/abci/types"
 
 	lockuptypes "github.com/osmosis-labs/osmosis/v7/x/lockup/types"
-	minttypes "github.com/osmosis-labs/osmosis/v7/x/mint/types"
 	"github.com/osmosis-labs/osmosis/v7/x/superfluid/keeper"
 	"github.com/osmosis-labs/osmosis/v7/x/superfluid/types"
 
@@ -15,146 +13,35 @@ import (
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
-type normalDelegation struct {
-	delIndex   int64
-	valIndex   int64
-	coinAmount int64
-}
-
 type superfluidDelegation struct {
 	delIndex int64
 	valIndex int64
 	lpIndex  int64
 	lpAmount int64
 }
-type superfluidRedelegation struct {
-	lockId      uint64
-	oldValIndex int64
-	newValIndex int64
-}
-
-type osmoEquivalentMultiplier struct {
-	lpIndex int64
-	price   sdk.Dec
-}
-
-func (suite *KeeperTestSuite) SetupNormalDelegation(delAddrs []sdk.AccAddress, valAddrs []sdk.ValAddress, del normalDelegation) error {
-	val, found := suite.App.StakingKeeper.GetValidator(suite.Ctx, valAddrs[del.valIndex])
-	if !found {
-		return fmt.Errorf("validator not found")
-	}
-	_, err := suite.App.StakingKeeper.Delegate(suite.Ctx, delAddrs[del.delIndex], sdk.NewIntFromUint64(uint64(del.coinAmount)), stakingtypes.Bonded, val, false)
-	return err
-}
-
-func (suite *KeeperTestSuite) SetupSuperfluidDelegations(delAddrs []sdk.AccAddress, valAddrs []sdk.ValAddress, superDelegations []superfluidDelegation, denoms []string) ([]types.SuperfluidIntermediaryAccount, []lockuptypes.PeriodLock) {
-	flagIntermediaryAcc := make(map[string]bool)
-	intermediaryAccs := []types.SuperfluidIntermediaryAccount{}
-	locks := []lockuptypes.PeriodLock{}
-
-	// setup superfluid delegations
-
-	// we do sanity check on the test cases.
-	// if superfluid staking is happening with single val and multiple superfluid delegations,
-	// we should be running `AddTokensToLockByID`, instead of creating new locks
-	for _, del := range superDelegations {
-		delAddr := delAddrs[del.delIndex]
-		valAddr := valAddrs[del.valIndex]
-		lock := suite.SetupSuperfluidDelegate(delAddr, valAddr, denoms[del.lpIndex], del.lpAmount)
-		address := suite.App.SuperfluidKeeper.GetLockIdIntermediaryAccountConnection(suite.Ctx, lock.ID)
-		gotAcc := suite.App.SuperfluidKeeper.GetIntermediaryAccount(suite.Ctx, address)
-
-		// save accounts for future use
-		if flagIntermediaryAcc[gotAcc.String()] == false {
-			flagIntermediaryAcc[gotAcc.String()] = true
-			intermediaryAccs = append(intermediaryAccs, gotAcc)
-		}
-		// save locks for future use
-		locks = append(locks, lock)
-	}
-	return intermediaryAccs, locks
-}
-
-func (suite *KeeperTestSuite) checkIntermediaryAccountDelegations(intermediaryAccs []types.SuperfluidIntermediaryAccount) {
-	for _, acc := range intermediaryAccs {
-		valAddr, err := sdk.ValAddressFromBech32(acc.ValAddr)
-		suite.Require().NoError(err)
-
-		// check delegation from intermediary account to validator
-		delegation, found := suite.App.StakingKeeper.GetDelegation(suite.Ctx, acc.GetAccAddress(), valAddr)
-		suite.Require().True(found)
-		suite.Require().True(delegation.Shares.GTE(sdk.NewDec(10000000)))
-
-		// check delegated tokens
-		validator, found := suite.App.StakingKeeper.GetValidator(suite.Ctx, valAddr)
-		suite.Require().True(found)
-		delegatedTokens := validator.TokensFromShares(delegation.Shares).TruncateInt()
-		suite.Require().True(delegatedTokens.GTE(sdk.NewInt(10000000)))
-	}
-}
-
-func (suite *KeeperTestSuite) SetupSuperfluidDelegate(delAddr sdk.AccAddress, valAddr sdk.ValAddress, denom string, amount int64) lockuptypes.PeriodLock {
-	unbondingDuration := suite.App.StakingKeeper.GetParams(suite.Ctx).UnbondingTime
-
-	// create lockup of LP token
-	coins := sdk.Coins{sdk.NewInt64Coin(denom, amount)}
-	lastLockID := suite.App.LockupKeeper.GetLastLockID(suite.Ctx)
-
-	lockID := suite.LockTokens(delAddr, coins, unbondingDuration)
-	lock, err := suite.App.LockupKeeper.GetLockByID(suite.Ctx, lockID)
-	suite.Require().NoError(err)
-
-	// here we check if check `LockTokens` added to existing locks or created a new lock.
-	// if `LockTokens` created a new lock, we continue SuperfluidDelegate
-	// if lock has been existing before, we wouldn't have to call SuperfluidDelegate separately, as hooks on LockTokens would have automatically called IncreaseSuperfluidDelegation
-	if lastLockID != lockID {
-		err = suite.App.SuperfluidKeeper.SuperfluidDelegate(suite.Ctx, lock.Owner, lock.ID, valAddr.String())
-		suite.Require().NoError(err)
-	} else {
-		// here we handle two cases.
-		// 1. the lock has existed before but has not been superflud staking
-		// 2. the lock has existed before and has been superfluid staking
-
-		// we check if synth lock that has existed before, if it did, it means that the lock has been superfluid staked
-		// we do not care about unbonding synthlocks, as superfluid delegation has no effect
-
-		_, err := suite.App.LockupKeeper.GetSyntheticLockup(suite.Ctx, lockID, keeper.StakingSyntheticDenom(lock.Coins[0].Denom, valAddr.String()))
-		// if lock has existed before but has not been superfluid staked, we do initial superfluid staking
-		if err != nil {
-			err = suite.App.SuperfluidKeeper.SuperfluidDelegate(suite.Ctx, lock.Owner, lock.ID, valAddr.String())
-			suite.Require().NoError(err)
-		}
-	}
-
-	return *lock
-}
 
 func (suite *KeeperTestSuite) TestSuperfluidDelegate() {
 	testCases := []struct {
 		name               string
 		validatorStats     []stakingtypes.BondStatus
-		delegatorNumber    int
 		superDelegations   []superfluidDelegation
 		expInterDelegation []sdk.Dec
 	}{
 		{
 			"with single validator and single superfluid delegation",
 			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			1,
 			[]superfluidDelegation{{0, 0, 0, 1000000}},
 			[]sdk.Dec{sdk.NewDec(10000000)}, // 50% x 20 x 1000000
 		},
 		{
 			"with single validator and additional superfluid delegations",
 			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			1,
 			[]superfluidDelegation{{0, 0, 0, 1000000}, {0, 0, 0, 1000000}},
 			[]sdk.Dec{sdk.NewDec(20000000)}, // 50% x 20 x 1000000 x 2
 		},
 		{
 			"with multiple validators and multiple superfluid delegations",
 			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
-			2,
 			[]superfluidDelegation{{0, 0, 0, 1000000}, {1, 1, 0, 1000000}},
 			[]sdk.Dec{sdk.NewDec(10000000), sdk.NewDec(10000000)}, // 50% x 20 x 1000000
 		},
@@ -166,9 +53,6 @@ func (suite *KeeperTestSuite) TestSuperfluidDelegate() {
 			suite.SetupTest()
 			bondDenom := suite.App.StakingKeeper.BondDenom(suite.Ctx)
 
-			// Generate delegator addresses
-			delAddrs := CreateRandomAccounts(tc.delegatorNumber)
-
 			// setup validators
 			valAddrs := suite.SetupValidators(tc.validatorStats)
 
@@ -179,8 +63,7 @@ func (suite *KeeperTestSuite) TestSuperfluidDelegate() {
 			presupplyWithOffset := suite.App.BankKeeper.GetSupplyWithOffset(suite.Ctx, bondDenom)
 
 			// setup superfluid delegations
-			_, _, _ = delAddrs, valAddrs, denoms
-			intermediaryAccs, locks := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, tc.superDelegations, denoms)
+			_, intermediaryAccs, locks := suite.setupSuperfluidDelegations(valAddrs, tc.superDelegations, denoms)
 
 			// ensure post-superfluid delegations osmo supplywithoffset is the same while supply is not
 			postsupply := suite.App.BankKeeper.GetSupply(suite.Ctx, bondDenom)
@@ -257,9 +140,7 @@ func (suite *KeeperTestSuite) TestSuperfluidUndelegate() {
 	testCases := []struct {
 		name                  string
 		validatorStats        []stakingtypes.BondStatus
-		delegatorNumber       int
 		superDelegations      []superfluidDelegation
-		addMoreTokensLockIds  []uint64
 		superUnbondingLockIds []uint64
 		expSuperUnbondingErr  []bool
 		// expected amount of delegation to intermediary account
@@ -268,9 +149,7 @@ func (suite *KeeperTestSuite) TestSuperfluidUndelegate() {
 		{
 			"with single validator and single superfluid delegation and single undelegation",
 			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			1,
 			[]superfluidDelegation{{0, 0, 0, 1000000}},
-			[]uint64{},
 			[]uint64{1},
 			[]bool{false},
 			[]sdk.Dec{sdk.ZeroDec()},
@@ -287,9 +166,7 @@ func (suite *KeeperTestSuite) TestSuperfluidUndelegate() {
 		{
 			"with single validator and additional superfluid delegations and single undelegation",
 			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			1,
 			[]superfluidDelegation{{0, 0, 0, 1000000}, {0, 0, 0, 1000000}},
-			[]uint64{},
 			[]uint64{1},
 			[]bool{false},
 			[]sdk.Dec{sdk.ZeroDec()},
@@ -297,9 +174,7 @@ func (suite *KeeperTestSuite) TestSuperfluidUndelegate() {
 		{
 			"with multiple validators and multiple superfluid delegations and multiple undelegations",
 			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
-			2,
 			[]superfluidDelegation{{0, 0, 0, 1000000}, {1, 1, 0, 1000000}},
-			[]uint64{},
 			[]uint64{1, 2},
 			[]bool{false, false},
 			[]sdk.Dec{sdk.ZeroDec()},
@@ -307,9 +182,7 @@ func (suite *KeeperTestSuite) TestSuperfluidUndelegate() {
 		{
 			"undelegating not available lock id",
 			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			1,
 			[]superfluidDelegation{{0, 0, 0, 1000000}},
-			[]uint64{},
 			[]uint64{2},
 			[]bool{true},
 			[]sdk.Dec{},
@@ -317,9 +190,7 @@ func (suite *KeeperTestSuite) TestSuperfluidUndelegate() {
 		{
 			"try undelegating twice for same lock id",
 			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			1,
 			[]superfluidDelegation{{0, 0, 0, 1000000}},
-			[]uint64{},
 			[]uint64{1, 1},
 			[]bool{false, true},
 			[]sdk.Dec{sdk.ZeroDec()},
@@ -333,30 +204,15 @@ func (suite *KeeperTestSuite) TestSuperfluidUndelegate() {
 
 			bondDenom := suite.App.StakingKeeper.GetParams(suite.Ctx).BondDenom
 
-			// Generate delegator addresses
-			delAddrs := CreateRandomAccounts(tc.delegatorNumber)
-
 			// setup validators
 			valAddrs := suite.SetupValidators(tc.validatorStats)
 
 			denoms, _ := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20), sdk.NewDec(20)})
 
 			// setup superfluid delegations
-			intermediaryAccs, _ := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, tc.superDelegations, denoms)
+			_, intermediaryAccs, _ := suite.setupSuperfluidDelegations(valAddrs, tc.superDelegations, denoms)
 			suite.checkIntermediaryAccountDelegations(intermediaryAccs)
 
-			for _, lockId := range tc.addMoreTokensLockIds {
-				lock, err := suite.App.LockupKeeper.GetLockByID(suite.Ctx, lockId)
-				suite.Require().NoError(err)
-				lockOwner, err := sdk.AccAddressFromBech32(lock.Owner)
-				suite.Require().NoError(err)
-				coin := sdk.NewInt64Coin("gamm/pool/1", 1000000)
-				suite.App.BankKeeper.MintCoins(suite.Ctx, minttypes.ModuleName, sdk.NewCoins(coin))
-				suite.App.BankKeeper.SendCoinsFromModuleToAccount(suite.Ctx, minttypes.ModuleName, lockOwner, sdk.NewCoins(coin))
-				_, err = suite.App.LockupKeeper.AddTokensToLockByID(suite.Ctx, lockId, lockOwner, coin)
-				suite.Require().NoError(err)
-			}
-
 			for index, lockId := range tc.superUnbondingLockIds {
 				// get intermediary account
 				accAddr := suite.App.SuperfluidKeeper.GetLockIdIntermediaryAccountConnection(suite.Ctx, lockId)
@@ -445,16 +301,13 @@ func (suite *KeeperTestSuite) TestSuperfluidUndelegate() {
 func (suite *KeeperTestSuite) TestSuperfluidUnbondLock() {
 	suite.SetupTest()
 
-	// Generate delegator addresses
-	delAddrs := CreateRandomAccounts(1)
-
 	// setup validators
 	valAddrs := suite.SetupValidators([]stakingtypes.BondStatus{stakingtypes.Bonded})
 
 	denoms, _ := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20), sdk.NewDec(20)})
 
 	// setup superfluid delegations
-	intermediaryAccs, locks := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, []superfluidDelegation{{0, 0, 0, 1000000}}, denoms)
+	_, intermediaryAccs, locks := suite.setupSuperfluidDelegations(valAddrs, []superfluidDelegation{{0, 0, 0, 1000000}}, denoms)
 	suite.checkIntermediaryAccountDelegations(intermediaryAccs)
 
 	for _, lock := range locks {
@@ -527,6 +380,151 @@ func (suite *KeeperTestSuite) TestSuperfluidUnbondLock() {
 	}
 }
 
+func (suite *KeeperTestSuite) TestRefreshIntermediaryDelegationAmounts() {
+	testCases := []struct {
+		name             string
+		validatorStats   []stakingtypes.BondStatus
+		superDelegations []superfluidDelegation
+		// denom of the superfluid asset is the key, multiplier is the value
+		multipliersByDenom map[string]sdk.Dec
+	}{
+		{
+			"with single validator and single delegation",
+			[]stakingtypes.BondStatus{stakingtypes.Bonded},
+			[]superfluidDelegation{{0, 0, 0, 1000000}},
+			map[string]sdk.Dec{"gamm/pool/1": sdk.NewDec(10)},
+		},
+		{
+			"with single validator and additional delegations",
+			[]stakingtypes.BondStatus{stakingtypes.Bonded},
+			[]superfluidDelegation{{0, 0, 0, 1000000}, {0, 0, 0, 1000000}},
+			map[string]sdk.Dec{"gamm/pool/1": sdk.NewDec(10)},
+		},
+		{
+			"with multiple validator and multiple superfluid delegations",
+			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
+			[]superfluidDelegation{{0, 0, 0, 1000000}, {1, 1, 0, 1000000}},
+			map[string]sdk.Dec{"gamm/pool/1": sdk.NewDec(10)},
+		},
+		{
+			"with single validator and multiple denom superfluid delegations",
+			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
+			[]superfluidDelegation{{0, 0, 0, 1000000}, {0, 0, 1, 1000000}},
+			map[string]sdk.Dec{"gamm/pool/1": sdk.NewDec(10), "gamm/pool/2": sdk.NewDec(10)},
+		},
+		{
+			"with multiple validators and multiple denom superfluid delegations",
+			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
+			[]superfluidDelegation{{0, 0, 0, 1000000}, {0, 1, 1, 1000000}},
+			map[string]sdk.Dec{"gamm/pool/1": sdk.NewDec(10), "gamm/pool/2": sdk.NewDec(10)},
+		},
+		{
+			"zero price multiplier check",
+			[]stakingtypes.BondStatus{stakingtypes.Bonded},
+			[]superfluidDelegation{{0, 0, 0, 1000000}},
+			map[string]sdk.Dec{"gamm/pool/1": sdk.NewDec(0)},
+		},
+		{
+			"dust price multiplier check",
+			[]stakingtypes.BondStatus{stakingtypes.Bonded},
+			[]superfluidDelegation{{0, 0, 0, 1000000}},
+			map[string]sdk.Dec{"gamm/pool/1": sdk.NewDecWithPrec(1, 10)}, // 10^-10
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		suite.Run(tc.name, func() {
+			suite.SetupTest()
+
+			// setup validators
+			valAddrs := suite.SetupValidators(tc.validatorStats)
+
+			denoms, _ := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20), sdk.NewDec(20)})
+
+			// setup superfluid delegations
+			_, intermediaryAccs, locks := suite.setupSuperfluidDelegations(valAddrs, tc.superDelegations, denoms)
+			suite.checkIntermediaryAccountDelegations(intermediaryAccs)
+
+			// we make a map of intermediary account to delegation shares to store delegation share
+			// before refreshing intermediary account delegations on epoch
+			interAccIndexToDenomShare := make(map[int]sdk.Dec)
+			for accIndex, intermediaryAcc := range intermediaryAccs {
+				valAddr, err := sdk.ValAddressFromBech32(intermediaryAcc.ValAddr)
+				suite.Require().NoError(err)
+				delegation, found := suite.App.StakingKeeper.GetDelegation(suite.Ctx, intermediaryAcc.GetAccAddress(), valAddr)
+				suite.Require().True(found)
+
+				interAccIndexToDenomShare[accIndex] = delegation.Shares
+			}
+
+			for denom, multiplier := range tc.multipliersByDenom {
+				suite.App.SuperfluidKeeper.SetOsmoEquivalentMultiplier(suite.Ctx, 2, denom, multiplier)
+			}
+
+			suite.App.SuperfluidKeeper.RefreshIntermediaryDelegationAmounts(suite.Ctx)
+
+			originalMultiplier := sdk.NewDec(20)
+			for interAccIndex, intermediaryAcc := range intermediaryAccs {
+				multiplier := tc.multipliersByDenom[intermediaryAcc.Denom]
+				oldDelegation := interAccIndexToDenomShare[interAccIndex]
+				expDelegation := oldDelegation.Mul(multiplier).Quo(originalMultiplier)
+				lpTokenAmount := sdk.NewInt(1000000)
+				decAmt := multiplier.Mul(lpTokenAmount.ToDec())
+				asset := suite.App.SuperfluidKeeper.GetSuperfluidAsset(suite.Ctx, intermediaryAcc.Denom)
+				expAmount := suite.App.SuperfluidKeeper.GetRiskAdjustedOsmoValue(suite.Ctx, asset, decAmt.RoundInt())
+
+				// check delegation changes
+				valAddr, err := sdk.ValAddressFromBech32(intermediaryAcc.ValAddr)
+				suite.Require().NoError(err)
+				delegation, found := suite.App.StakingKeeper.GetDelegation(suite.Ctx, intermediaryAcc.GetAccAddress(), valAddr)
+				if expAmount.IsPositive() {
+					suite.Require().True(found)
+					suite.Require().Equal(delegation.Shares, expDelegation)
+				} else {
+					suite.Require().False(found)
+				}
+			}
+
+			// unbond all lockups
+			for _, lock := range locks {
+				// superfluid undelegate
+				// handling the case same lockup is used for further delegation
+				cacheCtx, write := suite.Ctx.CacheContext()
+				err := suite.App.SuperfluidKeeper.SuperfluidUndelegate(cacheCtx, lock.Owner, lock.ID)
+				if err == nil {
+					write()
+				}
+			}
+			unbondingDuration := suite.App.StakingKeeper.GetParams(suite.Ctx).UnbondingTime
+
+			for _, intermediaryAcc := range intermediaryAccs {
+				suite.Ctx = suite.Ctx.WithBlockTime(suite.Ctx.BlockTime().Add(unbondingDuration + time.Second))
+				suite.App.EndBlocker(suite.Ctx, abci.RequestEndBlock{Height: suite.Ctx.BlockHeight()})
+
+				unbonded := suite.App.BankKeeper.GetBalance(suite.Ctx, intermediaryAcc.GetAccAddress(), sdk.DefaultBondDenom)
+				suite.Require().True(unbonded.IsZero())
+			}
+
+			// refresh intermediary account delegations
+			suite.App.SuperfluidKeeper.RefreshIntermediaryDelegationAmounts(suite.Ctx)
+
+			for _, intermediaryAcc := range intermediaryAccs {
+				// check unbonded amount is removed after refresh operation
+				refreshed := suite.App.BankKeeper.GetBalance(suite.Ctx, intermediaryAcc.GetAccAddress(), sdk.DefaultBondDenom)
+				suite.Require().True(refreshed.IsZero())
+			}
+
+		})
+	}
+}
+
+// type superfluidRedelegation struct {
+// 	lockId      uint64
+// 	oldValIndex int64
+// 	newValIndex int64
+// }
+
 // func (suite *KeeperTestSuite) TestSuperfluidRedelegate() {
 // 	testCases := []struct {
 // 		name                    string
@@ -676,367 +674,3 @@ func (suite *KeeperTestSuite) TestSuperfluidUnbondLock() {
 // 		})
 // 	}
 // }
-
-func (suite *KeeperTestSuite) TestRefreshIntermediaryDelegationAmounts() {
-	testCases := []struct {
-		name                string
-		validatorStats      []stakingtypes.BondStatus
-		delegatorNumber     int
-		superDelegations    []superfluidDelegation
-		roundOneMultipliers []osmoEquivalentMultiplier
-		roundTwoMultipliers []osmoEquivalentMultiplier
-		checkAccIndexes     []int64
-	}{
-		{
-			"with single validator and single delegation",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			1,
-			[]superfluidDelegation{{0, 0, 0, 1000000}},
-			[]osmoEquivalentMultiplier{{0, sdk.NewDec(10)}},
-			[]osmoEquivalentMultiplier{},
-			[]int64{0},
-		},
-		{
-			"with single validator and additional delegations",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			1,
-			[]superfluidDelegation{{0, 0, 0, 1000000}, {0, 0, 0, 1000000}},
-			[]osmoEquivalentMultiplier{{0, sdk.NewDec(10)}},
-			[]osmoEquivalentMultiplier{},
-			[]int64{0},
-		},
-		{
-			"with multiple validator and multiple superfluid delegations",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
-			2,
-			[]superfluidDelegation{{0, 0, 0, 1000000}, {1, 1, 0, 1000000}},
-			[]osmoEquivalentMultiplier{{0, sdk.NewDec(10)}},
-			[]osmoEquivalentMultiplier{},
-			[]int64{0, 1},
-		},
-		{
-			"with single validator and multiple denom superfluid delegations",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
-			2,
-			[]superfluidDelegation{{0, 0, 0, 1000000}, {0, 0, 1, 1000000}},
-			[]osmoEquivalentMultiplier{{0, sdk.NewDec(10)}, {1, sdk.NewDec(10)}},
-			[]osmoEquivalentMultiplier{},
-			[]int64{0, 1},
-		},
-		{
-			"with multiple validators and multiple denom superfluid delegations",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
-			2,
-			[]superfluidDelegation{{0, 0, 0, 1000000}, {0, 1, 1, 1000000}},
-			[]osmoEquivalentMultiplier{{0, sdk.NewDec(10)}, {1, sdk.NewDec(10)}},
-			[]osmoEquivalentMultiplier{},
-			[]int64{0, 1},
-		},
-		{
-			"zero price multiplier check",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			2,
-			[]superfluidDelegation{{0, 0, 0, 1000000}},
-			[]osmoEquivalentMultiplier{{0, sdk.NewDec(0)}},
-			[]osmoEquivalentMultiplier{},
-			[]int64{0},
-		},
-		{
-			"refresh case from zero to non-zero",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			2,
-			[]superfluidDelegation{{0, 0, 0, 1000000}},
-			[]osmoEquivalentMultiplier{{0, sdk.NewDec(0)}},
-			[]osmoEquivalentMultiplier{{0, sdk.NewDec(10)}},
-			[]int64{0},
-		},
-		{
-			"dust price multiplier check",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			2,
-			[]superfluidDelegation{{0, 0, 0, 1000000}},
-			[]osmoEquivalentMultiplier{{0, sdk.NewDecWithPrec(1, 10)}}, // 10^-10
-			[]osmoEquivalentMultiplier{},
-			[]int64{0},
-		},
-		{
-			"refresh case from dust to non-dust",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			2,
-			[]superfluidDelegation{{0, 0, 0, 1000000}},
-			[]osmoEquivalentMultiplier{{0, sdk.NewDecWithPrec(1, 10)}}, // 10^-10
-			[]osmoEquivalentMultiplier{{0, sdk.NewDec(10)}},
-			[]int64{0},
-		},
-	}
-
-	for _, tc := range testCases {
-		tc := tc
-		suite.Run(tc.name, func() {
-			suite.SetupTest()
-
-			bondDenom := suite.App.StakingKeeper.BondDenom(suite.Ctx)
-
-			// Generate delegator addresses
-			delAddrs := CreateRandomAccounts(tc.delegatorNumber)
-
-			// setup validators
-			valAddrs := suite.SetupValidators(tc.validatorStats)
-
-			denoms, _ := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20), sdk.NewDec(20)})
-
-			// setup superfluid delegations
-			intermediaryAccs, locks := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, tc.superDelegations, denoms)
-			suite.checkIntermediaryAccountDelegations(intermediaryAccs)
-			intermediaryDels := []sdk.Dec{}
-
-			for _, intAccIndex := range tc.checkAccIndexes {
-				expAcc := intermediaryAccs[intAccIndex]
-				valAddr, err := sdk.ValAddressFromBech32(expAcc.ValAddr)
-				suite.Require().NoError(err)
-
-				// check delegation from intermediary account to validator
-				delegation, found := suite.App.StakingKeeper.GetDelegation(suite.Ctx, expAcc.GetAccAddress(), valAddr)
-				suite.Require().True(found)
-				intermediaryDels = append(intermediaryDels, delegation.Shares)
-			}
-
-			// multiplier change before refresh
-			multiplierByDenom := make(map[string]sdk.Dec)
-			for _, multiplier := range tc.roundOneMultipliers {
-				denom := denoms[multiplier.lpIndex]
-				multiplierByDenom[denom] = multiplier.price
-				suite.App.SuperfluidKeeper.SetOsmoEquivalentMultiplier(suite.Ctx, 2, denom, multiplier.price)
-			}
-
-			// get pre-superfluid delgations osmo supply and supplyWithOffset
-			presupply := suite.App.BankKeeper.GetSupply(suite.Ctx, bondDenom)
-			presupplyWithOffset := suite.App.BankKeeper.GetSupplyWithOffset(suite.Ctx, bondDenom)
-
-			// refresh intermediary account delegations
-			suite.App.SuperfluidKeeper.RefreshIntermediaryDelegationAmounts(suite.Ctx)
-
-			// ensure post-superfluid delegations osmo supplywithoffset is the same while supply is not
-			postsupply := suite.App.BankKeeper.GetSupply(suite.Ctx, bondDenom)
-			postsupplyWithOffset := suite.App.BankKeeper.GetSupplyWithOffset(suite.Ctx, bondDenom)
-			suite.Require().False(postsupply.IsEqual(presupply), "presupply: %s   postsupply: %s", presupply, postsupply)
-			suite.Require().True(postsupplyWithOffset.IsEqual(presupplyWithOffset))
-
-			originMultiplier := sdk.NewDec(20)
-			for index, intAccIndex := range tc.checkAccIndexes {
-				expAcc := intermediaryAccs[intAccIndex]
-				multiplier, ok := multiplierByDenom[expAcc.Denom]
-				if !ok {
-					multiplier = originMultiplier
-				}
-
-				// calculating the estimated delegation amount for multiplier change
-				expDelegation := intermediaryDels[index].Mul(multiplier).Quo(originMultiplier)
-				lpTokenAmount := sdk.NewInt(1000000)
-				decAmt := multiplier.Mul(lpTokenAmount.ToDec())
-				asset := suite.App.SuperfluidKeeper.GetSuperfluidAsset(suite.Ctx, expAcc.Denom)
-				expAmount := suite.App.SuperfluidKeeper.GetRiskAdjustedOsmoValue(suite.Ctx, asset, decAmt.RoundInt())
-
-				valAddr, err := sdk.ValAddressFromBech32(expAcc.ValAddr)
-				suite.Require().NoError(err)
-
-				// check delegation changes
-				delegation, found := suite.App.StakingKeeper.GetDelegation(suite.Ctx, expAcc.GetAccAddress(), valAddr)
-				if expAmount.IsPositive() {
-					suite.Require().True(found)
-					suite.Require().Equal(delegation.Shares, expDelegation)
-				} else {
-					suite.Require().False(found)
-				}
-			}
-
-			// if second round multipliers exists, execute round two multipliers mock and finish tests
-			if len(tc.roundTwoMultipliers) > 0 {
-				multiplier2ByDenom := make(map[string]sdk.Dec)
-				for _, multiplier := range tc.roundTwoMultipliers {
-					denom := denoms[multiplier.lpIndex]
-					multiplier2ByDenom[denom] = multiplier.price
-					suite.App.SuperfluidKeeper.SetOsmoEquivalentMultiplier(suite.Ctx, 3, denom, multiplier.price)
-				}
-				// refresh intermediary account delegations
-				suite.App.SuperfluidKeeper.RefreshIntermediaryDelegationAmounts(suite.Ctx)
-
-				for index, intAccIndex := range tc.checkAccIndexes {
-					expAcc := intermediaryAccs[intAccIndex]
-					valAddr, err := sdk.ValAddressFromBech32(expAcc.ValAddr)
-					suite.Require().NoError(err)
-
-					expDelegation := intermediaryDels[index].Mul(multiplier2ByDenom[expAcc.Denom]).Quo(originMultiplier)
-
-					// check delegation changes
-					delegation, found := suite.App.StakingKeeper.GetDelegation(suite.Ctx, expAcc.GetAccAddress(), valAddr)
-
-					suite.Require().True(found)
-					suite.Require().Equal(delegation.Shares, expDelegation)
-				}
-				return
-			}
-
-			// unbond all lockups
-			for _, lock := range locks {
-				// superfluid undelegate
-				// handling the case same lockup is used for further delegation
-				cacheCtx, write := suite.Ctx.CacheContext()
-				err := suite.App.SuperfluidKeeper.SuperfluidUndelegate(cacheCtx, lock.Owner, lock.ID)
-				if err == nil {
-					write()
-				}
-			}
-			unbondingDuration := suite.App.StakingKeeper.GetParams(suite.Ctx).UnbondingTime
-
-			// check intermediary account changes after unbonding operations
-			for _, intAccIndex := range tc.checkAccIndexes {
-				expAcc := intermediaryAccs[intAccIndex]
-				suite.Ctx = suite.Ctx.WithBlockTime(suite.Ctx.BlockTime().Add(unbondingDuration + time.Second))
-				suite.App.EndBlocker(suite.Ctx, abci.RequestEndBlock{Height: suite.Ctx.BlockHeight()})
-
-				unbonded := suite.App.BankKeeper.GetBalance(suite.Ctx, expAcc.GetAccAddress(), sdk.DefaultBondDenom)
-				suite.Require().True(unbonded.IsZero())
-			}
-
-			// refresh intermediary account delegations
-			suite.App.SuperfluidKeeper.RefreshIntermediaryDelegationAmounts(suite.Ctx)
-
-			// check if intermediary accounts does not have free balance after refresh operation
-			for _, intAccIndex := range tc.checkAccIndexes {
-				expAcc := intermediaryAccs[intAccIndex]
-				// check unbonded amount is removed after refresh operation
-				refreshed := suite.App.BankKeeper.GetBalance(suite.Ctx, expAcc.GetAccAddress(), sdk.DefaultBondDenom)
-				suite.Require().True(refreshed.IsZero())
-			}
-		})
-	}
-}
-
-func (suite *KeeperTestSuite) TestSuperfluidDelegationGovernanceVoting() {
-	testCases := []struct {
-		name              string
-		validatorStats    []stakingtypes.BondStatus
-		superDelegations  [][]superfluidDelegation
-		normalDelegations []normalDelegation
-	}{
-		{
-			"with single validator and single delegation",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			[][]superfluidDelegation{{{0, 0, 0, 1000000}}},
-			nil,
-		},
-		{
-			"with single validator and additional delegations",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			[][]superfluidDelegation{{{0, 0, 0, 1000000}, {0, 0, 0, 1000000}}},
-			nil,
-		},
-		{
-			"with multiple validator and multiple superfluid delegations",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
-			[][]superfluidDelegation{{{0, 0, 0, 1000000}}, {{1, 1, 0, 1000000}}},
-			nil,
-		},
-		{
-			"with single validator and multiple denom superfluid delegations",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
-			[][]superfluidDelegation{{{0, 0, 0, 1000000}, {0, 0, 1, 1000000}}},
-			nil,
-		},
-		{
-			"with multiple validators and multiple denom superfluid delegations",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
-			[][]superfluidDelegation{{{0, 0, 0, 1000000}, {0, 1, 1, 1000000}}},
-			nil,
-		},
-		{
-			"many delegations",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded, stakingtypes.Bonded},
-			[][]superfluidDelegation{
-				{{0, 0, 0, 1000000}, {0, 1, 1, 1000000}},
-				{{1, 0, 0, 1000000}, {1, 0, 1, 1000000}},
-				{{2, 1, 1, 1000000}, {2, 1, 0, 1000000}},
-				{{3, 0, 0, 1000000}, {3, 1, 1, 1000000}},
-			},
-			nil,
-		},
-		{
-			"with normal delegations",
-			[]stakingtypes.BondStatus{stakingtypes.Bonded},
-			[][]superfluidDelegation{
-				{{0, 0, 0, 1000000}, {0, 0, 1, 1000000}},
-			},
-			[]normalDelegation{
-				{0, 0, 1000000},
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		tc := tc
-
-		suite.Run(tc.name, func() {
-			suite.SetupTest()
-
-			denoms, _ := suite.SetupGammPoolsAndSuperfluidAssets([]sdk.Dec{sdk.NewDec(20), sdk.NewDec(20)})
-
-			// Generate delegator addresses
-			delAddrs := CreateRandomAccounts(len(tc.superDelegations))
-
-			// setup validators
-			valAddrs := suite.SetupValidators(tc.validatorStats)
-
-			// setup superfluid delegations
-			for _, sfdel := range tc.superDelegations {
-				intermediaryAccs, _ := suite.SetupSuperfluidDelegations(delAddrs, valAddrs, sfdel, denoms)
-				suite.checkIntermediaryAccountDelegations(intermediaryAccs)
-			}
-
-			// setup normal delegations
-			for _, del := range tc.normalDelegations {
-				err := suite.SetupNormalDelegation(delAddrs, valAddrs, del)
-				suite.NoError(err)
-			}
-
-			// all expected delegated amounts to a validator from a delegator
-			delegatedAmount := func(delidx, validx int) sdk.Int {
-				res := sdk.ZeroInt()
-				for _, del := range tc.superDelegations[delidx] {
-					if del.valIndex == int64(validx) {
-						res = res.AddRaw(del.lpAmount)
-					}
-				}
-				if len(tc.normalDelegations) != 0 {
-					del := tc.normalDelegations[delidx]
-					res = res.AddRaw(del.coinAmount / 10) // LP price is 10 osmo in this test
-				}
-				return res
-			}
-			for delidx := range tc.superDelegations {
-				// store all actual delegations to a validator
-				sharePerValidatorMap := make(map[string]sdk.Dec)
-				for validx := range tc.validatorStats {
-					sharePerValidatorMap[valAddrs[validx].String()] = sdk.ZeroDec()
-				}
-				addToSharePerValidatorMap := func(val sdk.ValAddress, share sdk.Dec) {
-					if existing, ok := sharePerValidatorMap[val.String()]; ok {
-						share.AddMut(existing)
-					}
-					sharePerValidatorMap[val.String()] = share
-				}
-
-				// iterate delegations and add eligible shares to the sharePerValidatorMap
-				suite.App.SuperfluidKeeper.IterateDelegations(suite.Ctx, delAddrs[delidx], func(_ int64, del stakingtypes.DelegationI) bool {
-					addToSharePerValidatorMap(del.GetValidatorAddr(), del.GetShares())
-					return false
-				})
-
-				// check if the expected delegated amount equals to actual
-				for validx := range tc.validatorStats {
-					suite.Equal(delegatedAmount(delidx, validx).Int64()*10, sharePerValidatorMap[valAddrs[validx].String()].RoundInt().Int64())
-				}
-			}
-		})
-	}
-}
diff --git a/x/txfees/keeper/hooks_test.go b/x/txfees/keeper/hooks_test.go
index 9995ea275..6b5f97b1e 100644
--- a/x/txfees/keeper/hooks_test.go
+++ b/x/txfees/keeper/hooks_test.go
@@ -64,7 +64,7 @@ func (suite *KeeperTestSuite) TestTxFeesAfterEpochEnd() {
 		},
 	}
 
-	var finalOutputAmount = sdk.NewInt(0)
+	finalOutputAmount := sdk.NewInt(0)
 
 	for _, tc := range tests {
 		tc := tc