diff --git a/scripts/build/simulations.mk b/scripts/build/simulations.mk
index ea7510db4cb8..454820878013 100644
--- a/scripts/build/simulations.mk
+++ b/scripts/build/simulations.mk
@@ -2,7 +2,7 @@
 #? test-sim-nondeterminism: Run non-determinism test for simapp
 test-sim-nondeterminism:
 	@echo "Running non-determinism test..."
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -timeout=30m -tags='sims' -run TestAppStateDeterminism \
+	@cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -timeout=30m -tags='sims' -run TestAppStateDeterminism \
 		-NumBlocks=100 -BlockSize=200 -Period=0
 
 # Requires an exported plugin. See store/streaming/README.md for documentation.
@@ -16,45 +16,45 @@ test-sim-nondeterminism:
 #   make test-sim-nondeterminism-streaming
 test-sim-nondeterminism-streaming:
 	@echo "Running non-determinism-streaming test..."
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -timeout=30m -tags='sims' -run TestAppStateDeterminism \
+	@cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -timeout=30m -tags='sims' -run TestAppStateDeterminism \
 		-NumBlocks=100 -BlockSize=200 -Period=0 -EnableStreaming=true
 
 test-sim-custom-genesis-fast:
 	@echo "Running custom genesis simulation..."
 	@echo "By default, ${HOME}/.simapp/config/genesis.json will be used."
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -timeout=30m -tags='sims' -run TestFullAppSimulation -Genesis=${HOME}/.simapp/config/genesis.json \
+	@cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -timeout=30m -tags='sims' -run TestFullAppSimulation -Genesis=${HOME}/.simapp/config/genesis.json \
 		-NumBlocks=100 -BlockSize=200 -Seed=99 -Period=5 -SigverifyTx=false
 
 test-sim-import-export:
 	@echo "Running application import/export simulation. This may take several minutes..."
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -timeout 20m -tags='sims' -run TestAppImportExport \
+	@cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -timeout 20m -tags='sims' -run TestAppImportExport \
 		-NumBlocks=50 -Period=5
 
 test-sim-after-import:
 	@echo "Running application simulation-after-import. This may take several minutes..."
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -timeout 30m -tags='sims' -run TestAppSimulationAfterImport \
+	@cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -timeout 30m -tags='sims' -run TestAppSimulationAfterImport \
 		-NumBlocks=50 -Period=5
 
 
 test-sim-custom-genesis-multi-seed:
 	@echo "Running multi-seed custom genesis simulation..."
 	@echo "By default, ${HOME}/.simapp/config/genesis.json will be used."
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -timeout 30m -tags='sims' -run TestFullAppSimulation -Genesis=${HOME}/.simapp/config/genesis.json \
+	@cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -timeout 30m -tags='sims' -run TestFullAppSimulation -Genesis=${HOME}/.simapp/config/genesis.json \
 		-NumBlocks=400 -Period=5
 
 test-sim-multi-seed-long:
 	@echo "Running long multi-seed application simulation. This may take awhile!"
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -timeout=1h -tags='sims' -run TestFullAppSimulation \
+	@cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -timeout=1h -tags='sims' -run TestFullAppSimulation \
 		-NumBlocks=150 -Period=50
 
 test-sim-multi-seed-short:
 	@echo "Running short multi-seed application simulation. This may take awhile!"
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -timeout 30m -tags='sims' -run TestFullAppSimulation \
-		-NumBlocks=50 -Period=10
+	@cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -timeout 30m -tags='sims' -run TestFullAppSimulation \
+		-NumBlocks=50 -Period=10 -FauxMerkle=true
 
 test-sim-benchmark-invariants:
 	@echo "Running simulation invariant benchmarks..."
-	cd ${CURRENT_DIR}/simapp && go test -mod=readonly -benchmem -bench=BenchmarkInvariants -tags='sims' -run=^$ \
+	cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -benchmem -bench=BenchmarkInvariants -tags='sims' -run=^$ \
 	-Enabled=true -NumBlocks=1000 -BlockSize=200 \
 	-Period=1 -Commit=true -Seed=57 -v -timeout 24h
 
@@ -77,50 +77,23 @@ SIM_COMMIT ?= true
 test-sim-fuzz:
 	@echo "Running application fuzz for numBlocks=2, blockSize=20. This may take awhile!"
 #ld flags are a quick fix to make it work on current osx
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -json -tags='sims' -ldflags="-extldflags=-Wl,-ld_classic" -timeout=60m -fuzztime=60m -run=^$$ -fuzz=FuzzFullAppSimulation -GenesisTime=1714720615 -NumBlocks=2 -BlockSize=20
+	@cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -json -tags='sims' -ldflags="-extldflags=-Wl,-ld_classic" -timeout=60m -fuzztime=60m -run=^$$ -fuzz=FuzzFullAppSimulation -GenesisTime=1714720615 -NumBlocks=2 -BlockSize=20
 
 #? test-sim-benchmark: Run benchmark test for simapp
 test-sim-benchmark:
 	@echo "Running application benchmark for numBlocks=$(SIM_NUM_BLOCKS), blockSize=$(SIM_BLOCK_SIZE). This may take awhile!"
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -tags='sims' -run=^$$ $(.) -bench ^BenchmarkFullAppSimulation$$  \
+	@cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -tags='sims' -run=^$$ $(.) -bench ^BenchmarkFullAppSimulation$$  \
 		-Enabled=true -NumBlocks=$(SIM_NUM_BLOCKS) -BlockSize=$(SIM_BLOCK_SIZE) -Commit=$(SIM_COMMIT) -timeout 24h
 
-# Requires an exported plugin. See store/streaming/README.md for documentation.
-#
-# example:
-#   export COSMOS_SDK_ABCI_V1=<path-to-plugin-binary>
-#   make test-sim-benchmark-streaming
-#
-# Using the built-in examples:
-#   export COSMOS_SDK_ABCI_V1=<path-to-sdk>/store/streaming/abci/examples/file/file
-#   make test-sim-benchmark-streaming
-test-sim-benchmark-streaming:
-	@echo "Running application benchmark for numBlocks=$(SIM_NUM_BLOCKS), blockSize=$(SIM_BLOCK_SIZE). This may take awhile!"
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -tags='sims' -run=^$$ $(.) -bench ^BenchmarkFullAppSimulation$$  \
-		-Enabled=true -NumBlocks=$(SIM_NUM_BLOCKS) -BlockSize=$(SIM_BLOCK_SIZE) -Commit=$(SIM_COMMIT) -timeout 24h -EnableStreaming=true
 
 test-sim-profile:
 	@echo "Running application benchmark for numBlocks=$(SIM_NUM_BLOCKS), blockSize=$(SIM_BLOCK_SIZE). This may take awhile!"
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -tags='sims' -benchmem -run=^$$ $(.) -bench ^BenchmarkFullAppSimulation$$ \
+	@cd ${CURRENT_DIR}/simapp && go test -failfast -mod=readonly -tags='sims' -benchmem -run=^$$ $(.) -bench ^BenchmarkFullAppSimulation$$ \
 		-Enabled=true -NumBlocks=$(SIM_NUM_BLOCKS) -BlockSize=$(SIM_BLOCK_SIZE) -Commit=$(SIM_COMMIT) -timeout 24h -cpuprofile cpu.out -memprofile mem.out
 
-# Requires an exported plugin. See store/streaming/README.md for documentation.
-#
-# example:
-#   export COSMOS_SDK_ABCI_V1=<path-to-plugin-binary>
-#   make test-sim-profile-streaming
-#
-# Using the built-in examples:
-#   export COSMOS_SDK_ABCI_V1=<path-to-sdk>/store/streaming/abci/examples/file/file
-#   make test-sim-profile-streaming
-test-sim-profile-streaming:
-	@echo "Running application benchmark for numBlocks=$(SIM_NUM_BLOCKS), blockSize=$(SIM_BLOCK_SIZE). This may take awhile!"
-	@cd ${CURRENT_DIR}/simapp && go test -mod=readonly -tags='sims' -benchmem -run=^$$ $(.) -bench ^BenchmarkFullAppSimulation$$ \
-		-Enabled=true -NumBlocks=$(SIM_NUM_BLOCKS) -BlockSize=$(SIM_BLOCK_SIZE) -Commit=$(SIM_COMMIT) -timeout 24h -cpuprofile cpu.out -memprofile mem.out -EnableStreaming=true
-
 .PHONY: test-sim-profile test-sim-benchmark test-sim-fuzz
 
 #? benchmark: Run benchmark tests
 benchmark:
-	@go test -mod=readonly -bench=. $(PACKAGES_NOSIMULATION)
+	@go test -failfast -mod=readonly -bench=. $(PACKAGES_NOSIMULATION)
 .PHONY: benchmark
diff --git a/simapp/app.go b/simapp/app.go
index 092435e4781c..ac8368cd8a3e 100644
--- a/simapp/app.go
+++ b/simapp/app.go
@@ -538,7 +538,7 @@ func NewSimApp(
 	overrideModules := map[string]module.AppModuleSimulation{
 		authtypes.ModuleName: auth.NewAppModule(app.appCodec, app.AuthKeeper, app.AccountsKeeper, authsims.RandomGenesisAccounts),
 	}
-	app.sm = module.NewSimulationManagerFromAppModules(app.ModuleManager.Modules, overrideModules)
+	app.sm = module.NewSimulationManagerFromAppModules(app.AuthKeeper, app.BankKeeper, app.ModuleManager.Modules, overrideModules)
 
 	// create, start, and load the unordered tx manager
 	utxDataDir := filepath.Join(homePath, "data")
diff --git a/simapp/app_di.go b/simapp/app_di.go
index 63beee09ab7e..2815b8d06b89 100644
--- a/simapp/app_di.go
+++ b/simapp/app_di.go
@@ -276,7 +276,7 @@ func NewSimApp(
 	overrideModules := map[string]module.AppModuleSimulation{
 		authtypes.ModuleName: auth.NewAppModule(app.appCodec, app.AuthKeeper, &app.AccountsKeeper, authsims.RandomGenesisAccounts),
 	}
-	app.sm = module.NewSimulationManagerFromAppModules(app.ModuleManager.Modules, overrideModules)
+	app.sm = module.NewSimulationManagerFromAppModules(app.AuthKeeper, app.BankKeeper, app.ModuleManager.Modules, overrideModules)
 
 	app.sm.RegisterStoreDecoders()
 
diff --git a/simapp/sim_bench_test.go b/simapp/sim_bench_test.go
index 4a7832c8ec14..af3020a90839 100644
--- a/simapp/sim_bench_test.go
+++ b/simapp/sim_bench_test.go
@@ -3,32 +3,13 @@
 package simapp
 
 import (
-	"os"
 	"testing"
 
-	"cosmossdk.io/log"
 	"github.com/cosmos/cosmos-sdk/testutils/sims"
 
-	flag "github.com/spf13/pflag"
-	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
-
-	"github.com/cosmos/cosmos-sdk/baseapp"
-	"github.com/cosmos/cosmos-sdk/client/flags"
-	"github.com/cosmos/cosmos-sdk/server"
-	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
-	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
-	"github.com/cosmos/cosmos-sdk/x/simulation"
 	simcli "github.com/cosmos/cosmos-sdk/x/simulation/client/cli"
 )
 
-var FlagEnableBenchStreamingValue bool
-
-// Get flags every time the simulator is run
-func init() {
-	flag.BoolVar(&FlagEnableBenchStreamingValue, "EnableStreaming", false, "Enable streaming service")
-}
-
 // Profile with:
 // /usr/local/go/bin/go test -benchmem -run=^$ cosmossdk.io/simapp -bench ^BenchmarkFullAppSimulation$ -Commit=true -cpuprofile cpu.out
 func BenchmarkFullAppSimulation(b *testing.B) {
@@ -37,52 +18,5 @@ func BenchmarkFullAppSimulation(b *testing.B) {
 	config := simcli.NewConfigFromFlags()
 	config.ChainID = sims.SimAppChainID
 
-	db, dir, logger, skip, err := simtestutil.SetupSimulation(config, "goleveldb-app-sim", "Simulation", simcli.FlagVerboseValue, simcli.FlagEnabledValue)
-	if err != nil {
-		b.Fatalf("simulation setup failed: %s", err.Error())
-	}
-
-	if skip {
-		b.Skip("skipping benchmark application simulation")
-	}
-
-	defer func() {
-		require.NoError(b, db.Close())
-		require.NoError(b, os.RemoveAll(dir))
-	}()
-
-	appOptions := viper.New()
-	appOptions.SetDefault(flags.FlagHome, DefaultNodeHome)
-	appOptions.SetDefault(server.FlagInvCheckPeriod, simcli.FlagPeriodValue)
-
-	app := NewSimApp(logger, db, nil, true, appOptions, interBlockCacheOpt(), baseapp.SetChainID(sims.SimAppChainID))
-
-	// run randomized simulation
-	simParams, simErr := simulation.SimulateFromSeedX(
-		b,
-		log.NewNopLogger(),
-		os.Stdout,
-		app.BaseApp,
-		simtestutil.AppStateFn(app.AppCodec(), app.AuthKeeper.AddressCodec(), app.StakingKeeper.ValidatorAddressCodec(), app.SimulationManager(), app.DefaultGenesis()),
-		simtypes.RandomAccounts,
-		simtestutil.SimulationOperations(app, app.AppCodec(), config, app.txConfig),
-		BlockedAddresses(),
-		config,
-		app.AppCodec(),
-		app.txConfig.SigningContext().AddressCodec(),
-		&simulation.DummyLogWriter{},
-	)
-
-	// export state and simParams before the simulation error is checked
-	if err = simtestutil.CheckExportSimulation(app, config, simParams); err != nil {
-		b.Fatal(err)
-	}
-
-	if simErr != nil {
-		b.Fatal(simErr)
-	}
-
-	if config.Commit {
-		simtestutil.PrintStats(db)
-	}
+	sims.RunWithSeed(b, config, NewSimApp, setupStateFactory, 1, nil)
 }
diff --git a/simapp/sim_test.go b/simapp/sim_test.go
index 7a02d6a46cd6..258c5e45709a 100644
--- a/simapp/sim_test.go
+++ b/simapp/sim_test.go
@@ -11,6 +11,7 @@ import (
 	"strings"
 	"sync"
 	"testing"
+	"time"
 
 	"cosmossdk.io/log"
 	"cosmossdk.io/store"
@@ -63,12 +64,12 @@ func setupStateFactory(app *SimApp) sims.SimStateFactory {
 }
 
 var (
-	exportAllModules       = []string{}
-	exportWithValidatorSet = []string{}
+	exportAllModules       []string
+	exportWithValidatorSet []string
 )
 
 func TestAppImportExport(t *testing.T) {
-	sims.Run(t, NewSimApp, setupStateFactory, func(t *testing.T, ti sims.TestInstance[*SimApp]) {
+	sims.Run(t, NewSimApp, setupStateFactory, func(t testing.TB, ti sims.TestInstance[*SimApp]) {
 		app := ti.App
 		t.Log("exporting genesis...\n")
 		exported, err := app.ExportAppStateAndValidators(false, exportWithValidatorSet, exportAllModules)
@@ -110,40 +111,34 @@ func TestAppImportExport(t *testing.T) {
 //	set up a new node instance, Init chain from exported genesis
 //	run new instance for n blocks
 func TestAppSimulationAfterImport(t *testing.T) {
-	sims.Run(t, NewSimApp, setupStateFactory, func(t *testing.T, ti sims.TestInstance[*SimApp]) {
+	sims.Run(t, NewSimApp, setupStateFactory, func(t testing.TB, ti sims.TestInstance[*SimApp]) {
 		app := ti.App
 		t.Log("exporting genesis...\n")
 		exported, err := app.ExportAppStateAndValidators(false, exportWithValidatorSet, exportAllModules)
 		require.NoError(t, err)
 
 		t.Log("importing genesis...\n")
-		newTestInstance := sims.NewSimulationAppInstance(t, ti.Cfg, NewSimApp)
-		newApp := newTestInstance.App
-		_, err = newApp.InitChain(&abci.InitChainRequest{
-			AppStateBytes: exported.AppState,
-			ChainId:       sims.SimAppChainID,
-		})
-		if IsEmptyValidatorSetErr(err) {
-			t.Skip("Skipping simulation as all validators have been unbonded")
-			return
+		importGenesisStateFactory := func(app *SimApp) sims.SimStateFactory {
+			return sims.SimStateFactory{
+				Codec: app.AppCodec(),
+				AppStateFn: func(r *rand.Rand, accs []simtypes.Account, config simtypes.Config) (json.RawMessage, []simtypes.Account, string, time.Time) {
+					_, err = app.InitChain(&abci.InitChainRequest{
+						AppStateBytes: exported.AppState,
+						ChainId:       sims.SimAppChainID,
+					})
+					if IsEmptyValidatorSetErr(err) {
+						t.Skip("Skipping simulation as all validators have been unbonded")
+						return nil, nil, "", time.Time{}
+					}
+					acc, err := simtestutil.AccountsFromAppState(app.AppCodec(), exported.AppState)
+					require.NoError(t, err)
+					genesisTimestamp := time.Unix(config.GenesisTime, 0)
+					return exported.AppState, acc, config.ChainID, genesisTimestamp
+				},
+				BlockedAddr: BlockedAddresses(),
+			}
 		}
-		require.NoError(t, err)
-		newStateFactory := setupStateFactory(newApp)
-		_, err = simulation.SimulateFromSeedX(
-			t,
-			newTestInstance.AppLogger,
-			sims.WriteToDebugLog(newTestInstance.AppLogger),
-			newApp.BaseApp,
-			newStateFactory.AppStateFn,
-			simtypes.RandomAccounts,
-			simtestutil.SimulationOperations(newApp, newApp.AppCodec(), newTestInstance.Cfg, newApp.TxConfig()),
-			newStateFactory.BlockedAddr,
-			newTestInstance.Cfg,
-			newStateFactory.Codec,
-			newApp.TxConfig().SigningContext().AddressCodec(),
-			ti.ExecLogWriter,
-		)
-		require.NoError(t, err)
+		sims.RunWithSeed(t, ti.Cfg, NewSimApp, importGenesisStateFactory, ti.Cfg.Seed, ti.Cfg.FuzzSeed)
 	})
 }
 
@@ -189,7 +184,7 @@ func TestAppStateDeterminism(t *testing.T) {
 	var mx sync.Mutex
 	appHashResults := make(map[int64][][]byte)
 	appSimLogger := make(map[int64][]simulation.LogWriter)
-	captureAndCheckHash := func(t *testing.T, ti sims.TestInstance[*SimApp]) {
+	captureAndCheckHash := func(t testing.TB, ti sims.TestInstance[*SimApp]) {
 		seed, appHash := ti.Cfg.Seed, ti.App.LastCommitID().Hash
 		mx.Lock()
 		otherHashes, execWriters := appHashResults[seed], appSimLogger[seed]
@@ -225,7 +220,7 @@ type ComparableStoreApp interface {
 	GetStoreKeys() []storetypes.StoreKey
 }
 
-func AssertEqualStores(t *testing.T, app ComparableStoreApp, newApp ComparableStoreApp, storeDecoders simtypes.StoreDecoderRegistry, skipPrefixes map[string][][]byte) {
+func AssertEqualStores(t testing.TB, app ComparableStoreApp, newApp ComparableStoreApp, storeDecoders simtypes.StoreDecoderRegistry, skipPrefixes map[string][][]byte) {
 	ctxA := app.NewContextLegacy(true, cmtproto.Header{Height: app.LastBlockHeight()})
 	ctxB := newApp.NewContextLegacy(true, cmtproto.Header{Height: app.LastBlockHeight()})
 
diff --git a/simsx/common_test.go b/simsx/common_test.go
new file mode 100644
index 000000000000..32703ef3259e
--- /dev/null
+++ b/simsx/common_test.go
@@ -0,0 +1,161 @@
+package simsx
+
+import (
+	"context"
+	"math/rand"
+
+	"github.com/cosmos/gogoproto/proto"
+
+	coretransaction "cosmossdk.io/core/transaction"
+	"cosmossdk.io/x/auth/tx"
+	"cosmossdk.io/x/tx/signing"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/codec/address"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+	"github.com/cosmos/cosmos-sdk/std"
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+)
+
+// SimAccountFixture testing only
+func SimAccountFixture(mutators ...func(account *SimAccount)) SimAccount {
+	r := rand.New(rand.NewSource(1))
+	acc := SimAccount{
+		Account: simtypes.RandomAccounts(r, 1)[0],
+	}
+	acc.liquidBalance = NewSimsAccountBalance(&acc, r, sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1_000_000_000)))
+	for _, mutator := range mutators {
+		mutator(&acc)
+	}
+	return acc
+}
+
+// MemoryAccountSource testing only
+func MemoryAccountSource(srcs ...SimAccount) AccountSourceFn {
+	accs := make(map[string]FakeAccountI, len(srcs))
+	for _, src := range srcs {
+		accs[src.AddressBech32] = FakeAccountI{SimAccount: src, id: 1, seq: 2}
+	}
+	return func(ctx context.Context, addr sdk.AccAddress) sdk.AccountI {
+		return accs[addr.String()]
+	}
+}
+
+// testing only
+func txConfig() client.TxConfig {
+	ir := must(codectypes.NewInterfaceRegistryWithOptions(codectypes.InterfaceRegistryOptions{
+		ProtoFiles: proto.HybridResolver,
+		SigningOptions: signing.Options{
+			AddressCodec:          address.NewBech32Codec("cosmos"),
+			ValidatorAddressCodec: address.NewBech32Codec("cosmosvaloper"),
+		},
+	}))
+	std.RegisterInterfaces(ir)
+	ir.RegisterImplementations((*coretransaction.Msg)(nil), &testdata.TestMsg{})
+	protoCodec := codec.NewProtoCodec(ir)
+	signingCtx := protoCodec.InterfaceRegistry().SigningContext()
+	return tx.NewTxConfig(protoCodec, signingCtx.AddressCodec(), signingCtx.ValidatorAddressCodec(), tx.DefaultSignModes)
+}
+
+var _ AppEntrypoint = SimDeliverFn(nil)
+
+type (
+	AppEntrypointFn = SimDeliverFn
+	SimDeliverFn    func(_txEncoder sdk.TxEncoder, tx sdk.Tx) (sdk.GasInfo, *sdk.Result, error)
+)
+
+func (m SimDeliverFn) SimDeliver(txEncoder sdk.TxEncoder, tx sdk.Tx) (sdk.GasInfo, *sdk.Result, error) {
+	return m(txEncoder, tx)
+}
+
+var _ AccountSource = AccountSourceFn(nil)
+
+type AccountSourceFn func(ctx context.Context, addr sdk.AccAddress) sdk.AccountI
+
+func (a AccountSourceFn) GetAccount(ctx context.Context, addr sdk.AccAddress) sdk.AccountI {
+	return a(ctx, addr)
+}
+
+var _ sdk.AccountI = &FakeAccountI{}
+
+type FakeAccountI struct {
+	SimAccount
+	id, seq uint64
+}
+
+func (m FakeAccountI) GetAddress() sdk.AccAddress {
+	return m.Address
+}
+
+func (m FakeAccountI) GetPubKey() cryptotypes.PubKey {
+	return m.PubKey
+}
+
+func (m FakeAccountI) GetAccountNumber() uint64 {
+	return m.id
+}
+
+func (m FakeAccountI) GetSequence() uint64 {
+	return m.seq
+}
+
+func (m FakeAccountI) Reset() {
+	panic("implement me")
+}
+
+func (m FakeAccountI) String() string {
+	panic("implement me")
+}
+
+func (m FakeAccountI) ProtoMessage() {
+	panic("implement me")
+}
+
+func (m FakeAccountI) SetAddress(address sdk.AccAddress) error {
+	panic("implement me")
+}
+
+func (m FakeAccountI) SetPubKey(key cryptotypes.PubKey) error {
+	panic("implement me")
+}
+
+func (m FakeAccountI) SetAccountNumber(u uint64) error {
+	panic("implement me")
+}
+
+func (m FakeAccountI) SetSequence(u uint64) error {
+	panic("implement me")
+}
+
+var _ AccountSourceX = &MockAccountSourceX{}
+
+// MockAccountSourceX mock impl for testing only
+type MockAccountSourceX struct {
+	GetAccountFn       func(ctx context.Context, addr sdk.AccAddress) sdk.AccountI
+	GetModuleAddressFn func(moduleName string) sdk.AccAddress
+}
+
+func (m MockAccountSourceX) GetAccount(ctx context.Context, addr sdk.AccAddress) sdk.AccountI {
+	if m.GetAccountFn == nil {
+		panic("not expected to be called")
+	}
+	return m.GetAccountFn(ctx, addr)
+}
+
+func (m MockAccountSourceX) GetModuleAddress(moduleName string) sdk.AccAddress {
+	if m.GetModuleAddressFn == nil {
+		panic("not expected to be called")
+	}
+	return m.GetModuleAddressFn(moduleName)
+}
+
+func must[T any](r T, err error) T {
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
diff --git a/simsx/delivery.go b/simsx/delivery.go
new file mode 100644
index 000000000000..5dc9bb95ae94
--- /dev/null
+++ b/simsx/delivery.go
@@ -0,0 +1,98 @@
+package simsx
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/rand"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+	"github.com/cosmos/cosmos-sdk/testutil/sims"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+)
+
+type (
+	// AppEntrypoint is an alias to the simtype interface
+	AppEntrypoint = simtypes.AppEntrypoint
+
+	AccountSource interface {
+		GetAccount(ctx context.Context, addr sdk.AccAddress) sdk.AccountI
+	}
+	// SimDeliveryResultHandler processes the delivery response error. Some sims are supposed to fail and expect an error.
+	// An unhandled error returned indicates a failure
+	SimDeliveryResultHandler func(error) error
+)
+
+// DeliverSimsMsg delivers a simulation message by creating and signing a mock transaction,
+// then delivering it to the application through the specified entrypoint. It returns a legacy
+// operation message representing the result of the delivery.
+//
+// The function takes the following parameters:
+// - reporter: SimulationReporter - Interface for reporting the result of the delivery
+// - r: *rand.Rand - Random number generator used for creating the mock transaction
+// - app: AppEntrypoint - Entry point for delivering the simulation transaction to the application
+// - txGen: client.TxConfig - Configuration for generating transactions
+// - ak: AccountSource - Source for retrieving accounts
+// - msg: sdk.Msg - The simulation message to be delivered
+// - ctx: sdk.Context - The simulation context
+// - chainID: string - The chain ID
+// - senders: ...SimAccount - Accounts from which to send the simulation message
+//
+// The function returns a simtypes.OperationMsg, which is a legacy representation of the result
+// of the delivery.
+func DeliverSimsMsg(
+	ctx sdk.Context,
+	reporter SimulationReporter,
+	app AppEntrypoint,
+	r *rand.Rand,
+	txGen client.TxConfig,
+	ak AccountSource,
+	chainID string,
+	msg sdk.Msg,
+	deliveryResultHandler SimDeliveryResultHandler,
+	senders ...SimAccount,
+) simtypes.OperationMsg {
+	if reporter.IsSkipped() {
+		return reporter.ToLegacyOperationMsg()
+	}
+	if len(senders) == 0 {
+		reporter.Fail(errors.New("no senders"), "encoding TX")
+		return reporter.ToLegacyOperationMsg()
+	}
+	accountNumbers := make([]uint64, len(senders))
+	sequenceNumbers := make([]uint64, len(senders))
+	for i := 0; i < len(senders); i++ {
+		acc := ak.GetAccount(ctx, senders[i].Address)
+		accountNumbers[i] = acc.GetAccountNumber()
+		sequenceNumbers[i] = acc.GetSequence()
+	}
+	fees := senders[0].LiquidBalance().RandFees()
+	tx, err := sims.GenSignedMockTx(
+		r,
+		txGen,
+		[]sdk.Msg{msg},
+		fees,
+		sims.DefaultGenTxGas,
+		chainID,
+		accountNumbers,
+		sequenceNumbers,
+		Collect(senders, func(a SimAccount) cryptotypes.PrivKey { return a.PrivKey })...,
+	)
+	if err != nil {
+		reporter.Fail(err, "encoding TX")
+		return reporter.ToLegacyOperationMsg()
+	}
+	_, _, err = app.SimDeliver(txGen.TxEncoder(), tx)
+	if err2 := deliveryResultHandler(err); err2 != nil {
+		var comment string
+		for _, msg := range tx.GetMsgs() {
+			comment += fmt.Sprintf("%#v", msg)
+		}
+		reporter.Fail(err2, fmt.Sprintf("delivering tx with msgs: %s", comment))
+		return reporter.ToLegacyOperationMsg()
+	}
+	reporter.Success(msg)
+	return reporter.ToLegacyOperationMsg()
+}
diff --git a/simsx/delivery_test.go b/simsx/delivery_test.go
new file mode 100644
index 000000000000..ea22ff872176
--- /dev/null
+++ b/simsx/delivery_test.go
@@ -0,0 +1,74 @@
+package simsx
+
+import (
+	"errors"
+	"math/rand"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+)
+
+func TestDeliverSimsMsg(t *testing.T) {
+	var (
+		sender   = SimAccountFixture()
+		ak       = MemoryAccountSource(sender)
+		myMsg    = testdata.NewTestMsg(sender.Address)
+		txConfig = txConfig()
+		r        = rand.New(rand.NewSource(1))
+		ctx      sdk.Context
+	)
+	noopResultHandler := func(err error) error { return err }
+	specs := map[string]struct {
+		app                      AppEntrypoint
+		reporter                 func() SimulationReporter
+		deliveryResultHandler    SimDeliveryResultHandler
+		errDeliveryResultHandler error
+		expOps                   simtypes.OperationMsg
+	}{
+		"error when reporter skipped": {
+			app: SimDeliverFn(func(_txEncoder sdk.TxEncoder, tx sdk.Tx) (sdk.GasInfo, *sdk.Result, error) {
+				return sdk.GasInfo{GasWanted: 100, GasUsed: 20}, &sdk.Result{}, nil
+			}),
+			reporter: func() SimulationReporter {
+				r := NewBasicSimulationReporter()
+				r.Skip("testing")
+				return r
+			},
+			expOps: simtypes.NoOpMsg("", "", "testing"),
+		},
+		"successful delivery": {
+			app: SimDeliverFn(func(_txEncoder sdk.TxEncoder, tx sdk.Tx) (sdk.GasInfo, *sdk.Result, error) {
+				return sdk.GasInfo{GasWanted: 100, GasUsed: 20}, &sdk.Result{}, nil
+			}),
+			reporter:              func() SimulationReporter { return NewBasicSimulationReporter() },
+			deliveryResultHandler: noopResultHandler,
+			expOps:                simtypes.NewOperationMsgBasic("", "", "", true, must(myMsg.Marshal())),
+		},
+		"error delivery": {
+			app: SimDeliverFn(func(_txEncoder sdk.TxEncoder, tx sdk.Tx) (sdk.GasInfo, *sdk.Result, error) {
+				return sdk.GasInfo{GasWanted: 100, GasUsed: 20}, &sdk.Result{}, errors.New("my error")
+			}),
+			reporter:              func() SimulationReporter { return NewBasicSimulationReporter() },
+			deliveryResultHandler: noopResultHandler,
+			expOps:                simtypes.NewOperationMsgBasic("", "", "delivering tx with msgs: &testdata.TestMsg{Signers:[]string{\"cosmos1tnh2q55v8wyygtt9srz5safamzdengsnqeycj3\"}}", false, nil),
+		},
+		"error delivery handled": {
+			app: SimDeliverFn(func(_txEncoder sdk.TxEncoder, tx sdk.Tx) (sdk.GasInfo, *sdk.Result, error) {
+				return sdk.GasInfo{GasWanted: 100, GasUsed: 20}, &sdk.Result{}, errors.New("my error")
+			}),
+			reporter:              func() SimulationReporter { return NewBasicSimulationReporter() },
+			deliveryResultHandler: func(err error) error { return nil },
+			expOps:                simtypes.NewOperationMsgBasic("", "", "", true, must(myMsg.Marshal())),
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			got := DeliverSimsMsg(ctx, spec.reporter(), spec.app, r, txConfig, ak, "testing", myMsg, spec.deliveryResultHandler, sender)
+			assert.Equal(t, spec.expOps, got)
+		})
+	}
+}
diff --git a/simsx/environment.go b/simsx/environment.go
new file mode 100644
index 000000000000..1c7f27ccc193
--- /dev/null
+++ b/simsx/environment.go
@@ -0,0 +1,455 @@
+package simsx
+
+import (
+	"context"
+	"errors"
+	"math/rand"
+	"slices"
+	"time"
+
+	"cosmossdk.io/core/address"
+	"cosmossdk.io/math"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+)
+
+// helper type for simple bank access
+type contextAwareBalanceSource struct {
+	ctx  context.Context
+	bank BalanceSource
+}
+
+func (s contextAwareBalanceSource) SpendableCoins(accAddress sdk.AccAddress) sdk.Coins {
+	return s.bank.SpendableCoins(s.ctx, accAddress)
+}
+
+func (s contextAwareBalanceSource) IsSendEnabledDenom(denom string) bool {
+	return s.bank.IsSendEnabledDenom(s.ctx, denom)
+}
+
+// SimAccount is an extended simtypes.Account
+type SimAccount struct {
+	simtypes.Account
+	r             *rand.Rand
+	liquidBalance *SimsAccountBalance
+	bank          contextAwareBalanceSource
+}
+
+// LiquidBalance spendable balance. This excludes not spendable amounts like staked or vested amounts.
+func (a *SimAccount) LiquidBalance() *SimsAccountBalance {
+	if a.liquidBalance == nil {
+		a.liquidBalance = NewSimsAccountBalance(a, a.r, a.bank.SpendableCoins(a.Address))
+	}
+	return a.liquidBalance
+}
+
+// SimsAccountBalance is a helper type for common access methods to balance amounts.
+type SimsAccountBalance struct {
+	sdk.Coins
+	owner *SimAccount
+	r     *rand.Rand
+}
+
+// NewSimsAccountBalance constructor
+func NewSimsAccountBalance(o *SimAccount, r *rand.Rand, coins sdk.Coins) *SimsAccountBalance {
+	return &SimsAccountBalance{Coins: coins, r: r, owner: o}
+}
+
+type CoinsFilter interface {
+	Accept(c sdk.Coins) bool // returns false to reject
+}
+type CoinsFilterFn func(c sdk.Coins) bool
+
+func (f CoinsFilterFn) Accept(c sdk.Coins) bool {
+	return f(c)
+}
+
+func WithSendEnabledCoins() CoinsFilter {
+	return statefulCoinsFilterFn(func(s *SimAccount, coins sdk.Coins) bool {
+		for _, coin := range coins {
+			if !s.bank.IsSendEnabledDenom(coin.Denom) {
+				return false
+			}
+		}
+		return true
+	})
+}
+
+// filter with context of SimAccount
+type statefulCoinsFilter struct {
+	s  *SimAccount
+	do func(s *SimAccount, c sdk.Coins) bool
+}
+
+// constructor
+func statefulCoinsFilterFn(f func(s *SimAccount, c sdk.Coins) bool) CoinsFilter {
+	return &statefulCoinsFilter{do: f}
+}
+
+func (f statefulCoinsFilter) Accept(c sdk.Coins) bool {
+	if f.s == nil {
+		panic("account not set")
+	}
+	return f.do(f.s, c)
+}
+
+func (f *statefulCoinsFilter) visit(s *SimAccount) {
+	f.s = s
+}
+
+var _ visitable = &statefulCoinsFilter{}
+
+type visitable interface {
+	visit(s *SimAccount)
+}
+
+// RandSubsetCoins return random amounts from the current balance. When the coins are empty, skip is called on the reporter.
+// The amounts are removed from the liquid balance.
+func (b *SimsAccountBalance) RandSubsetCoins(reporter SimulationReporter, filters ...CoinsFilter) sdk.Coins {
+	amount := b.randomAmount(5, reporter, b.Coins, filters...)
+	b.Coins = b.Coins.Sub(amount...)
+	if amount.Empty() {
+		reporter.Skip("got empty amounts")
+	}
+	return amount
+}
+
+// RandSubsetCoin return random amount from the current balance. When the coins are empty, skip is called on the reporter.
+// The amount is removed from the liquid balance.
+func (b *SimsAccountBalance) RandSubsetCoin(reporter SimulationReporter, denom string, filters ...CoinsFilter) sdk.Coin {
+	ok, coin := b.Find(denom)
+	if !ok {
+		reporter.Skipf("no such coin: %s", denom)
+		return sdk.NewCoin(denom, math.ZeroInt())
+	}
+	amounts := b.randomAmount(5, reporter, sdk.Coins{coin}, filters...)
+	if amounts.Empty() {
+		reporter.Skip("empty coin")
+		return sdk.NewCoin(denom, math.ZeroInt())
+	}
+	b.BlockAmount(amounts[0])
+	return amounts[0]
+}
+
+// BlockAmount returns true when balance is > requested amount and subtracts the amount from the liquid balance
+func (b *SimsAccountBalance) BlockAmount(amount sdk.Coin) bool {
+	ok, coin := b.Coins.Find(amount.Denom)
+	if !ok || !coin.IsPositive() || !coin.IsGTE(amount) {
+		return false
+	}
+	b.Coins = b.Coins.Sub(amount)
+	return true
+}
+
+func (b *SimsAccountBalance) randomAmount(retryCount int, reporter SimulationReporter, coins sdk.Coins, filters ...CoinsFilter) sdk.Coins {
+	if retryCount < 0 || b.Coins.Empty() {
+		reporter.Skip("failed to find matching amount")
+		return sdk.Coins{}
+	}
+	amount := simtypes.RandSubsetCoins(b.r, coins)
+	for _, filter := range filters {
+		if f, ok := filter.(visitable); ok {
+			f.visit(b.owner)
+		}
+		if !filter.Accept(amount) {
+			return b.randomAmount(retryCount-1, reporter, coins, filters...)
+		}
+	}
+	return amount
+}
+
+func (b *SimsAccountBalance) RandFees() sdk.Coins {
+	amount, err := simtypes.RandomFees(b.r, b.Coins)
+	if err != nil {
+		return sdk.Coins{}
+	}
+	return amount
+}
+
+type SimAccountFilter interface {
+	// Accept returns true to accept the account or false to reject
+	Accept(a SimAccount) bool
+}
+type SimAccountFilterFn func(a SimAccount) bool
+
+func (s SimAccountFilterFn) Accept(a SimAccount) bool {
+	return s(a)
+}
+
+func ExcludeAccounts(others ...SimAccount) SimAccountFilter {
+	return SimAccountFilterFn(func(a SimAccount) bool {
+		return !slices.ContainsFunc(others, func(o SimAccount) bool {
+			return a.Address.Equals(o.Address)
+		})
+	})
+}
+
+// UniqueAccounts returns a stateful filter that rejects duplicate accounts.
+// It uses a map to keep track of accounts that have been processed.
+// If an account exists in the map, the filter function returns false
+// to reject a duplicate, else it adds the account to the map and returns true.
+//
+// Example usage:
+//
+//	uniqueAccountsFilter := simsx.UniqueAccounts()
+//
+//	for {
+//	    from := testData.AnyAccount(reporter, uniqueAccountsFilter)
+//	    //... rest of the loop
+//	}
+func UniqueAccounts() SimAccountFilter {
+	idx := make(map[string]struct{})
+	return SimAccountFilterFn(func(a SimAccount) bool {
+		if _, ok := idx[a.AddressBech32]; ok {
+			return false
+		}
+		idx[a.AddressBech32] = struct{}{}
+		return true
+	})
+}
+
+func ExcludeAddresses(addrs ...string) SimAccountFilter {
+	return SimAccountFilterFn(func(a SimAccount) bool {
+		return !slices.Contains(addrs, a.AddressBech32)
+	})
+}
+
+func WithDenomBalance(denom string) SimAccountFilter {
+	return SimAccountFilterFn(func(a SimAccount) bool {
+		return a.LiquidBalance().AmountOf(denom).IsPositive()
+	})
+}
+
+func WithLiquidBalanceGTE(amount ...sdk.Coin) SimAccountFilter {
+	return SimAccountFilterFn(func(a SimAccount) bool {
+		return a.LiquidBalance().IsAllGTE(amount)
+	})
+}
+
+// WithSpendableBalance Filters for liquid token but send may not be enabled for all or any
+func WithSpendableBalance() SimAccountFilter {
+	return SimAccountFilterFn(func(a SimAccount) bool {
+		return !a.LiquidBalance().Empty()
+	})
+}
+
+type ModuleAccountSource interface {
+	GetModuleAddress(moduleName string) sdk.AccAddress
+}
+type BalanceSource interface {
+	SpendableCoins(ctx context.Context, addr sdk.AccAddress) sdk.Coins
+	IsSendEnabledDenom(ctx context.Context, denom string) bool
+}
+
+type ChainDataSource struct {
+	r                         *rand.Rand
+	addressToAccountsPosIndex map[string]int
+	accounts                  []SimAccount
+	accountSource             ModuleAccountSource
+	addressCodec              address.Codec
+	bank                      contextAwareBalanceSource
+}
+
+// NewChainDataSource constructor
+func NewChainDataSource(
+	ctx context.Context,
+	r *rand.Rand,
+	ak ModuleAccountSource,
+	bk BalanceSource,
+	codec address.Codec,
+	oldSimAcc ...simtypes.Account,
+) *ChainDataSource {
+	acc := make([]SimAccount, len(oldSimAcc))
+	index := make(map[string]int, len(oldSimAcc))
+	bank := contextAwareBalanceSource{ctx: ctx, bank: bk}
+	for i, a := range oldSimAcc {
+		acc[i] = SimAccount{Account: a, r: r, bank: bank}
+		index[a.AddressBech32] = i
+	}
+	return &ChainDataSource{
+		r:                         r,
+		accountSource:             ak,
+		addressCodec:              codec,
+		accounts:                  acc,
+		bank:                      bank,
+		addressToAccountsPosIndex: index,
+	}
+}
+
+// AnyAccount returns a random SimAccount matching the filter criteria. Module accounts are excluded.
+// In case of an error or no matching account found, the reporter is set to skip and an empty value is returned.
+func (c *ChainDataSource) AnyAccount(r SimulationReporter, filters ...SimAccountFilter) SimAccount {
+	acc := c.randomAccount(r, 5, filters...)
+	return acc
+}
+
+// GetAccountbyAccAddr return SimAccount with given binary address. Reporter skip flag is set when not found.
+func (c ChainDataSource) GetAccountbyAccAddr(reporter SimulationReporter, addr sdk.AccAddress) SimAccount {
+	if len(addr) == 0 {
+		reporter.Skip("can not find account for empty address")
+		return c.nullAccount()
+	}
+	addrStr, err := c.addressCodec.BytesToString(addr)
+	if err != nil {
+		reporter.Skipf("can not convert account address to string: %s", err)
+		return c.nullAccount()
+	}
+	return c.GetAccount(reporter, addrStr)
+}
+
+func (c ChainDataSource) HasAccount(addr string) bool {
+	_, ok := c.addressToAccountsPosIndex[addr]
+	return ok
+}
+
+// GetAccount return SimAccount with given bench32 address. Reporter skip flag is set when not found.
+func (c ChainDataSource) GetAccount(reporter SimulationReporter, addr string) SimAccount {
+	pos, ok := c.addressToAccountsPosIndex[addr]
+	if !ok {
+		reporter.Skipf("no account: %s", addr)
+		return c.nullAccount()
+	}
+	return c.accounts[pos]
+}
+
+func (c *ChainDataSource) randomAccount(reporter SimulationReporter, retryCount int, filters ...SimAccountFilter) SimAccount {
+	if retryCount < 0 {
+		reporter.Skip("failed to find a matching account")
+		return c.nullAccount()
+	}
+	idx := c.r.Intn(len(c.accounts))
+	acc := c.accounts[idx]
+	for _, filter := range filters {
+		if !filter.Accept(acc) {
+			return c.randomAccount(reporter, retryCount-1, filters...)
+		}
+	}
+	return acc
+}
+
+// create null object
+func (c ChainDataSource) nullAccount() SimAccount {
+	return SimAccount{
+		Account:       simtypes.Account{},
+		r:             c.r,
+		liquidBalance: &SimsAccountBalance{},
+		bank:          c.accounts[0].bank,
+	}
+}
+
+func (c *ChainDataSource) ModuleAccountAddress(reporter SimulationReporter, moduleName string) string {
+	acc := c.accountSource.GetModuleAddress(moduleName)
+	if acc == nil {
+		reporter.Skipf("unknown module account: %s", moduleName)
+		return ""
+	}
+	res, err := c.addressCodec.BytesToString(acc)
+	if err != nil {
+		reporter.Skipf("failed to encode module address: %s", err)
+		return ""
+	}
+	return res
+}
+
+func (c *ChainDataSource) AddressCodec() address.Codec {
+	return c.addressCodec
+}
+
+func (c *ChainDataSource) Rand() *XRand {
+	return &XRand{c.r}
+}
+
+func (c *ChainDataSource) IsSendEnabledDenom(denom string) bool {
+	return c.bank.IsSendEnabledDenom(denom)
+}
+
+// AllAccounts returns all accounts in legacy format
+func (c *ChainDataSource) AllAccounts() []simtypes.Account {
+	return Collect(c.accounts, func(a SimAccount) simtypes.Account { return a.Account })
+}
+
+func (c *ChainDataSource) AccountsCount() int {
+	return len(c.accounts)
+}
+
+// AccountAt return SimAccount within the accounts slice. Reporter skip flag is set when boundaries are exceeded.
+
+func (c *ChainDataSource) AccountAt(reporter SimulationReporter, i int) SimAccount {
+	if i > len(c.accounts) {
+		reporter.Skipf("account index out of range: %d", i)
+		return c.nullAccount()
+	}
+	return c.accounts[i]
+}
+
+type XRand struct {
+	*rand.Rand
+}
+
+// NewXRand constructor
+func NewXRand(rand *rand.Rand) *XRand {
+	return &XRand{Rand: rand}
+}
+
+func (r *XRand) StringN(max int) string {
+	return simtypes.RandStringOfLength(r.Rand, max)
+}
+
+func (r *XRand) SubsetCoins(src sdk.Coins) sdk.Coins {
+	return simtypes.RandSubsetCoins(r.Rand, src)
+}
+
+// Coin return one coin from the list
+func (r *XRand) Coin(src sdk.Coins) sdk.Coin {
+	return src[r.Intn(len(src))]
+}
+
+func (r *XRand) DecN(max math.LegacyDec) math.LegacyDec {
+	return simtypes.RandomDecAmount(r.Rand, max)
+}
+
+func (r *XRand) IntInRange(min, max int) int {
+	return r.Rand.Intn(max-min) + min
+}
+
+// Uint64InRange returns a pseudo-random uint64 number in the range [min, max].
+// It panics when min >= max
+func (r *XRand) Uint64InRange(min, max uint64) uint64 {
+	return uint64(r.Rand.Int63n(int64(max-min)) + int64(min))
+}
+
+// Uint32InRange returns a pseudo-random uint32 number in the range [min, max].
+// It panics when min >= max
+func (r *XRand) Uint32InRange(min, max uint32) uint32 {
+	return uint32(r.Rand.Intn(int(max-min))) + min
+}
+
+func (r *XRand) PositiveSDKIntn(max math.Int) (math.Int, error) {
+	return simtypes.RandPositiveInt(r.Rand, max)
+}
+
+func (r *XRand) PositiveSDKIntInRange(min, max math.Int) (math.Int, error) {
+	diff := max.Sub(min)
+	if !diff.IsPositive() {
+		return math.Int{}, errors.New("min value must not be greater or equal to max")
+	}
+	result, err := r.PositiveSDKIntn(diff)
+	if err != nil {
+		return math.Int{}, err
+	}
+	return result.Add(min), nil
+}
+
+// Timestamp returns a timestamp between  Jan 1, 2062 and Jan 1, 2262
+func (r *XRand) Timestamp() time.Time {
+	return simtypes.RandTimestamp(r.Rand)
+}
+
+func (r *XRand) Bool() bool {
+	return r.Intn(100) > 50
+}
+
+func (r *XRand) Amount(balance math.Int) math.Int {
+	return simtypes.RandomAmount(r.Rand, balance)
+}
diff --git a/simsx/environment_test.go b/simsx/environment_test.go
new file mode 100644
index 000000000000..957601326b23
--- /dev/null
+++ b/simsx/environment_test.go
@@ -0,0 +1,67 @@
+package simsx
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+)
+
+func TestChainDataSourceAnyAccount(t *testing.T) {
+	codec := txConfig().SigningContext().AddressCodec()
+	r := rand.New(rand.NewSource(1))
+	accs := simtypes.RandomAccounts(r, 3)
+	specs := map[string]struct {
+		filters []SimAccountFilter
+		assert  func(t *testing.T, got SimAccount, reporter SimulationReporter)
+	}{
+		"no filters": {
+			assert: func(t *testing.T, got SimAccount, reporter SimulationReporter) { //nolint:thelper // not a helper
+				assert.NotEmpty(t, got.AddressBech32)
+				assert.False(t, reporter.IsSkipped())
+			},
+		},
+		"filter": {
+			filters: []SimAccountFilter{SimAccountFilterFn(func(a SimAccount) bool { return a.AddressBech32 == accs[2].AddressBech32 })},
+			assert: func(t *testing.T, got SimAccount, reporter SimulationReporter) { //nolint:thelper // not a helper
+				assert.Equal(t, accs[2].AddressBech32, got.AddressBech32)
+				assert.False(t, reporter.IsSkipped())
+			},
+		},
+		"no match": {
+			filters: []SimAccountFilter{SimAccountFilterFn(func(a SimAccount) bool { return false })},
+			assert: func(t *testing.T, got SimAccount, reporter SimulationReporter) { //nolint:thelper // not a helper
+				assert.Empty(t, got.AddressBech32)
+				assert.True(t, reporter.IsSkipped())
+			},
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			reporter := NewBasicSimulationReporter()
+			c := NewChainDataSource(sdk.Context{}, r, nil, nil, codec, accs...)
+			a := c.AnyAccount(reporter, spec.filters...)
+			spec.assert(t, a, reporter)
+		})
+	}
+}
+
+func TestChainDataSourceGetHasAccount(t *testing.T) {
+	codec := txConfig().SigningContext().AddressCodec()
+	r := rand.New(rand.NewSource(1))
+	accs := simtypes.RandomAccounts(r, 3)
+	reporter := NewBasicSimulationReporter()
+	c := NewChainDataSource(sdk.Context{}, r, nil, nil, codec, accs...)
+	exisingAddr := accs[0].AddressBech32
+	assert.Equal(t, exisingAddr, c.GetAccount(reporter, exisingAddr).AddressBech32)
+	assert.False(t, reporter.IsSkipped())
+	assert.True(t, c.HasAccount(exisingAddr))
+	// and non-existing account
+	reporter = NewBasicSimulationReporter()
+	assert.Empty(t, c.GetAccount(reporter, "non-existing").AddressBech32)
+	assert.False(t, c.HasAccount("non-existing"))
+	assert.True(t, reporter.IsSkipped())
+}
diff --git a/simsx/msg_factory.go b/simsx/msg_factory.go
new file mode 100644
index 000000000000..82054539f664
--- /dev/null
+++ b/simsx/msg_factory.go
@@ -0,0 +1,112 @@
+package simsx
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type SimMsgFactoryX interface {
+	MsgType() sdk.Msg
+	Create() FactoryMethod
+	DeliveryResultHandler() SimDeliveryResultHandler
+}
+type (
+	// FactoryMethod method signature that is implemented by the concrete message factories
+	FactoryMethod func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg sdk.Msg)
+
+	// FactoryMethodWithFutureOps extended message factory method for the gov module or others that have to schedule operations for a future block.
+	FactoryMethodWithFutureOps[T sdk.Msg] func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter, fOpsReg FutureOpsRegistry) ([]SimAccount, T)
+
+	// FactoryMethodWithDeliveryResultHandler extended factory method that can return a result handler, that is executed on the delivery tx error result.
+	// This is used in staking for example to validate negative execution results.
+	FactoryMethodWithDeliveryResultHandler[T sdk.Msg] func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg T, handler SimDeliveryResultHandler)
+)
+
+var _ SimMsgFactoryX = &ResultHandlingSimMsgFactory[sdk.Msg]{}
+
+// ResultHandlingSimMsgFactory message factory with a delivery error result handler configured.
+type ResultHandlingSimMsgFactory[T sdk.Msg] struct {
+	SimMsgFactoryFn[T]
+	resultHandler SimDeliveryResultHandler
+}
+
+// NewSimMsgFactoryWithDeliveryResultHandler constructor
+func NewSimMsgFactoryWithDeliveryResultHandler[T sdk.Msg](f FactoryMethodWithDeliveryResultHandler[T]) *ResultHandlingSimMsgFactory[T] {
+	// the result handler is always called after the factory. so we initialize it lazy for syntactic sugar and simplicity
+	// in the message factory function that is implemented by the users
+	var lazyResultHandler SimDeliveryResultHandler
+	r := &ResultHandlingSimMsgFactory[T]{
+		resultHandler: func(err error) error {
+			return lazyResultHandler(err)
+		},
+	}
+	r.SimMsgFactoryFn = func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg T) {
+		signer, msg, lazyResultHandler = f(ctx, testData, reporter)
+		if lazyResultHandler == nil {
+			lazyResultHandler = expectNoError
+		}
+		return
+	}
+	return r
+}
+
+func (f ResultHandlingSimMsgFactory[T]) DeliveryResultHandler() SimDeliveryResultHandler {
+	return f.resultHandler
+}
+
+var (
+	_ SimMsgFactoryX       = &LazyStateSimMsgFactory[sdk.Msg]{}
+	_ hasFutureOpsRegistry = &LazyStateSimMsgFactory[sdk.Msg]{}
+)
+
+// LazyStateSimMsgFactory stateful message factory with weighted proposals and future operation
+// registry initialized lazy before execution.
+type LazyStateSimMsgFactory[T sdk.Msg] struct {
+	SimMsgFactoryFn[T]
+	fsOpsReg FutureOpsRegistry
+}
+
+func NewSimMsgFactoryWithFutureOps[T sdk.Msg](f FactoryMethodWithFutureOps[T]) *LazyStateSimMsgFactory[T] {
+	r := &LazyStateSimMsgFactory[T]{}
+	r.SimMsgFactoryFn = func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg T) {
+		signer, msg = f(ctx, testData, reporter, r.fsOpsReg)
+		return
+	}
+	return r
+}
+
+func (c *LazyStateSimMsgFactory[T]) SetFutureOpsRegistry(registry FutureOpsRegistry) {
+	c.fsOpsReg = registry
+}
+
+// pass errors through and don't handle them
+func expectNoError(err error) error {
+	return err
+}
+
+var _ SimMsgFactoryX = SimMsgFactoryFn[sdk.Msg](nil)
+
+// SimMsgFactoryFn is the default factory for most cases. It does not create future operations but ensures successful message delivery.
+type SimMsgFactoryFn[T sdk.Msg] func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg T)
+
+// MsgType returns an empty instance of type T, which implements `sdk.Msg`.
+func (f SimMsgFactoryFn[T]) MsgType() sdk.Msg {
+	var x T
+	return x
+}
+
+func (f SimMsgFactoryFn[T]) Create() FactoryMethod {
+	// adapter to return sdk.Msg instead of typed result to match FactoryMethod signature
+	return func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) ([]SimAccount, sdk.Msg) {
+		return f(ctx, testData, reporter)
+	}
+}
+
+func (f SimMsgFactoryFn[T]) DeliveryResultHandler() SimDeliveryResultHandler {
+	return expectNoError
+}
+
+func (f SimMsgFactoryFn[T]) Cast(msg sdk.Msg) T {
+	return msg.(T)
+}
diff --git a/simsx/msg_factory_test.go b/simsx/msg_factory_test.go
new file mode 100644
index 000000000000..01826cf474cc
--- /dev/null
+++ b/simsx/msg_factory_test.go
@@ -0,0 +1,53 @@
+package simsx
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+)
+
+func TestMsgFactories(t *testing.T) {
+	myMsg := testdata.NewTestMsg()
+	mySigners := []SimAccount{{}}
+	specs := map[string]struct {
+		src           SimMsgFactoryX
+		expErrHandled bool
+	}{
+		"default": {
+			src: SimMsgFactoryFn[*testdata.TestMsg](func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg *testdata.TestMsg) {
+				return mySigners, myMsg
+			}),
+		},
+		"with delivery result handler": {
+			src: NewSimMsgFactoryWithDeliveryResultHandler[*testdata.TestMsg](func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg *testdata.TestMsg, handler SimDeliveryResultHandler) {
+				return mySigners, myMsg, func(err error) error { return nil }
+			}),
+			expErrHandled: true,
+		},
+		"with future ops": {
+			src: NewSimMsgFactoryWithFutureOps[*testdata.TestMsg](func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter, fOpsReg FutureOpsRegistry) ([]SimAccount, *testdata.TestMsg) {
+				return mySigners, myMsg
+			}),
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			assert.Equal(t, (*testdata.TestMsg)(nil), spec.src.MsgType())
+
+			factoryMethod := spec.src.Create()
+			require.NotNil(t, factoryMethod)
+			gotSigners, gotMsg := factoryMethod(context.Background(), nil, nil)
+			assert.Equal(t, mySigners, gotSigners)
+			assert.Equal(t, gotMsg, myMsg)
+
+			require.NotNil(t, spec.src.DeliveryResultHandler())
+			gotErr := spec.src.DeliveryResultHandler()(errors.New("testing"))
+			assert.Equal(t, spec.expErrHandled, gotErr == nil)
+		})
+	}
+}
diff --git a/simsx/params.go b/simsx/params.go
new file mode 100644
index 000000000000..7acd6edcf84f
--- /dev/null
+++ b/simsx/params.go
@@ -0,0 +1,52 @@
+package simsx
+
+import (
+	"math/rand"
+
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+)
+
+// WeightSource interface for retrieving weights based on a name and a default value.
+type WeightSource interface {
+	Get(name string, defaultValue uint32) uint32
+}
+
+// WeightSourceFn function adapter that implements WeightSource.
+// Example:
+//
+//	weightSource := WeightSourceFn(func(name string, defaultValue uint32) uint32 {
+//	  // implementation code...
+//	})
+type WeightSourceFn func(name string, defaultValue uint32) uint32
+
+func (f WeightSourceFn) Get(name string, defaultValue uint32) uint32 {
+	return f(name, defaultValue)
+}
+
+// ParamWeightSource is an adapter to the simtypes.AppParams object. This function returns a WeightSource
+// implementation that retrieves weights
+// based on a name and a default value. The implementation uses the provided AppParams
+// to get or generate the weight value. If the weight value exists in the AppParams,
+// it is decoded and returned. Otherwise, the provided ParamSimulator is used to generate
+// a random value or default value.
+//
+// The WeightSource implementation is a WeightSourceFn function adapter that implements
+// the WeightSource interface. It takes in a name string and a defaultValue uint32 as
+// parameters and returns the weight value as a uint32.
+//
+// Example Usage:
+//
+//	appParams := simtypes.AppParams{}
+//	// add parameters to appParams
+//
+//	weightSource := ParamWeightSource(appParams)
+//	weightSource.Get("some_weight", 100)
+func ParamWeightSource(p simtypes.AppParams) WeightSource {
+	return WeightSourceFn(func(name string, defaultValue uint32) uint32 {
+		var result uint32
+		p.GetOrGenerate("op_weight_"+name, &result, nil, func(_ *rand.Rand) {
+			result = defaultValue
+		})
+		return result
+	})
+}
diff --git a/simsx/registry.go b/simsx/registry.go
new file mode 100644
index 000000000000..b44152cf13f1
--- /dev/null
+++ b/simsx/registry.go
@@ -0,0 +1,227 @@
+package simsx
+
+import (
+	"context"
+	"math/rand"
+	"time"
+
+	"cosmossdk.io/core/address"
+	"cosmossdk.io/core/log"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+	"github.com/cosmos/cosmos-sdk/x/simulation"
+)
+
+// Registry is an abstract entry point to register message factories with weights
+type Registry interface {
+	Add(weight uint32, f SimMsgFactoryX)
+}
+type FutureOpsRegistry interface {
+	Add(blockTime time.Time, f SimMsgFactoryX)
+}
+type AccountSourceX interface {
+	AccountSource
+	ModuleAccountSource
+}
+
+var (
+	_ Registry = &WeightedOperationRegistryAdapter{}
+	_ Registry = &SimsProposalRegistryAdapter{}
+)
+
+// common types for abstract registry without generics
+type regCommon struct {
+	reporter     SimulationReporter
+	ak           AccountSourceX
+	bk           BalanceSource
+	addressCodec address.Codec
+	txConfig     client.TxConfig
+	logger       log.Logger
+}
+
+func (c regCommon) newChainDataSource(ctx context.Context, r *rand.Rand, accs ...simtypes.Account) *ChainDataSource {
+	return NewChainDataSource(ctx, r, c.ak, c.bk, c.addressCodec, accs...)
+}
+
+type AbstractRegistry[T any] struct {
+	regCommon
+	legacyObjs []T
+}
+
+// ToLegacyObjects returns the legacy properties of the SimsRegistryAdapter as a slice of type T.
+func (l *AbstractRegistry[T]) ToLegacyObjects() []T {
+	return l.legacyObjs
+}
+
+// WeightedOperationRegistryAdapter is an implementation of the Registry interface that provides adapters to use the new message factories
+// with the legacy simulation system
+type WeightedOperationRegistryAdapter struct {
+	AbstractRegistry[simtypes.WeightedOperation]
+}
+
+// NewSimsMsgRegistryAdapter creates a new instance of SimsRegistryAdapter for WeightedOperation types.
+func NewSimsMsgRegistryAdapter(
+	reporter SimulationReporter,
+	ak AccountSourceX,
+	bk BalanceSource,
+	txConfig client.TxConfig,
+	logger log.Logger,
+) *WeightedOperationRegistryAdapter {
+	return &WeightedOperationRegistryAdapter{
+		AbstractRegistry: AbstractRegistry[simtypes.WeightedOperation]{
+			regCommon: regCommon{
+				reporter:     reporter,
+				ak:           ak,
+				bk:           bk,
+				txConfig:     txConfig,
+				addressCodec: txConfig.SigningContext().AddressCodec(),
+				logger:       logger,
+			},
+		},
+	}
+}
+
+// Add adds a new weighted operation to the collection
+func (l *WeightedOperationRegistryAdapter) Add(weight uint32, fx SimMsgFactoryX) {
+	if fx == nil {
+		panic("message factory must not be nil")
+	}
+	if weight == 0 {
+		return
+	}
+	obj := simulation.NewWeightedOperation(int(weight), legacyOperationAdapter(l.regCommon, fx))
+	l.legacyObjs = append(l.legacyObjs, obj)
+}
+
+type hasFutureOpsRegistry interface {
+	SetFutureOpsRegistry(FutureOpsRegistry)
+}
+
+func legacyOperationAdapter(l regCommon, fx SimMsgFactoryX) simtypes.Operation {
+	return func(
+		r *rand.Rand, app AppEntrypoint, ctx sdk.Context,
+		accs []simtypes.Account, chainID string,
+	) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
+		xCtx, done := context.WithCancel(ctx)
+		ctx = sdk.UnwrapSDKContext(xCtx)
+		testData := l.newChainDataSource(ctx, r, accs...)
+		reporter := l.reporter.WithScope(fx.MsgType(), SkipHookFn(func(args ...any) { done() }))
+		fOpsReg := newFutureOpsRegistry(l)
+		if fx, ok := fx.(hasFutureOpsRegistry); ok {
+			fx.SetFutureOpsRegistry(fOpsReg)
+		}
+		from, msg := runWithFailFast(ctx, testData, reporter, fx.Create())
+		futOps := fOpsReg.legacyObjs
+		weightedOpsResult := DeliverSimsMsg(ctx, reporter, app, r, l.txConfig, l.ak, chainID, msg, fx.DeliveryResultHandler(), from...)
+		err := reporter.Close()
+		return weightedOpsResult, futOps, err
+	}
+}
+
+func newFutureOpsRegistry(l regCommon) *FutureOperationRegistryAdapter {
+	return &FutureOperationRegistryAdapter{regCommon: l}
+}
+
+type FutureOperationRegistryAdapter AbstractRegistry[simtypes.FutureOperation]
+
+func (l *FutureOperationRegistryAdapter) Add(blockTime time.Time, fx SimMsgFactoryX) {
+	if fx == nil {
+		panic("message factory must not be nil")
+	}
+	if blockTime.IsZero() {
+		return
+	}
+	obj := simtypes.FutureOperation{
+		BlockTime: blockTime,
+		Op:        legacyOperationAdapter(l.regCommon, fx),
+	}
+	l.legacyObjs = append(l.legacyObjs, obj)
+}
+
+type SimsProposalRegistryAdapter struct {
+	AbstractRegistry[simtypes.WeightedProposalMsg]
+}
+
+// NewSimsProposalRegistryAdapter creates a new instance of SimsRegistryAdapter for WeightedProposalMsg types.
+func NewSimsProposalRegistryAdapter(
+	reporter SimulationReporter,
+	ak AccountSourceX,
+	bk BalanceSource,
+	addrCodec address.Codec,
+	logger log.Logger,
+) *SimsProposalRegistryAdapter {
+	return &SimsProposalRegistryAdapter{
+		AbstractRegistry: AbstractRegistry[simtypes.WeightedProposalMsg]{
+			regCommon: regCommon{
+				reporter:     reporter,
+				ak:           ak,
+				bk:           bk,
+				addressCodec: addrCodec,
+				logger:       logger,
+			},
+		},
+	}
+}
+
+func (l *SimsProposalRegistryAdapter) Add(weight uint32, fx SimMsgFactoryX) {
+	if fx == nil {
+		panic("message factory must not be nil")
+	}
+	if weight == 0 {
+		return
+	}
+	l.legacyObjs = append(l.legacyObjs, legacyProposalMsgAdapter(l.regCommon, weight, fx))
+}
+
+// legacyProposalMsgAdapter adapter to convert the new msg factory into the weighted proposal message type
+func legacyProposalMsgAdapter(l regCommon, weight uint32, fx SimMsgFactoryX) simtypes.WeightedProposalMsg {
+	msgAdapter := func(ctx context.Context, r *rand.Rand, accs []simtypes.Account, cdc address.Codec) (sdk.Msg, error) {
+		xCtx, done := context.WithCancel(ctx)
+		testData := l.newChainDataSource(xCtx, r, accs...)
+		reporter := l.reporter.WithScope(fx.MsgType(), SkipHookFn(func(args ...any) { done() }))
+		_, msg := runWithFailFast(xCtx, testData, reporter, fx.Create())
+		return msg, reporter.Close()
+	}
+	return simulation.NewWeightedProposalMsgX("", int(weight), msgAdapter)
+}
+
+type tuple struct {
+	signer []SimAccount
+	msg    sdk.Msg
+}
+
+// runWithFailFast runs the factory method on a separate goroutine to abort early when the context is canceled via reporter skip
+func runWithFailFast(
+	ctx context.Context,
+	data *ChainDataSource,
+	reporter SimulationReporter,
+	f FactoryMethod,
+) (signer []SimAccount, msg sdk.Msg) {
+	r := make(chan tuple)
+	go func() {
+		defer recoverPanicForSkipped(reporter, r)
+		signer, msg := f(ctx, data, reporter)
+		r <- tuple{signer: signer, msg: msg}
+	}()
+	select {
+	case t, ok := <-r:
+		if !ok {
+			return nil, nil
+		}
+		return t.signer, t.msg
+	case <-ctx.Done():
+		reporter.Skip("context closed")
+		return nil, nil
+	}
+}
+
+func recoverPanicForSkipped(reporter SimulationReporter, resultChan chan tuple) {
+	if r := recover(); r != nil {
+		if !reporter.IsSkipped() {
+			panic(r)
+		}
+		close(resultChan)
+	}
+}
diff --git a/simsx/registry_test.go b/simsx/registry_test.go
new file mode 100644
index 000000000000..a3da6ac357d1
--- /dev/null
+++ b/simsx/registry_test.go
@@ -0,0 +1,215 @@
+package simsx
+
+import (
+	"context"
+	"errors"
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"cosmossdk.io/log"
+
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+)
+
+func TestSimsMsgRegistryAdapter(t *testing.T) {
+	senderAcc := SimAccountFixture()
+	accs := []simtypes.Account{senderAcc.Account}
+	ak := MockAccountSourceX{GetAccountFn: MemoryAccountSource(senderAcc).GetAccount}
+	myMsg := testdata.NewTestMsg(senderAcc.Address)
+	ctx := sdk.Context{}.WithContext(context.Background())
+	futureTime := time.Now().Add(time.Second)
+
+	specs := map[string]struct {
+		factory           SimMsgFactoryX
+		expFactoryMsg     sdk.Msg
+		expFactoryErr     error
+		expDeliveryErr    error
+		expFutureOpsCount int
+	}{
+		"successful execution": {
+			factory: SimMsgFactoryFn[*testdata.TestMsg](func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg *testdata.TestMsg) {
+				return []SimAccount{senderAcc}, myMsg
+			}),
+			expFactoryMsg: myMsg,
+		},
+		"skip execution": {
+			factory: SimMsgFactoryFn[*testdata.TestMsg](func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg *testdata.TestMsg) {
+				reporter.Skip("testing")
+				return nil, nil
+			}),
+		},
+		"future ops registration": {
+			factory: NewSimMsgFactoryWithFutureOps[*testdata.TestMsg](func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter, fOpsReg FutureOpsRegistry) (signer []SimAccount, msg *testdata.TestMsg) {
+				fOpsReg.Add(futureTime, SimMsgFactoryFn[*testdata.TestMsg](func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg *testdata.TestMsg) {
+					return []SimAccount{senderAcc}, myMsg
+				}))
+				return []SimAccount{senderAcc}, myMsg
+			}),
+			expFactoryMsg:     myMsg,
+			expFutureOpsCount: 1,
+		},
+		"error in factory execution": {
+			factory: NewSimMsgFactoryWithFutureOps[*testdata.TestMsg](func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter, fOpsReg FutureOpsRegistry) (signer []SimAccount, msg *testdata.TestMsg) {
+				reporter.Fail(errors.New("testing"))
+				return nil, nil
+			}),
+			expFactoryErr: errors.New("testing"),
+		},
+		"missing senders": {
+			factory: SimMsgFactoryFn[*testdata.TestMsg](func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg *testdata.TestMsg) {
+				return nil, myMsg
+			}),
+			expDeliveryErr: errors.New("no senders"),
+		},
+		"error in delivery execution": {
+			factory: SimMsgFactoryFn[*testdata.TestMsg](func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg *testdata.TestMsg) {
+				return []SimAccount{senderAcc}, myMsg
+			}),
+			expDeliveryErr: errors.New("testing"),
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			r := NewBasicSimulationReporter()
+			reg := NewSimsMsgRegistryAdapter(r, ak, nil, txConfig(), log.NewNopLogger())
+			// when
+			reg.Add(100, spec.factory)
+			// then
+			gotOps := reg.ToLegacyObjects()
+			require.Len(t, gotOps, 1)
+			assert.Equal(t, 100, gotOps[0].Weight())
+
+			// and when ops executed
+			var capturedTXs []sdk.Tx
+			captureTXApp := AppEntrypointFn(func(_txEncoder sdk.TxEncoder, tx sdk.Tx) (sdk.GasInfo, *sdk.Result, error) {
+				capturedTXs = append(capturedTXs, tx)
+				return sdk.GasInfo{}, &sdk.Result{}, spec.expDeliveryErr
+			})
+			fn := gotOps[0].Op()
+			gotOpsResult, gotFOps, gotErr := fn(rand.New(rand.NewSource(1)), captureTXApp, ctx, accs, "testchain")
+			// then
+			if spec.expFactoryErr != nil {
+				require.Equal(t, spec.expFactoryErr, gotErr)
+				assert.Empty(t, gotFOps)
+				assert.Equal(t, gotOpsResult.OK, spec.expFactoryErr == nil)
+				assert.Empty(t, gotOpsResult.Comment)
+				require.Empty(t, capturedTXs)
+			}
+			if spec.expDeliveryErr != nil {
+				require.Equal(t, spec.expDeliveryErr, gotErr)
+			}
+			// and verify TX delivery
+			if spec.expFactoryMsg != nil {
+				require.Len(t, capturedTXs, 1)
+				require.Len(t, capturedTXs[0].GetMsgs(), 1)
+				assert.Equal(t, spec.expFactoryMsg, capturedTXs[0].GetMsgs()[0])
+			}
+			assert.Len(t, gotFOps, spec.expFutureOpsCount)
+		})
+	}
+}
+
+func TestSimsProposalRegistryAdapter(t *testing.T) {
+	myAcc1 := SimAccountFixture()
+	ak := MockAccountSourceX{GetAccountFn: MemoryAccountSource(myAcc1).GetAccount}
+	myMsg := testdata.NewTestMsg(myAcc1.Address)
+	addrCodec := txConfig().SigningContext().AddressCodec()
+	ctx := sdk.Context{}.WithContext(context.Background())
+
+	specs := map[string]struct {
+		factory SimMsgFactoryFn[*testdata.TestMsg]
+		expMsg  sdk.Msg
+		expErr  error
+	}{
+		"successful execution": {
+			factory: func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg *testdata.TestMsg) {
+				return nil, myMsg
+			},
+			expMsg: myMsg,
+		},
+		"skip execution": {
+			factory: func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg *testdata.TestMsg) {
+				reporter.Skip("testing")
+				return nil, nil
+			},
+		},
+		"error execution": {
+			factory: func(ctx context.Context, testData *ChainDataSource, reporter SimulationReporter) (signer []SimAccount, msg *testdata.TestMsg) {
+				reporter.Fail(errors.New("testing"))
+				return nil, nil
+			},
+			expErr: errors.New("testing"),
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			r := NewBasicSimulationReporter()
+			reg := NewSimsProposalRegistryAdapter(r, ak, nil, addrCodec, log.NewNopLogger())
+			// when
+			reg.Add(100, spec.factory)
+			// then
+			gotOps := reg.ToLegacyObjects()
+			require.Len(t, gotOps, 1)
+			assert.Equal(t, 100, gotOps[0].DefaultWeight())
+
+			// and when ops executed
+			fn := gotOps[0].MsgSimulatorFn()
+			gotPayloadMsg, gotErr := fn(ctx, rand.New(rand.NewSource(1)), []simtypes.Account{}, addrCodec)
+			// then
+			if spec.expErr != nil {
+				require.Equal(t, spec.expErr, gotErr)
+				return
+			}
+			assert.Equal(t, spec.expMsg, gotPayloadMsg)
+		})
+	}
+}
+
+func TestRunWithFailFast(t *testing.T) {
+	myTestMsg := testdata.NewTestMsg()
+	mySigners := []SimAccount{SimAccountFixture()}
+	specs := map[string]struct {
+		factory    FactoryMethod
+		expSigners []SimAccount
+		expMsg     sdk.Msg
+		expSkipped bool
+	}{
+		"factory completes": {
+			factory: func(ctx context.Context, _ *ChainDataSource, reporter SimulationReporter) ([]SimAccount, sdk.Msg) {
+				return mySigners, myTestMsg
+			},
+			expSigners: mySigners,
+			expMsg:     myTestMsg,
+		},
+		"factory skips": {
+			factory: func(ctx context.Context, _ *ChainDataSource, reporter SimulationReporter) ([]SimAccount, sdk.Msg) {
+				reporter.Skip("testing")
+				return nil, nil
+			},
+			expSkipped: true,
+		},
+		"factory skips and panics": {
+			factory: func(ctx context.Context, _ *ChainDataSource, reporter SimulationReporter) ([]SimAccount, sdk.Msg) {
+				reporter.Skip("testing")
+				panic("should be handled")
+			},
+			expSkipped: true,
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			ctx, done := context.WithCancel(context.Background())
+			reporter := NewBasicSimulationReporter().WithScope(&testdata.TestMsg{}, SkipHookFn(func(...any) { done() }))
+			gotSigners, gotMsg := runWithFailFast(ctx, nil, reporter, spec.factory)
+			assert.Equal(t, spec.expSigners, gotSigners)
+			assert.Equal(t, spec.expMsg, gotMsg)
+			assert.Equal(t, spec.expSkipped, reporter.IsSkipped())
+		})
+	}
+}
diff --git a/simsx/reporter.go b/simsx/reporter.go
new file mode 100644
index 000000000000..d6813db22c50
--- /dev/null
+++ b/simsx/reporter.go
@@ -0,0 +1,268 @@
+package simsx
+
+import (
+	"errors"
+	"fmt"
+	"slices"
+	"sort"
+	"strings"
+	"sync"
+	"sync/atomic"
+
+	"github.com/cosmos/gogoproto/proto"
+	"golang.org/x/exp/maps"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+)
+
+// SimulationReporter is an interface for reporting the result of a simulation run.
+type SimulationReporter interface {
+	WithScope(msg sdk.Msg, optionalSkipHook ...SkipHook) SimulationReporter
+	Skip(comment string)
+	Skipf(comment string, args ...any)
+	// IsSkipped returns true when skipped or completed
+	IsSkipped() bool
+	ToLegacyOperationMsg() simtypes.OperationMsg
+	// Fail complete with failure
+	Fail(err error, comments ...string)
+	// Success complete with success
+	Success(msg sdk.Msg, comments ...string)
+	// Close returns error captured on fail
+	Close() error
+	Comment() string
+}
+
+var _ SimulationReporter = &BasicSimulationReporter{}
+
+type ReporterStatus uint8
+
+const (
+	undefined ReporterStatus = iota
+	skipped   ReporterStatus = iota
+	completed ReporterStatus = iota
+)
+
+func (s ReporterStatus) String() string {
+	switch s {
+	case skipped:
+		return "skipped"
+	case completed:
+		return "completed"
+	default:
+		return "undefined"
+	}
+}
+
+// SkipHook is an interface that represents a callback hook used triggered on skip operations.
+// It provides a single method `Skip` that accepts variadic arguments. This interface is implemented
+// by Go stdlib testing.T and testing.B
+type SkipHook interface {
+	Skip(args ...any)
+}
+
+var _ SkipHook = SkipHookFn(nil)
+
+type SkipHookFn func(args ...any)
+
+func (s SkipHookFn) Skip(args ...any) {
+	s(args...)
+}
+
+type BasicSimulationReporter struct {
+	skipCallbacks     []SkipHook
+	completedCallback func(reporter *BasicSimulationReporter)
+	module            string
+	msgTypeURL        string
+
+	status atomic.Uint32
+
+	cMX        sync.RWMutex
+	comments   []string
+	error      error
+	msgProtoBz []byte
+
+	summary *ExecutionSummary
+}
+
+// NewBasicSimulationReporter constructor that accepts an optional callback hook that is called on state transition to skipped status
+// A typical implementation for this hook is testing.T or testing.B.
+func NewBasicSimulationReporter(optionalSkipHook ...SkipHook) *BasicSimulationReporter {
+	r := &BasicSimulationReporter{
+		skipCallbacks: optionalSkipHook,
+		summary:       NewExecutionSummary(),
+	}
+	r.completedCallback = func(child *BasicSimulationReporter) {
+		r.summary.Add(child.module, child.msgTypeURL, ReporterStatus(child.status.Load()), child.Comment())
+	}
+	return r
+}
+
+// WithScope is a method of the BasicSimulationReporter type that creates a new instance of SimulationReporter
+// with an additional scope specified by the input `msg`. The msg is used to set type, module and binary data as
+// context for the legacy operation.
+// The WithScope method acts as a constructor to initialize state and has to be called before using the instance
+// in DeliverSimsMsg.
+//
+// The method accepts an optional `optionalSkipHook` parameter
+// that can be used to add a callback hook that is triggered on skip operations additional to any parent skip hook.
+// This method returns the newly created
+// SimulationReporter instance.
+func (x *BasicSimulationReporter) WithScope(msg sdk.Msg, optionalSkipHook ...SkipHook) SimulationReporter {
+	typeURL := sdk.MsgTypeURL(msg)
+	r := &BasicSimulationReporter{
+		skipCallbacks:     append(x.skipCallbacks, optionalSkipHook...),
+		completedCallback: x.completedCallback,
+		error:             x.error,
+		msgProtoBz:        x.msgProtoBz,
+		msgTypeURL:        typeURL,
+		module:            sdk.GetModuleNameFromTypeURL(typeURL),
+		comments:          slices.Clone(x.comments),
+	}
+	r.status.Store(x.status.Load())
+	return r
+}
+
+func (x *BasicSimulationReporter) Skip(comment string) {
+	x.toStatus(skipped, comment)
+}
+
+func (x *BasicSimulationReporter) Skipf(comment string, args ...any) {
+	x.Skip(fmt.Sprintf(comment, args...))
+}
+
+func (x *BasicSimulationReporter) IsSkipped() bool {
+	return ReporterStatus(x.status.Load()) > undefined
+}
+
+func (x *BasicSimulationReporter) ToLegacyOperationMsg() simtypes.OperationMsg {
+	switch ReporterStatus(x.status.Load()) {
+	case skipped:
+		return simtypes.NoOpMsg(x.module, x.msgTypeURL, x.Comment())
+	case completed:
+		x.cMX.RLock()
+		err := x.error
+		x.cMX.RUnlock()
+		if err == nil {
+			return simtypes.NewOperationMsgBasic(x.module, x.msgTypeURL, x.Comment(), true, x.msgProtoBz)
+		} else {
+			return simtypes.NewOperationMsgBasic(x.module, x.msgTypeURL, x.Comment(), false, x.msgProtoBz)
+		}
+	default:
+		x.Fail(errors.New("operation aborted before msg was executed"))
+		return x.ToLegacyOperationMsg()
+	}
+}
+
+func (x *BasicSimulationReporter) Fail(err error, comments ...string) {
+	if !x.toStatus(completed, comments...) {
+		return
+	}
+	x.cMX.Lock()
+	defer x.cMX.Unlock()
+	x.error = err
+}
+
+func (x *BasicSimulationReporter) Success(msg sdk.Msg, comments ...string) {
+	if !x.toStatus(completed, comments...) {
+		return
+	}
+	if msg == nil {
+		return
+	}
+	protoBz, err := proto.Marshal(msg) // todo: not great to capture the proto bytes here again but legacy test are using it.
+	if err != nil {
+		panic(err)
+	}
+	x.cMX.Lock()
+	defer x.cMX.Unlock()
+	x.msgProtoBz = protoBz
+}
+
+func (x *BasicSimulationReporter) Close() error {
+	x.completedCallback(x)
+	x.cMX.RLock()
+	defer x.cMX.RUnlock()
+	return x.error
+}
+
+func (x *BasicSimulationReporter) toStatus(next ReporterStatus, comments ...string) bool {
+	oldStatus := ReporterStatus(x.status.Load())
+	if oldStatus > next {
+		panic(fmt.Sprintf("can not switch from status %s to %s", oldStatus, next))
+	}
+	if !x.status.CompareAndSwap(uint32(oldStatus), uint32(next)) {
+		return false
+	}
+	x.cMX.Lock()
+	newComments := append(x.comments, comments...)
+	x.comments = newComments
+	x.cMX.Unlock()
+
+	if oldStatus != skipped && next == skipped {
+		prettyComments := strings.Join(newComments, ", ")
+		for _, hook := range x.skipCallbacks {
+			hook.Skip(prettyComments)
+		}
+	}
+	return true
+}
+
+func (x *BasicSimulationReporter) Comment() string {
+	x.cMX.RLock()
+	defer x.cMX.RUnlock()
+	return strings.Join(x.comments, ", ")
+}
+
+func (x *BasicSimulationReporter) Summary() *ExecutionSummary {
+	return x.summary
+}
+
+type ExecutionSummary struct {
+	mx          sync.RWMutex
+	counts      map[string]int            // module to count
+	skipReasons map[string]map[string]int // msg type to reason->count
+}
+
+func NewExecutionSummary() *ExecutionSummary {
+	return &ExecutionSummary{counts: make(map[string]int), skipReasons: make(map[string]map[string]int)}
+}
+
+func (s *ExecutionSummary) Add(module, url string, status ReporterStatus, comment string) {
+	s.mx.Lock()
+	defer s.mx.Unlock()
+	combinedKey := fmt.Sprintf("%s_%s", module, status.String())
+	s.counts[combinedKey] += 1
+	if status == completed {
+		return
+	}
+	r, ok := s.skipReasons[url]
+	if !ok {
+		r = make(map[string]int)
+		s.skipReasons[url] = r
+	}
+	r[comment] += 1
+}
+
+func (s *ExecutionSummary) String() string {
+	s.mx.RLock()
+	defer s.mx.RUnlock()
+	keys := maps.Keys(s.counts)
+	sort.Strings(keys)
+	var sb strings.Builder
+	for _, key := range keys {
+		sb.WriteString(fmt.Sprintf("%s: %d\n", key, s.counts[key]))
+	}
+	for m, c := range s.skipReasons {
+		sb.WriteString(fmt.Sprintf("%d\t%s: %q\n", sum(maps.Values(c)), m, maps.Keys(c)))
+	}
+	return sb.String()
+}
+
+func sum(values []int) int {
+	var r int
+	for _, v := range values {
+		r += v
+	}
+	return r
+}
diff --git a/simsx/reporter_test.go b/simsx/reporter_test.go
new file mode 100644
index 000000000000..a828d58d2857
--- /dev/null
+++ b/simsx/reporter_test.go
@@ -0,0 +1,219 @@
+package simsx
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+)
+
+func TestSimulationReporterToLegacy(t *testing.T) {
+	myErr := errors.New("my-error")
+	myMsg := testdata.NewTestMsg([]byte{1})
+
+	specs := map[string]struct {
+		setup  func() SimulationReporter
+		expOp  simtypes.OperationMsg
+		expErr error
+	}{
+		"init only": {
+			setup:  func() SimulationReporter { return NewBasicSimulationReporter() },
+			expOp:  simtypes.NewOperationMsgBasic("", "", "", false, nil),
+			expErr: errors.New("operation aborted before msg was executed"),
+		},
+		"success result": {
+			setup: func() SimulationReporter {
+				r := NewBasicSimulationReporter().WithScope(myMsg)
+				r.Success(myMsg, "testing")
+				return r
+			},
+			expOp: simtypes.NewOperationMsgBasic("TestMsg", "/testpb.TestMsg", "testing", true, must(myMsg.Marshal())),
+		},
+		"error result": {
+			setup: func() SimulationReporter {
+				r := NewBasicSimulationReporter().WithScope(myMsg)
+				r.Fail(myErr, "testing")
+				return r
+			},
+			expOp:  simtypes.NewOperationMsgBasic("TestMsg", "/testpb.TestMsg", "testing", false, nil),
+			expErr: myErr,
+		},
+		"last error wins": {
+			setup: func() SimulationReporter {
+				r := NewBasicSimulationReporter().WithScope(myMsg)
+				r.Fail(errors.New("other-err"), "testing1")
+				r.Fail(myErr, "testing2")
+				return r
+			},
+			expOp:  simtypes.NewOperationMsgBasic("TestMsg", "/testpb.TestMsg", "testing1, testing2", false, nil),
+			expErr: myErr,
+		},
+		"skipped ": {
+			setup: func() SimulationReporter {
+				r := NewBasicSimulationReporter().WithScope(myMsg)
+				r.Skip("testing")
+				return r
+			},
+			expOp: simtypes.NoOpMsg("TestMsg", "/testpb.TestMsg", "testing"),
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			r := spec.setup()
+			assert.Equal(t, spec.expOp, r.ToLegacyOperationMsg())
+			require.Equal(t, spec.expErr, r.Close())
+		})
+	}
+}
+
+func TestSimulationReporterTransitions(t *testing.T) {
+	specs := map[string]struct {
+		setup     func(r SimulationReporter)
+		expStatus ReporterStatus
+		expPanic  bool
+	}{
+		"undefined->skipped": {
+			setup: func(r SimulationReporter) {
+				r.Skip("testing")
+			},
+			expStatus: skipped,
+		},
+		"skipped->skipped": {
+			setup: func(r SimulationReporter) {
+				r.Skip("testing1")
+				r.Skip("testing2")
+			},
+			expStatus: skipped,
+		},
+		"skipped->completed": {
+			setup: func(r SimulationReporter) {
+				r.Skip("testing1")
+				r.Success(nil, "testing2")
+			},
+			expStatus: completed,
+		},
+		"completed->completed": {
+			setup: func(r SimulationReporter) {
+				r.Success(nil, "testing1")
+				r.Fail(nil, "testing2")
+			},
+			expStatus: completed,
+		},
+		"completed->completed2": {
+			setup: func(r SimulationReporter) {
+				r.Fail(nil, "testing1")
+				r.Success(nil, "testing2")
+			},
+			expStatus: completed,
+		},
+		"completed->skipped: rejected": {
+			setup: func(r SimulationReporter) {
+				r.Success(nil, "testing1")
+				r.Skip("testing2")
+			},
+			expPanic: true,
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			r := NewBasicSimulationReporter()
+			if !spec.expPanic {
+				spec.setup(r)
+				assert.Equal(t, uint32(spec.expStatus), r.status.Load())
+				return
+			}
+			require.Panics(t, func() {
+				spec.setup(r)
+			})
+		})
+	}
+}
+
+func TestSkipHook(t *testing.T) {
+	myHook := func() (SkipHookFn, *bool) {
+		var hookCalled bool
+		return func(args ...any) {
+			hookCalled = true
+		}, &hookCalled
+	}
+	fn, myHookCalled := myHook()
+	r := NewBasicSimulationReporter(fn)
+	r.Skip("testing")
+	require.True(t, *myHookCalled)
+
+	// and with nested reporter
+	fn, myHookCalled = myHook()
+	r = NewBasicSimulationReporter(fn)
+	fn2, myOtherHookCalled := myHook()
+	r2 := r.WithScope(testdata.NewTestMsg([]byte{1}), fn2)
+	r2.Skipf("testing %d", 2)
+	assert.True(t, *myHookCalled)
+	assert.True(t, *myOtherHookCalled)
+}
+
+func TestReporterSummary(t *testing.T) {
+	specs := map[string]struct {
+		do         func(t *testing.T, r SimulationReporter)
+		expSummary map[string]int
+		expReasons map[string]map[string]int
+	}{
+		"skipped": {
+			do: func(t *testing.T, r SimulationReporter) { //nolint:thelper // not a helper
+				r2 := r.WithScope(testdata.NewTestMsg([]byte{1}))
+				r2.Skip("testing")
+				require.NoError(t, r2.Close())
+			},
+			expSummary: map[string]int{"TestMsg_skipped": 1},
+			expReasons: map[string]map[string]int{"/testpb.TestMsg": {"testing": 1}},
+		},
+		"success result": {
+			do: func(t *testing.T, r SimulationReporter) { //nolint:thelper // not a helper
+				msg := testdata.NewTestMsg([]byte{1})
+				r2 := r.WithScope(msg)
+				r2.Success(msg)
+				require.NoError(t, r2.Close())
+			},
+			expSummary: map[string]int{"TestMsg_completed": 1},
+			expReasons: map[string]map[string]int{},
+		},
+		"error result": {
+			do: func(t *testing.T, r SimulationReporter) { //nolint:thelper // not a helper
+				msg := testdata.NewTestMsg([]byte{1})
+				r2 := r.WithScope(msg)
+				r2.Fail(errors.New("testing"))
+				require.Error(t, r2.Close())
+			},
+			expSummary: map[string]int{"TestMsg_completed": 1},
+			expReasons: map[string]map[string]int{},
+		},
+		"multiple skipped": {
+			do: func(t *testing.T, r SimulationReporter) { //nolint:thelper // not a helper
+				r2 := r.WithScope(testdata.NewTestMsg([]byte{1}))
+				r2.Skip("testing1")
+				require.NoError(t, r2.Close())
+				r3 := r.WithScope(testdata.NewTestMsg([]byte{2}))
+				r3.Skip("testing2")
+				require.NoError(t, r3.Close())
+			},
+			expSummary: map[string]int{"TestMsg_skipped": 2},
+			expReasons: map[string]map[string]int{
+				"/testpb.TestMsg": {"testing1": 1, "testing2": 1},
+			},
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			r := NewBasicSimulationReporter()
+			// when
+			spec.do(t, r)
+			gotSummary := r.Summary()
+			// then
+			require.Equal(t, spec.expSummary, gotSummary.counts)
+			require.Equal(t, spec.expReasons, gotSummary.skipReasons)
+		})
+	}
+}
diff --git a/simsx/slices.go b/simsx/slices.go
new file mode 100644
index 000000000000..3466cd6f971c
--- /dev/null
+++ b/simsx/slices.go
@@ -0,0 +1,38 @@
+package simsx
+
+// Collect applies the function f to each element in the source slice,
+// returning a new slice containing the results.
+//
+// The source slice can contain elements of any type T, and the function f
+// should take an element of type T as input and return a value of any type E.
+//
+// Example usage:
+//
+//	source := []int{1, 2, 3, 4, 5}
+//	double := Collect(source, func(x int) int {
+//	    return x * 2
+//	})
+//	// double is now []int{2, 4, 6, 8, 10}
+func Collect[T, E any](source []T, f func(a T) E) []E {
+	r := make([]E, len(source))
+	for i, v := range source {
+		r[i] = f(v)
+	}
+	return r
+}
+
+// First returns the first element in the slice that matches the condition
+func First[T any](source []T, f func(a T) bool) *T {
+	for i := 0; i < len(source); i++ {
+		if f(source[i]) {
+			return &source[i]
+		}
+	}
+	return nil
+}
+
+// OneOf returns a random element from the given slice using the provided random number generator.
+// Panics for empty or nil slice
+func OneOf[T any](r interface{ Intn(n int) int }, s []T) T {
+	return s[r.Intn(len(s))]
+}
diff --git a/simsx/slices_test.go b/simsx/slices_test.go
new file mode 100644
index 000000000000..40decc173bd2
--- /dev/null
+++ b/simsx/slices_test.go
@@ -0,0 +1,40 @@
+package simsx
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCollect(t *testing.T) {
+	src := []int{1, 2, 3}
+	got := Collect(src, func(a int) int { return a * 2 })
+	assert.Equal(t, []int{2, 4, 6}, got)
+	gotStrings := Collect(src, strconv.Itoa)
+	assert.Equal(t, []string{"1", "2", "3"}, gotStrings)
+}
+
+func TestFirst(t *testing.T) {
+	src := []string{"a", "b"}
+	assert.Equal(t, &src[1], First(src, func(a string) bool { return a == "b" }))
+	assert.Nil(t, First(src, func(a string) bool { return false }))
+}
+
+func TestOneOf(t *testing.T) {
+	src := []string{"a", "b"}
+	got := OneOf(randMock{next: 1}, src)
+	assert.Equal(t, "b", got)
+	// test with other type
+	src2 := []int{1, 2, 3}
+	got2 := OneOf(randMock{next: 2}, src2)
+	assert.Equal(t, 3, got2)
+}
+
+type randMock struct {
+	next int
+}
+
+func (x randMock) Intn(n int) int {
+	return x.next
+}
diff --git a/tests/go.mod b/tests/go.mod
index 1dd30f25688f..331ef0b3867c 100644
--- a/tests/go.mod
+++ b/tests/go.mod
@@ -14,7 +14,7 @@ require (
 	cosmossdk.io/store v1.1.1-0.20240418092142-896cdf1971bc
 	cosmossdk.io/x/evidence v0.0.0-20230613133644-0a778132a60f
 	cosmossdk.io/x/feegrant v0.0.0-20230613133644-0a778132a60f
-	cosmossdk.io/x/nft v0.0.0-20230613133644-0a778132a60f
+	cosmossdk.io/x/nft v0.0.0-20230613133644-0a778132a60f // indirect
 	cosmossdk.io/x/protocolpool v0.0.0-20230925135524-a1bc045b3190
 	cosmossdk.io/x/tx v0.13.3
 	cosmossdk.io/x/upgrade v0.0.0-20230613133644-0a778132a60f
diff --git a/tests/sims/authz/operations_test.go b/tests/sims/authz/operations_test.go
deleted file mode 100644
index 7e59d00a827f..000000000000
--- a/tests/sims/authz/operations_test.go
+++ /dev/null
@@ -1,224 +0,0 @@
-package authz
-
-import (
-	"math/rand"
-	"testing"
-	"time"
-
-	"github.com/cosmos/gogoproto/proto"
-	"github.com/stretchr/testify/suite"
-
-	"cosmossdk.io/core/header"
-	coretesting "cosmossdk.io/core/testing"
-	"cosmossdk.io/depinject"
-	_ "cosmossdk.io/x/accounts" // import as blank for app wiring
-	_ "cosmossdk.io/x/auth"     // import as blank for app wiring
-	authkeeper "cosmossdk.io/x/auth/keeper"
-	_ "cosmossdk.io/x/auth/tx/config" // import as blank for app wiring
-	"cosmossdk.io/x/authz"
-	authzkeeper "cosmossdk.io/x/authz/keeper"
-	_ "cosmossdk.io/x/authz/module" // import as blank for app wiring
-	"cosmossdk.io/x/authz/simulation"
-	_ "cosmossdk.io/x/bank" // import as blank for app wiring
-	bankkeeper "cosmossdk.io/x/bank/keeper"
-	banktestutil "cosmossdk.io/x/bank/testutil"
-	banktypes "cosmossdk.io/x/bank/types"
-	_ "cosmossdk.io/x/consensus" // import as blank for app wiring
-	_ "cosmossdk.io/x/gov"       // import as blank for app wiring
-	_ "cosmossdk.io/x/mint"      // import as blank for app wiring
-	_ "cosmossdk.io/x/staking"   // import as blank for app wiring
-
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
-	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
-	"github.com/cosmos/cosmos-sdk/runtime"
-	"github.com/cosmos/cosmos-sdk/testutil/configurator"
-	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
-	_ "github.com/cosmos/cosmos-sdk/x/genutil" // import as blank for app wiring
-)
-
-var AppConfig = configurator.NewAppConfig(
-	configurator.AccountsModule(),
-	configurator.AuthModule(),
-	configurator.BankModule(),
-	configurator.StakingModule(),
-	configurator.TxModule(),
-	configurator.ConsensusModule(),
-	configurator.GenutilModule(),
-	configurator.AuthzModule(),
-	configurator.MintModule(),
-)
-
-type SimTestSuite struct {
-	suite.Suite
-
-	ctx sdk.Context
-
-	app               *runtime.App
-	codec             codec.Codec
-	interfaceRegistry codectypes.InterfaceRegistry
-	txConfig          client.TxConfig
-	accountKeeper     authkeeper.AccountKeeper
-	bankKeeper        bankkeeper.Keeper
-	authzKeeper       authzkeeper.Keeper
-}
-
-func (suite *SimTestSuite) SetupTest() {
-	app, err := simtestutil.Setup(
-		depinject.Configs(
-			AppConfig,
-			depinject.Supply(coretesting.NewNopLogger()),
-		),
-		&suite.codec,
-		&suite.interfaceRegistry,
-		&suite.txConfig,
-		&suite.accountKeeper,
-		&suite.bankKeeper,
-		&suite.authzKeeper,
-	)
-	suite.Require().NoError(err)
-	suite.app = app
-	suite.ctx = app.BaseApp.NewContext(false)
-}
-
-func (suite *SimTestSuite) TestWeightedOperations() {
-	cdc := suite.codec
-	appParams := make(simtypes.AppParams)
-
-	weightedOps := simulation.WeightedOperations(suite.interfaceRegistry, appParams, cdc, suite.txConfig, suite.accountKeeper,
-		suite.bankKeeper, suite.authzKeeper)
-
-	s := rand.NewSource(3)
-	r := rand.New(s)
-	// setup 2 accounts
-	accs := suite.getTestingAccounts(r, 2)
-
-	expected := []struct {
-		weight     int
-		opMsgRoute string
-		opMsgName  string
-	}{
-		{simulation.WeightGrant, authz.ModuleName, simulation.TypeMsgGrant},
-		{simulation.WeightExec, authz.ModuleName, simulation.TypeMsgExec},
-		{simulation.WeightRevoke, authz.ModuleName, simulation.TypeMsgRevoke},
-	}
-
-	require := suite.Require()
-	for i, w := range weightedOps {
-		op, _, err := w.Op()(r, suite.app.BaseApp, suite.ctx, accs, "")
-		require.NoError(err)
-
-		// the following checks are very much dependent from the ordering of the output given
-		// by WeightedOperations. if the ordering in WeightedOperations changes some tests
-		// will fail
-		require.Equal(expected[i].weight, w.Weight(), "weight should be the same. %v", op.Comment)
-		require.Equal(expected[i].opMsgRoute, op.Route, "route should be the same. %v", op.Comment)
-		require.Equal(expected[i].opMsgName, op.Name, "operation Msg name should be the same %v", op.Comment)
-	}
-}
-
-func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
-	accounts := simtypes.RandomAccounts(r, n)
-
-	initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
-	initCoins := sdk.NewCoins(sdk.NewCoin("stake", initAmt))
-
-	// add coins to the accounts
-	for _, account := range accounts {
-		acc := suite.accountKeeper.NewAccountWithAddress(suite.ctx, account.Address)
-		suite.accountKeeper.SetAccount(suite.ctx, acc)
-		suite.Require().NoError(banktestutil.FundAccount(suite.ctx, suite.bankKeeper, account.Address, initCoins))
-	}
-
-	return accounts
-}
-
-func (suite *SimTestSuite) TestSimulateGrant() {
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 2)
-	blockTime := time.Now().UTC()
-	ctx := suite.ctx.WithHeaderInfo(header.Info{Time: blockTime})
-
-	granter := accounts[0]
-	grantee := accounts[1]
-
-	// execute operation
-	op := simulation.SimulateMsgGrant(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.authzKeeper)
-	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, ctx, accounts, "")
-	suite.Require().NoError(err)
-
-	var msg authz.MsgGrant
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	suite.Require().NoError(err)
-	suite.Require().True(operationMsg.OK)
-	suite.Require().Equal(granter.Address.String(), msg.Granter)
-	suite.Require().Equal(grantee.Address.String(), msg.Grantee)
-	suite.Require().Len(futureOperations, 0)
-}
-
-func (suite *SimTestSuite) TestSimulateRevoke() {
-	// setup 3 accounts
-	s := rand.NewSource(2)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 3)
-	initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
-	initCoins := sdk.NewCoins(sdk.NewCoin("stake", initAmt))
-
-	granter := accounts[0]
-	grantee := accounts[1]
-	a := banktypes.NewSendAuthorization(initCoins, nil, suite.accountKeeper.AddressCodec())
-	expire := time.Now().Add(30 * time.Hour)
-
-	err := suite.authzKeeper.SaveGrant(suite.ctx, grantee.Address, granter.Address, a, &expire)
-	suite.Require().NoError(err)
-
-	// execute operation
-	op := simulation.SimulateMsgRevoke(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.authzKeeper)
-	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
-	suite.Require().NoError(err)
-
-	var msg authz.MsgRevoke
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	suite.Require().NoError(err)
-	suite.Require().True(operationMsg.OK)
-	suite.Require().Equal(granter.Address.String(), msg.Granter)
-	suite.Require().Equal(grantee.Address.String(), msg.Grantee)
-	suite.Require().Equal(banktypes.SendAuthorization{}.MsgTypeURL(), msg.MsgTypeUrl)
-	suite.Require().Len(futureOperations, 0)
-}
-
-func (suite *SimTestSuite) TestSimulateExec() {
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 3)
-	initAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
-	initCoins := sdk.NewCoins(sdk.NewCoin("stake", initAmt))
-
-	granter := accounts[0]
-	grantee := accounts[1]
-	a := banktypes.NewSendAuthorization(initCoins, nil, suite.accountKeeper.AddressCodec())
-	expire := suite.ctx.HeaderInfo().Time.Add(1 * time.Hour)
-
-	err := suite.authzKeeper.SaveGrant(suite.ctx, grantee.Address, granter.Address, a, &expire)
-	suite.Require().NoError(err)
-
-	// execute operation
-	op := simulation.SimulateMsgExec(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.authzKeeper, suite.codec)
-	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
-	suite.Require().NoError(err)
-
-	var msg authz.MsgExec
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	suite.Require().NoError(err)
-	suite.Require().True(operationMsg.OK)
-	suite.Require().Equal(grantee.Address.String(), msg.Grantee)
-	suite.Require().Len(futureOperations, 0)
-}
-
-func TestSimTestSuite(t *testing.T) {
-	suite.Run(t, new(SimTestSuite))
-}
diff --git a/tests/sims/bank/operations_test.go b/tests/sims/bank/operations_test.go
deleted file mode 100644
index 0243cf19dd40..000000000000
--- a/tests/sims/bank/operations_test.go
+++ /dev/null
@@ -1,217 +0,0 @@
-package simulation_test
-
-import (
-	"math/rand"
-	"testing"
-
-	"github.com/cosmos/gogoproto/proto"
-	"github.com/stretchr/testify/suite"
-
-	"cosmossdk.io/depinject"
-	"cosmossdk.io/log"
-	_ "cosmossdk.io/x/accounts"
-	_ "cosmossdk.io/x/auth"
-	_ "cosmossdk.io/x/auth/tx/config"
-	_ "cosmossdk.io/x/bank"
-	"cosmossdk.io/x/bank/keeper"
-	"cosmossdk.io/x/bank/simulation"
-	"cosmossdk.io/x/bank/testutil"
-	"cosmossdk.io/x/bank/types"
-	_ "cosmossdk.io/x/consensus"
-	_ "cosmossdk.io/x/staking"
-
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
-	"github.com/cosmos/cosmos-sdk/runtime"
-	"github.com/cosmos/cosmos-sdk/testutil/configurator"
-	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
-)
-
-type SimTestSuite struct {
-	suite.Suite
-
-	ctx           sdk.Context
-	accountKeeper types.AccountKeeper
-	bankKeeper    keeper.Keeper
-	cdc           codec.Codec
-	txConfig      client.TxConfig
-	app           *runtime.App
-}
-
-func (suite *SimTestSuite) SetupTest() {
-	var (
-		appBuilder *runtime.AppBuilder
-		err        error
-	)
-	suite.app, err = simtestutil.Setup(
-		depinject.Configs(
-			configurator.NewAppConfig(
-				configurator.AccountsModule(),
-				configurator.AuthModule(),
-				configurator.BankModule(),
-				configurator.StakingModule(),
-				configurator.ConsensusModule(),
-				configurator.TxModule(),
-			),
-			depinject.Supply(log.NewNopLogger()),
-		), &suite.accountKeeper, &suite.bankKeeper, &suite.cdc, &suite.txConfig, &appBuilder)
-
-	suite.NoError(err)
-
-	suite.ctx = suite.app.BaseApp.NewContext(false)
-}
-
-// TestWeightedOperations tests the weights of the operations.
-func (suite *SimTestSuite) TestWeightedOperations() {
-	cdc := suite.cdc
-	appParams := make(simtypes.AppParams)
-
-	weightesOps := simulation.WeightedOperations(appParams, cdc, suite.txConfig, suite.accountKeeper, suite.bankKeeper)
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accs := suite.getTestingAccounts(r, 3)
-
-	expected := []struct {
-		weight     int
-		opMsgRoute string
-		opMsgName  string
-	}{
-		{100, types.ModuleName, sdk.MsgTypeURL(&types.MsgSend{})},
-		{10, types.ModuleName, sdk.MsgTypeURL(&types.MsgMultiSend{})},
-	}
-
-	for i, w := range weightesOps {
-		operationMsg, _, err := w.Op()(r, suite.app.BaseApp, suite.ctx, accs, "")
-		suite.Require().NoError(err)
-
-		// the following checks are very much dependent from the ordering of the output given
-		// by WeightedOperations. if the ordering in WeightedOperations changes some tests
-		// will fail
-		suite.Require().Equal(expected[i].weight, w.Weight(), "weight should be the same")
-		suite.Require().Equal(expected[i].opMsgRoute, operationMsg.Route, "route should be the same")
-		suite.Require().Equal(expected[i].opMsgName, operationMsg.Name, "operation Msg name should be the same")
-	}
-}
-
-// TestSimulateMsgSend tests the normal scenario of a valid message of type TypeMsgSend.
-// Abonormal scenarios, where the message is created by an errors, are not tested here.
-func (suite *SimTestSuite) TestSimulateMsgSend() {
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 3)
-
-	// execute operation
-	op := simulation.SimulateMsgSend(suite.txConfig, suite.accountKeeper, suite.bankKeeper)
-	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
-	suite.Require().NoError(err)
-
-	var msg types.MsgSend
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	suite.Require().NoError(err)
-	suite.Require().True(operationMsg.OK)
-	suite.Require().Equal("65337742stake", msg.Amount.String())
-	suite.Require().Equal("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", msg.FromAddress)
-	suite.Require().Equal("cosmos1p8wcgrjr4pjju90xg6u9cgq55dxwq8j7u4x9a0", msg.ToAddress)
-	suite.Require().Equal(sdk.MsgTypeURL(&types.MsgSend{}), sdk.MsgTypeURL(&msg))
-	suite.Require().Len(futureOperations, 0)
-}
-
-// TestSimulateMsgMultiSend tests the normal scenario of a valid message of type TypeMsgMultiSend.
-// Abonormal scenarios, where the message is created by an errors, are not tested here.
-func (suite *SimTestSuite) TestSimulateMsgMultiSend() {
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 3)
-
-	// execute operation
-	op := simulation.SimulateMsgMultiSend(suite.txConfig, suite.accountKeeper, suite.bankKeeper)
-	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
-	require := suite.Require()
-	require.NoError(err)
-
-	var msg types.MsgMultiSend
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	suite.Require().NoError(err)
-	require.True(operationMsg.OK)
-	require.Len(msg.Inputs, 1)
-	require.Equal("cosmos1tnh2q55v8wyygtt9srz5safamzdengsnqeycj3", msg.Inputs[0].Address)
-	require.Equal("114949958stake", msg.Inputs[0].Coins.String())
-	require.Len(msg.Outputs, 2)
-	require.Equal("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", msg.Outputs[1].Address)
-	require.Equal("107287087stake", msg.Outputs[1].Coins.String())
-	suite.Require().Equal(sdk.MsgTypeURL(&types.MsgMultiSend{}), sdk.MsgTypeURL(&msg))
-	require.Len(futureOperations, 0)
-}
-
-func (suite *SimTestSuite) TestSimulateModuleAccountMsgSend() {
-	const moduleAccount = 1
-
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 1)
-
-	// execute operation
-	op := simulation.SimulateMsgSendToModuleAccount(suite.txConfig, suite.accountKeeper, suite.bankKeeper, moduleAccount)
-
-	s = rand.NewSource(1)
-	r = rand.New(s)
-
-	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
-	suite.Require().Error(err)
-
-	var msg types.MsgSend
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	suite.Require().NoError(err)
-	suite.Require().False(operationMsg.OK)
-	suite.Require().Equal(operationMsg.Comment, "invalid transfers")
-	suite.Require().Equal(sdk.MsgTypeURL(&types.MsgSend{}), sdk.MsgTypeURL(&msg))
-	suite.Require().Len(futureOperations, 0)
-}
-
-func (suite *SimTestSuite) TestSimulateMsgMultiSendToModuleAccount() {
-	const mAccount = 2
-
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 2)
-
-	// execute operation
-	op := simulation.SimulateMsgMultiSendToModuleAccount(suite.txConfig, suite.accountKeeper, suite.bankKeeper, mAccount)
-
-	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
-	suite.Require().Error(err)
-
-	var msg types.MsgMultiSend
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	suite.Require().NoError(err)
-	suite.Require().False(operationMsg.OK) // sending tokens to a module account should fail
-	suite.Require().Equal(operationMsg.Comment, "invalid transfers")
-	suite.Require().Equal(sdk.MsgTypeURL(&types.MsgMultiSend{}), sdk.MsgTypeURL(&msg))
-	suite.Require().Len(futureOperations, 0)
-}
-
-func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
-	accounts := simtypes.RandomAccounts(r, n)
-
-	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
-	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
-
-	// add coins to the accounts
-	for _, account := range accounts {
-		acc := suite.accountKeeper.NewAccountWithAddress(suite.ctx, account.Address)
-		suite.accountKeeper.SetAccount(suite.ctx, acc)
-		suite.Require().NoError(testutil.FundAccount(suite.ctx, suite.bankKeeper, account.Address, initCoins))
-	}
-
-	return accounts
-}
-
-func TestSimTestSuite(t *testing.T) {
-	suite.Run(t, new(SimTestSuite))
-}
diff --git a/tests/sims/distribution/app_config.go b/tests/sims/distribution/app_config.go
deleted file mode 100644
index 8c97052076ba..000000000000
--- a/tests/sims/distribution/app_config.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package distribution
-
-import (
-	_ "cosmossdk.io/x/accounts"       // import as blank for app wiring
-	_ "cosmossdk.io/x/auth"           // import as blank for app wiring
-	_ "cosmossdk.io/x/auth/tx/config" // import as blank for app wiring
-	_ "cosmossdk.io/x/bank"           // import as blank for app wiring
-	_ "cosmossdk.io/x/consensus"      // import as blank for app wiring
-	_ "cosmossdk.io/x/distribution"   // import as blank for app wiring
-	_ "cosmossdk.io/x/mint"           // import as blank for app wiring
-	_ "cosmossdk.io/x/protocolpool"   // import as blank for app wiring
-	_ "cosmossdk.io/x/staking"        // import as blank for app wiring
-
-	"github.com/cosmos/cosmos-sdk/testutil/configurator"
-	_ "github.com/cosmos/cosmos-sdk/x/genutil" // import as blank for app wiring
-)
-
-var AppConfig = configurator.NewAppConfig(
-	configurator.AccountsModule(),
-	configurator.AuthModule(),
-	configurator.BankModule(),
-	configurator.StakingModule(),
-	configurator.TxModule(),
-	configurator.ConsensusModule(),
-	configurator.GenutilModule(),
-	configurator.DistributionModule(),
-	configurator.MintModule(),
-	configurator.ProtocolPoolModule(),
-)
diff --git a/tests/sims/distribution/operations_test.go b/tests/sims/distribution/operations_test.go
deleted file mode 100644
index a5451da0866b..000000000000
--- a/tests/sims/distribution/operations_test.go
+++ /dev/null
@@ -1,287 +0,0 @@
-package distribution
-
-import (
-	"math/rand"
-	"testing"
-
-	"github.com/cosmos/gogoproto/proto"
-	"github.com/stretchr/testify/suite"
-
-	"cosmossdk.io/collections"
-	"cosmossdk.io/depinject"
-	"cosmossdk.io/log"
-	"cosmossdk.io/math"
-	authkeeper "cosmossdk.io/x/auth/keeper"
-	bankkeeper "cosmossdk.io/x/bank/keeper"
-	banktestutil "cosmossdk.io/x/bank/testutil"
-	"cosmossdk.io/x/distribution/keeper"
-	"cosmossdk.io/x/distribution/simulation"
-	"cosmossdk.io/x/distribution/types"
-	stakingkeeper "cosmossdk.io/x/staking/keeper"
-	stakingtypes "cosmossdk.io/x/staking/types"
-
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
-	"github.com/cosmos/cosmos-sdk/codec/address"
-	"github.com/cosmos/cosmos-sdk/runtime"
-	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
-)
-
-// TestWeightedOperations tests the weights of the operations.
-func (suite *SimTestSuite) TestWeightedOperations() {
-	appParams := make(simtypes.AppParams)
-
-	weightedOps := simulation.WeightedOperations(appParams, suite.cdc, suite.txConfig, suite.accountKeeper,
-		suite.bankKeeper, suite.distrKeeper, suite.stakingKeeper)
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accs := suite.getTestingAccounts(r, 3)
-
-	expected := []struct {
-		weight     int
-		opMsgRoute string
-		opMsgName  string
-	}{
-		{simulation.DefaultWeightMsgSetWithdrawAddress, types.ModuleName, sdk.MsgTypeURL(&types.MsgSetWithdrawAddress{})},
-		{simulation.DefaultWeightMsgWithdrawDelegationReward, types.ModuleName, sdk.MsgTypeURL(&types.MsgWithdrawDelegatorReward{})},
-		{simulation.DefaultWeightMsgWithdrawValidatorCommission, types.ModuleName, sdk.MsgTypeURL(&types.MsgWithdrawValidatorCommission{})},
-	}
-
-	for i, w := range weightedOps {
-		operationMsg, _, err := w.Op()(r, suite.app.BaseApp, suite.ctx, accs, "")
-		suite.Require().NoError(err)
-
-		// the following checks are very much dependent from the ordering of the output given
-		// by WeightedOperations. if the ordering in WeightedOperations changes some tests
-		// will fail
-		suite.Require().Equal(expected[i].weight, w.Weight(), "weight should be the same")
-		suite.Require().Equal(expected[i].opMsgRoute, operationMsg.Route, "route should be the same")
-		suite.Require().Equal(expected[i].opMsgName, operationMsg.Name, "operation Msg name should be the same")
-	}
-}
-
-// TestSimulateMsgSetWithdrawAddress tests the normal scenario of a valid message of type TypeMsgSetWithdrawAddress.
-// Abonormal scenarios, where the message is created by an errors, are not tested here.
-func (suite *SimTestSuite) TestSimulateMsgSetWithdrawAddress() {
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 3)
-
-	// execute operation
-	op := simulation.SimulateMsgSetWithdrawAddress(suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.distrKeeper)
-	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
-	suite.Require().NoError(err)
-
-	var msg types.MsgSetWithdrawAddress
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	suite.Require().NoError(err)
-	suite.Require().True(operationMsg.OK)
-	suite.Require().Equal("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", msg.DelegatorAddress)
-	suite.Require().Equal("cosmos1p8wcgrjr4pjju90xg6u9cgq55dxwq8j7u4x9a0", msg.WithdrawAddress)
-	suite.Require().Equal(sdk.MsgTypeURL(&types.MsgSetWithdrawAddress{}), sdk.MsgTypeURL(&msg))
-	suite.Require().Len(futureOperations, 0)
-}
-
-// TestSimulateMsgWithdrawDelegatorReward tests the normal scenario of a valid message
-// of type TypeMsgWithdrawDelegatorReward.
-// Abonormal scenarios, where the message is created by an errors, are not tested here.
-func (suite *SimTestSuite) TestSimulateMsgWithdrawDelegatorReward() {
-	// setup 3 accounts
-	s := rand.NewSource(4)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 3)
-
-	// setup accounts[0] as validator
-	validator0 := suite.getTestingValidator0(accounts)
-
-	// setup delegation
-	delTokens := sdk.TokensFromConsensusPower(2, sdk.DefaultPowerReduction)
-	validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
-	delegator := accounts[1]
-	delegation := stakingtypes.NewDelegation(delegator.Address.String(), validator0.GetOperator(), issuedShares)
-	suite.Require().NoError(suite.stakingKeeper.SetDelegation(suite.ctx, delegation))
-	valBz, err := address.NewBech32Codec("cosmosvaloper").StringToBytes(validator0.GetOperator())
-	suite.Require().NoError(err)
-
-	suite.Require().NoError(suite.distrKeeper.DelegatorStartingInfo.Set(suite.ctx, collections.Join(sdk.ValAddress(valBz), delegator.Address), types.NewDelegatorStartingInfo(2, math.LegacyOneDec(), 200)))
-
-	suite.setupValidatorRewards(valBz)
-
-	// execute operation
-	op := simulation.SimulateMsgWithdrawDelegatorReward(suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.distrKeeper, suite.stakingKeeper)
-	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
-	suite.Require().NoError(err)
-
-	var msg types.MsgWithdrawDelegatorReward
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	suite.Require().NoError(err)
-	suite.Require().True(operationMsg.OK)
-	suite.Require().Equal("cosmosvaloper1l4s054098kk9hmr5753c6k3m2kw65h686d3mhr", msg.ValidatorAddress)
-	suite.Require().Equal("cosmos1d6u7zhjwmsucs678d7qn95uqajd4ucl9jcjt26", msg.DelegatorAddress)
-	suite.Require().Equal(sdk.MsgTypeURL(&types.MsgWithdrawDelegatorReward{}), sdk.MsgTypeURL(&msg))
-	suite.Require().Len(futureOperations, 0)
-}
-
-// TestSimulateMsgWithdrawValidatorCommission tests the normal scenario of a valid message
-// of type TypeMsgWithdrawValidatorCommission.
-// Abonormal scenarios, where the message is created by an errors, are not tested here.
-func (suite *SimTestSuite) TestSimulateMsgWithdrawValidatorCommission() {
-	suite.testSimulateMsgWithdrawValidatorCommission("atoken")
-	suite.testSimulateMsgWithdrawValidatorCommission("tokenxxx")
-}
-
-// all the checks in this function should not fail if we change the tokenName
-func (suite *SimTestSuite) testSimulateMsgWithdrawValidatorCommission(tokenName string) {
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 3)
-
-	// setup accounts[0] as validator
-	validator0 := suite.getTestingValidator0(accounts)
-
-	// set module account coins
-	distrAcc := suite.distrKeeper.GetDistributionAccount(suite.ctx)
-	suite.Require().NoError(banktestutil.FundModuleAccount(suite.ctx, suite.bankKeeper, distrAcc.GetName(), sdk.NewCoins(
-		sdk.NewCoin(tokenName, math.NewInt(10)),
-		sdk.NewCoin("stake", math.NewInt(5)),
-	)))
-	suite.accountKeeper.SetModuleAccount(suite.ctx, distrAcc)
-
-	// set outstanding rewards
-	valCommission := sdk.NewDecCoins(
-		sdk.NewDecCoinFromDec(tokenName, math.LegacyNewDec(5).Quo(math.LegacyNewDec(2))),
-		sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(1).Quo(math.LegacyNewDec(1))),
-	)
-	valCodec := address.NewBech32Codec("cosmosvaloper")
-
-	val0, err := valCodec.StringToBytes(validator0.GetOperator())
-	suite.Require().NoError(err)
-
-	genVal0, err := valCodec.StringToBytes(suite.genesisVals[0].GetOperator())
-	suite.Require().NoError(err)
-
-	suite.Require().NoError(suite.distrKeeper.ValidatorOutstandingRewards.Set(suite.ctx, val0, types.ValidatorOutstandingRewards{Rewards: valCommission}))
-	suite.Require().NoError(suite.distrKeeper.ValidatorOutstandingRewards.Set(suite.ctx, genVal0, types.ValidatorOutstandingRewards{Rewards: valCommission}))
-
-	// setup validator accumulated commission
-	suite.Require().NoError(suite.distrKeeper.ValidatorsAccumulatedCommission.Set(suite.ctx, val0, types.ValidatorAccumulatedCommission{Commission: valCommission}))
-	suite.Require().NoError(suite.distrKeeper.ValidatorsAccumulatedCommission.Set(suite.ctx, genVal0, types.ValidatorAccumulatedCommission{Commission: valCommission}))
-
-	// execute operation
-	op := simulation.SimulateMsgWithdrawValidatorCommission(suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.distrKeeper, suite.stakingKeeper)
-	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, suite.ctx, accounts, "")
-	if !operationMsg.OK {
-		suite.Require().Equal("could not find account", operationMsg.Comment)
-	} else {
-		suite.Require().NoError(err)
-
-		var msg types.MsgWithdrawValidatorCommission
-		err = proto.Unmarshal(operationMsg.Msg, &msg)
-		suite.Require().NoError(err)
-		suite.Require().True(operationMsg.OK)
-		suite.Require().Equal("cosmosvaloper1tnh2q55v8wyygtt9srz5safamzdengsn9dsd7z", msg.ValidatorAddress)
-		suite.Require().Equal(sdk.MsgTypeURL(&types.MsgWithdrawValidatorCommission{}), sdk.MsgTypeURL(&msg))
-		suite.Require().Len(futureOperations, 0)
-	}
-}
-
-type SimTestSuite struct {
-	suite.Suite
-
-	ctx         sdk.Context
-	app         *runtime.App
-	genesisVals []stakingtypes.Validator
-
-	txConfig      client.TxConfig
-	cdc           codec.Codec
-	stakingKeeper *stakingkeeper.Keeper
-	accountKeeper authkeeper.AccountKeeper
-	bankKeeper    bankkeeper.Keeper
-	distrKeeper   keeper.Keeper
-}
-
-func (suite *SimTestSuite) SetupTest() {
-	var (
-		appBuilder *runtime.AppBuilder
-		err        error
-	)
-	suite.app, err = simtestutil.Setup(
-		depinject.Configs(
-			AppConfig,
-			depinject.Supply(log.NewNopLogger()),
-		),
-		&suite.accountKeeper,
-		&suite.bankKeeper,
-		&suite.cdc,
-		&appBuilder,
-		&suite.stakingKeeper,
-		&suite.distrKeeper,
-		&suite.txConfig,
-	)
-
-	suite.NoError(err)
-
-	suite.ctx = suite.app.BaseApp.NewContext(false)
-
-	genesisVals, err := suite.stakingKeeper.GetAllValidators(suite.ctx)
-	suite.Require().NoError(err)
-	suite.Require().Len(genesisVals, 1)
-	suite.genesisVals = genesisVals
-}
-
-func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
-	accounts := simtypes.RandomAccounts(r, n)
-
-	initAmt := suite.stakingKeeper.TokensFromConsensusPower(suite.ctx, 200)
-	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
-
-	// add coins to the accounts
-	for _, account := range accounts {
-		acc := suite.accountKeeper.NewAccountWithAddress(suite.ctx, account.Address)
-		suite.accountKeeper.SetAccount(suite.ctx, acc)
-		suite.Require().NoError(banktestutil.FundAccount(suite.ctx, suite.bankKeeper, account.Address, initCoins))
-	}
-
-	return accounts
-}
-
-func (suite *SimTestSuite) getTestingValidator0(accounts []simtypes.Account) stakingtypes.Validator {
-	commission0 := stakingtypes.NewCommission(math.LegacyZeroDec(), math.LegacyOneDec(), math.LegacyOneDec())
-	return suite.getTestingValidator(accounts, commission0, 0)
-}
-
-func (suite *SimTestSuite) getTestingValidator(accounts []simtypes.Account, commission stakingtypes.Commission, n int) stakingtypes.Validator {
-	require := suite.Require()
-	account := accounts[n]
-	valPubKey := account.PubKey
-	valAddr := sdk.ValAddress(account.PubKey.Address().Bytes())
-	validator, err := stakingtypes.NewValidator(valAddr.String(), valPubKey, stakingtypes.Description{})
-	require.NoError(err)
-	validator, err = validator.SetInitialCommission(commission)
-	require.NoError(err)
-	validator.DelegatorShares = math.LegacyNewDec(100)
-	validator.Tokens = math.NewInt(1000000)
-
-	suite.Require().NoError(suite.stakingKeeper.SetValidator(suite.ctx, validator))
-
-	return validator
-}
-
-func (suite *SimTestSuite) setupValidatorRewards(valAddress sdk.ValAddress) {
-	decCoins := sdk.DecCoins{sdk.NewDecCoinFromDec(sdk.DefaultBondDenom, math.LegacyOneDec())}
-	historicalRewards := types.NewValidatorHistoricalRewards(decCoins, 2)
-	suite.Require().NoError(suite.distrKeeper.ValidatorHistoricalRewards.Set(suite.ctx, collections.Join(valAddress, uint64(2)), historicalRewards))
-	// setup current revards
-	currentRewards := types.NewValidatorCurrentRewards(decCoins, 3)
-	suite.Require().NoError(suite.distrKeeper.ValidatorCurrentRewards.Set(suite.ctx, valAddress, currentRewards))
-}
-
-func TestSimTestSuite(t *testing.T) {
-	suite.Run(t, new(SimTestSuite))
-}
diff --git a/tests/sims/feegrant/operations_test.go b/tests/sims/feegrant/operations_test.go
deleted file mode 100644
index d280cd6c40ba..000000000000
--- a/tests/sims/feegrant/operations_test.go
+++ /dev/null
@@ -1,215 +0,0 @@
-package simulation_test
-
-import (
-	"math/rand"
-	"testing"
-	"time"
-
-	"github.com/cosmos/gogoproto/proto"
-	"github.com/stretchr/testify/suite"
-
-	"cosmossdk.io/core/header"
-	"cosmossdk.io/depinject"
-	"cosmossdk.io/log"
-	_ "cosmossdk.io/x/accounts" // import as blank for app wiring
-	_ "cosmossdk.io/x/auth"
-	authkeeper "cosmossdk.io/x/auth/keeper"
-	_ "cosmossdk.io/x/auth/tx/config"
-	_ "cosmossdk.io/x/bank"
-	bankkeeper "cosmossdk.io/x/bank/keeper"
-	banktestutil "cosmossdk.io/x/bank/testutil"
-	_ "cosmossdk.io/x/consensus"
-	"cosmossdk.io/x/feegrant"
-	"cosmossdk.io/x/feegrant/keeper"
-	_ "cosmossdk.io/x/feegrant/module"
-	"cosmossdk.io/x/feegrant/simulation"
-	_ "cosmossdk.io/x/mint"
-	_ "cosmossdk.io/x/staking"
-
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
-	codecaddress "github.com/cosmos/cosmos-sdk/codec/address"
-	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
-	"github.com/cosmos/cosmos-sdk/runtime"
-	"github.com/cosmos/cosmos-sdk/testutil/configurator"
-	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
-	_ "github.com/cosmos/cosmos-sdk/x/genutil"
-)
-
-type SimTestSuite struct {
-	suite.Suite
-
-	app               *runtime.App
-	ctx               sdk.Context
-	feegrantKeeper    keeper.Keeper
-	interfaceRegistry codectypes.InterfaceRegistry
-	txConfig          client.TxConfig
-	accountKeeper     authkeeper.AccountKeeper
-	bankKeeper        bankkeeper.Keeper
-	cdc               codec.Codec
-}
-
-func (suite *SimTestSuite) SetupTest() {
-	var err error
-	suite.app, err = simtestutil.Setup(
-		depinject.Configs(
-			configurator.NewAppConfig(
-				configurator.AccountsModule(),
-				configurator.AuthModule(),
-				configurator.BankModule(),
-				configurator.StakingModule(),
-				configurator.TxModule(),
-				configurator.ConsensusModule(),
-				configurator.GenutilModule(),
-				configurator.FeegrantModule(),
-			),
-			depinject.Supply(log.NewNopLogger()),
-		),
-		&suite.feegrantKeeper,
-		&suite.bankKeeper,
-		&suite.accountKeeper,
-		&suite.interfaceRegistry,
-		&suite.txConfig,
-		&suite.cdc,
-	)
-	suite.Require().NoError(err)
-
-	suite.ctx = suite.app.BaseApp.NewContext(false).WithHeaderInfo(header.Info{Time: time.Now()})
-}
-
-func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
-	accounts := simtypes.RandomAccounts(r, n)
-	initAmt := sdk.TokensFromConsensusPower(200, sdk.DefaultPowerReduction)
-	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
-
-	// add coins to the accounts
-	for _, account := range accounts {
-		acc := suite.accountKeeper.NewAccountWithAddress(suite.ctx, account.Address)
-		suite.accountKeeper.SetAccount(suite.ctx, acc)
-		err := banktestutil.FundAccount(suite.ctx, suite.bankKeeper, account.Address, initCoins)
-		suite.Require().NoError(err)
-	}
-
-	return accounts
-}
-
-func (suite *SimTestSuite) TestWeightedOperations() {
-	require := suite.Require()
-
-	appParams := make(simtypes.AppParams)
-
-	weightedOps := simulation.WeightedOperations(
-		suite.interfaceRegistry,
-		appParams, suite.cdc, suite.txConfig, suite.accountKeeper,
-		suite.bankKeeper, suite.feegrantKeeper, codecaddress.NewBech32Codec("cosmos"),
-	)
-
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accs := suite.getTestingAccounts(r, 3)
-
-	expected := []struct {
-		weight     int
-		opMsgRoute string
-		opMsgName  string
-	}{
-		{
-			simulation.DefaultWeightGrantAllowance,
-			feegrant.ModuleName,
-			sdk.MsgTypeURL(&feegrant.MsgGrantAllowance{}),
-		},
-		{
-			simulation.DefaultWeightRevokeAllowance,
-			feegrant.ModuleName,
-			sdk.MsgTypeURL(&feegrant.MsgRevokeAllowance{}),
-		},
-	}
-
-	for i, w := range weightedOps {
-		operationMsg, _, err := w.Op()(r, suite.app.BaseApp, suite.ctx.WithHeaderInfo(header.Info{Time: time.Now()}), accs, suite.ctx.ChainID())
-		require.NoError(err)
-
-		// the following checks are very much dependent from the ordering of the output given
-		// by WeightedOperations. if the ordering in WeightedOperations changes some tests
-		// will fail
-		require.Equal(expected[i].weight, w.Weight(), "weight should be the same")
-		require.Equal(expected[i].opMsgRoute, operationMsg.Route, "route should be the same")
-		require.Equal(expected[i].opMsgName, operationMsg.Name, "operation Msg name should be the same")
-	}
-}
-
-func (suite *SimTestSuite) TestSimulateMsgGrantAllowance() {
-	app, ctx := suite.app, suite.ctx
-	require := suite.Require()
-
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 3)
-	addr1, err := suite.accountKeeper.AddressCodec().BytesToString(accounts[1].Address)
-	require.NoError(err)
-	addr2, err := suite.accountKeeper.AddressCodec().BytesToString(accounts[2].Address)
-	require.NoError(err)
-
-	// execute operation
-	op := simulation.SimulateMsgGrantAllowance(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.feegrantKeeper)
-	operationMsg, futureOperations, err := op(r, app.BaseApp, ctx.WithHeaderInfo(header.Info{Time: time.Now()}), accounts, "")
-	require.NoError(err)
-
-	var msg feegrant.MsgGrantAllowance
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	require.NoError(err)
-	require.True(operationMsg.OK)
-	require.Equal(addr2, msg.Granter)
-	require.Equal(addr1, msg.Grantee)
-	require.Len(futureOperations, 0)
-}
-
-func (suite *SimTestSuite) TestSimulateMsgRevokeAllowance() {
-	app, ctx := suite.app, suite.ctx
-	require := suite.Require()
-
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 3)
-
-	feeAmt := sdk.TokensFromConsensusPower(200000, sdk.DefaultPowerReduction)
-	feeCoins := sdk.NewCoins(sdk.NewCoin("foo", feeAmt))
-
-	granter, grantee := accounts[0], accounts[1]
-
-	oneYear := ctx.HeaderInfo().Time.AddDate(1, 0, 0)
-	err := suite.feegrantKeeper.GrantAllowance(
-		ctx,
-		granter.Address,
-		grantee.Address,
-		&feegrant.BasicAllowance{
-			SpendLimit: feeCoins,
-			Expiration: &oneYear,
-		},
-	)
-	require.NoError(err)
-
-	granterStr, err := suite.accountKeeper.AddressCodec().BytesToString(accounts[0].Address)
-	require.NoError(err)
-	granteeStr, err := suite.accountKeeper.AddressCodec().BytesToString(accounts[1].Address)
-	require.NoError(err)
-
-	// execute operation
-	op := simulation.SimulateMsgRevokeAllowance(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.feegrantKeeper)
-	operationMsg, futureOperations, err := op(r, app.BaseApp, ctx, accounts, "")
-	require.NoError(err)
-
-	var msg feegrant.MsgRevokeAllowance
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	require.NoError(err)
-	require.True(operationMsg.OK)
-	require.Equal(granterStr, msg.Granter)
-	require.Equal(granteeStr, msg.Grantee)
-	require.Len(futureOperations, 0)
-}
-
-func TestSimTestSuite(t *testing.T) {
-	suite.Run(t, new(SimTestSuite))
-}
diff --git a/tests/sims/gov/operations_test.go b/tests/sims/gov/operations_test.go
deleted file mode 100644
index 93159e6f5206..000000000000
--- a/tests/sims/gov/operations_test.go
+++ /dev/null
@@ -1,428 +0,0 @@
-package simulation_test
-
-import (
-	"context"
-	"fmt"
-	"math/rand"
-	"testing"
-	"time"
-
-	"github.com/cosmos/gogoproto/proto"
-	"github.com/stretchr/testify/require"
-
-	"cosmossdk.io/core/address"
-	"cosmossdk.io/core/header"
-	"cosmossdk.io/depinject"
-	"cosmossdk.io/log"
-	_ "cosmossdk.io/x/accounts"
-	_ "cosmossdk.io/x/auth"
-	authkeeper "cosmossdk.io/x/auth/keeper"
-	_ "cosmossdk.io/x/auth/tx/config"
-	_ "cosmossdk.io/x/bank"
-	bankkeeper "cosmossdk.io/x/bank/keeper"
-	"cosmossdk.io/x/bank/testutil"
-	_ "cosmossdk.io/x/consensus"
-	_ "cosmossdk.io/x/gov"
-	"cosmossdk.io/x/gov/keeper"
-	"cosmossdk.io/x/gov/simulation"
-	"cosmossdk.io/x/gov/types"
-	v1 "cosmossdk.io/x/gov/types/v1"
-	"cosmossdk.io/x/gov/types/v1beta1"
-	_ "cosmossdk.io/x/protocolpool"
-	_ "cosmossdk.io/x/staking"
-	stakingkeeper "cosmossdk.io/x/staking/keeper"
-
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/runtime"
-	"github.com/cosmos/cosmos-sdk/testutil/configurator"
-	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
-)
-
-var (
-	_ simtypes.WeightedProposalMsg     = MockWeightedProposals{}
-	_ simtypes.WeightedProposalContent = MockWeightedProposals{} //nolint:staticcheck // testing legacy code path
-)
-
-type MockWeightedProposals struct {
-	n int
-}
-
-func (m MockWeightedProposals) AppParamsKey() string {
-	return fmt.Sprintf("AppParamsKey-%d", m.n)
-}
-
-func (m MockWeightedProposals) DefaultWeight() int {
-	return m.n
-}
-
-func (m MockWeightedProposals) MsgSimulatorFn() simtypes.MsgSimulatorFnX {
-	return func(_ context.Context, r *rand.Rand, _ []simtypes.Account, _ address.Codec) (sdk.Msg, error) {
-		return nil, nil
-	}
-}
-
-func (m MockWeightedProposals) ContentSimulatorFn() simtypes.ContentSimulatorFn { //nolint:staticcheck // testing legacy code path
-	return func(r *rand.Rand, _ sdk.Context, _ []simtypes.Account) simtypes.Content { //nolint:staticcheck // testing legacy code path
-		return v1beta1.NewTextProposal(
-			fmt.Sprintf("title-%d: %s", m.n, simtypes.RandStringOfLength(r, 100)),
-			fmt.Sprintf("description-%d: %s", m.n, simtypes.RandStringOfLength(r, 4000)),
-		)
-	}
-}
-
-func mockWeightedProposalMsg(n int) []simtypes.WeightedProposalMsg {
-	wpc := make([]simtypes.WeightedProposalMsg, n)
-	for i := 0; i < n; i++ {
-		wpc[i] = MockWeightedProposals{i}
-	}
-	return wpc
-}
-
-func mockWeightedLegacyProposalContent(n int) []simtypes.WeightedProposalContent { //nolint:staticcheck // testing legacy code path
-	wpc := make([]simtypes.WeightedProposalContent, n) //nolint:staticcheck // testing legacy code path
-	for i := 0; i < n; i++ {
-		wpc[i] = MockWeightedProposals{i}
-	}
-	return wpc
-}
-
-// TestWeightedOperations tests the weights of the operations.
-func TestWeightedOperations(t *testing.T) {
-	suite, ctx := createTestSuite(t, false)
-	app := suite.App
-	ctx.WithChainID("test-chain")
-	appParams := make(simtypes.AppParams)
-
-	weightesOps := simulation.WeightedOperations(appParams, suite.TxConfig, suite.AccountKeeper,
-		suite.BankKeeper, suite.GovKeeper, mockWeightedProposalMsg(3), mockWeightedLegacyProposalContent(1),
-	)
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accs := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, ctx, 3)
-
-	expected := []struct {
-		weight     int
-		opMsgRoute string
-		opMsgName  string
-	}{
-		{simulation.DefaultWeightMsgDeposit, types.ModuleName, simulation.TypeMsgDeposit},
-		{simulation.DefaultWeightMsgVote, types.ModuleName, simulation.TypeMsgVote},
-		{simulation.DefaultWeightMsgVoteWeighted, types.ModuleName, simulation.TypeMsgVoteWeighted},
-		{simulation.DefaultWeightMsgCancelProposal, types.ModuleName, simulation.TypeMsgCancelProposal},
-		{0, types.ModuleName, simulation.TypeMsgSubmitProposal},
-		{1, types.ModuleName, simulation.TypeMsgSubmitProposal},
-		{2, types.ModuleName, simulation.TypeMsgSubmitProposal},
-		{0, types.ModuleName, simulation.TypeMsgSubmitProposal},
-	}
-
-	require.Equal(t, len(weightesOps), len(expected), "number of operations should be the same")
-	for i, w := range weightesOps {
-		operationMsg, _, err := w.Op()(r, app.BaseApp, ctx, accs, ctx.ChainID())
-		require.NoError(t, err)
-
-		// the following checks are very much dependent from the ordering of the output given
-		// by WeightedOperations. if the ordering in WeightedOperations changes some tests
-		// will fail
-		require.Equal(t, expected[i].weight, w.Weight(), "weight should be the same")
-		require.Equal(t, expected[i].opMsgRoute, operationMsg.Route, "route should be the same")
-		require.Equal(t, expected[i].opMsgName, operationMsg.Name, "operation Msg name should be the same")
-	}
-}
-
-// TestSimulateMsgSubmitProposal tests the normal scenario of a valid message of type TypeMsgSubmitProposal.
-// Abnormal scenarios, where errors occur, are not tested here.
-func TestSimulateMsgSubmitProposal(t *testing.T) {
-	suite, ctx := createTestSuite(t, false)
-	app := suite.App
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, ctx, 3)
-
-	// execute operation
-	op := simulation.SimulateMsgSubmitProposal(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper, MockWeightedProposals{3}.MsgSimulatorFn())
-	operationMsg, _, err := op(r, app.BaseApp, ctx, accounts, "")
-	require.NoError(t, err)
-
-	var msg v1.MsgSubmitProposal
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	require.NoError(t, err)
-	require.True(t, operationMsg.OK)
-	require.Equal(t, "cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", msg.Proposer)
-	require.NotEqual(t, len(msg.InitialDeposit), 0)
-	require.Equal(t, "47841094stake", msg.InitialDeposit[0].String())
-	require.Equal(t, simulation.TypeMsgSubmitProposal, sdk.MsgTypeURL(&msg))
-}
-
-// TestSimulateMsgSubmitLegacyProposal tests the normal scenario of a valid message of type TypeMsgSubmitProposal.
-// Abnormal scenarios, where errors occur, are not tested here.
-func TestSimulateMsgSubmitLegacyProposal(t *testing.T) {
-	suite, ctx := createTestSuite(t, false)
-	app := suite.App
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, ctx, 3)
-
-	// execute operation
-	op := simulation.SimulateMsgSubmitLegacyProposal(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper, MockWeightedProposals{3}.ContentSimulatorFn())
-	operationMsg, _, err := op(r, app.BaseApp, ctx, accounts, "")
-	require.NoError(t, err)
-
-	var msg v1.MsgSubmitProposal
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	require.NoError(t, err)
-	var msgLegacyContent v1.MsgExecLegacyContent
-	err = proto.Unmarshal(msg.Messages[0].Value, &msgLegacyContent)
-	require.NoError(t, err)
-	var textProposal v1beta1.TextProposal
-	err = proto.Unmarshal(msgLegacyContent.Content.Value, &textProposal)
-	require.NoError(t, err)
-
-	require.True(t, operationMsg.OK)
-	require.Equal(t, "cosmos1p8wcgrjr4pjju90xg6u9cgq55dxwq8j7u4x9a0", msg.Proposer)
-	require.NotEqual(t, len(msg.InitialDeposit), 0)
-	require.Equal(t, "25166256stake", msg.InitialDeposit[0].String())
-	require.Equal(t, "title-3: ZBSpYuLyYggwexjxusrBqDOTtGTOWeLrQKjLxzIivHSlcxgdXhhuTSkuxKGLwQvuyNhYFmBZHeAerqyNEUzXPFGkqEGqiQWIXnku",
-		textProposal.GetTitle())
-	require.Equal(t, "description-3: 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",
-		textProposal.GetDescription())
-	require.Equal(t, simulation.TypeMsgSubmitProposal, sdk.MsgTypeURL(&msg))
-}
-
-// TestSimulateMsgCancelProposal tests the normal scenario of a valid message of type TypeMsgCancelProposal.
-// Abnormal scenarios, where errors occur, are not tested here.
-func TestSimulateMsgCancelProposal(t *testing.T) {
-	suite, ctx := createTestSuite(t, false)
-	app := suite.App
-	blockTime := time.Now().UTC()
-	ctx = ctx.WithHeaderInfo(header.Info{Time: blockTime})
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, ctx, 3)
-	// setup a proposal
-	proposer, err := suite.AccountKeeper.AddressCodec().BytesToString(accounts[0].Address)
-	require.NoError(t, err)
-	content := v1beta1.NewTextProposal("Test", "description")
-	contentMsg, err := v1.NewLegacyContent(content, suite.GovKeeper.GetGovernanceAccount(ctx).GetAddress().String())
-	require.NoError(t, err)
-
-	submitTime := ctx.HeaderInfo().Time
-	params, _ := suite.GovKeeper.Params.Get(ctx)
-	depositPeriod := params.MaxDepositPeriod
-
-	proposal, err := v1.NewProposal([]sdk.Msg{contentMsg}, 1, submitTime, submitTime.Add(*depositPeriod), "", "title", "summary", proposer, v1.ProposalType_PROPOSAL_TYPE_STANDARD)
-	require.NoError(t, err)
-
-	err = suite.GovKeeper.Proposals.Set(ctx, proposal.Id, proposal)
-	require.NoError(t, err)
-
-	// execute operation
-	op := simulation.SimulateMsgCancelProposal(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper)
-	operationMsg, _, err := op(r, app.BaseApp, ctx, accounts, "")
-	require.NoError(t, err)
-
-	var msg v1.MsgCancelProposal
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	require.NoError(t, err)
-	require.NoError(t, err)
-	require.True(t, operationMsg.OK)
-	require.Equal(t, uint64(1), msg.ProposalId)
-	require.Equal(t, proposer, msg.Proposer)
-	require.Equal(t, simulation.TypeMsgCancelProposal, sdk.MsgTypeURL(&msg))
-}
-
-// TestSimulateMsgDeposit tests the normal scenario of a valid message of type TypeMsgDeposit.
-// Abnormal scenarios, where errors occur, are not tested here.
-func TestSimulateMsgDeposit(t *testing.T) {
-	suite, ctx := createTestSuite(t, false)
-	app := suite.App
-	blockTime := time.Now().UTC()
-	ctx = ctx.WithHeaderInfo(header.Info{Time: blockTime})
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, ctx, 3)
-
-	// setup a proposal
-	content := v1beta1.NewTextProposal("Test", "description")
-	contentMsg, err := v1.NewLegacyContent(content, suite.GovKeeper.GetGovernanceAccount(ctx).GetAddress().String())
-	require.NoError(t, err)
-
-	submitTime := ctx.HeaderInfo().Time
-	params, _ := suite.GovKeeper.Params.Get(ctx)
-	depositPeriod := params.MaxDepositPeriod
-
-	proposal, err := v1.NewProposal([]sdk.Msg{contentMsg}, 1, submitTime, submitTime.Add(*depositPeriod), "", "text proposal", "description", "cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", v1.ProposalType_PROPOSAL_TYPE_STANDARD)
-	require.NoError(t, err)
-
-	err = suite.GovKeeper.Proposals.Set(ctx, proposal.Id, proposal)
-	require.NoError(t, err)
-
-	// execute operation
-	op := simulation.SimulateMsgDeposit(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper, simulation.NewSharedState())
-	operationMsg, _, err := op(r, app.BaseApp, ctx, accounts, "")
-	require.NoError(t, err)
-
-	var msg v1.MsgDeposit
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	require.NoError(t, err)
-	require.True(t, operationMsg.OK)
-	require.Equal(t, uint64(1), msg.ProposalId)
-	require.Equal(t, "cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", msg.Depositor)
-	require.NotEqual(t, len(msg.Amount), 0)
-	require.Equal(t, "560969stake", msg.Amount[0].String())
-	require.Equal(t, simulation.TypeMsgDeposit, sdk.MsgTypeURL(&msg))
-}
-
-// TestSimulateMsgVote tests the normal scenario of a valid message of type TypeMsgVote.
-// Abnormal scenarios, where errors occur, are not tested here.
-func TestSimulateMsgVote(t *testing.T) {
-	suite, ctx := createTestSuite(t, false)
-	app := suite.App
-	blockTime := time.Now().UTC()
-	ctx = ctx.WithHeaderInfo(header.Info{Time: blockTime})
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, ctx, 3)
-
-	// setup a proposal
-	govAcc := suite.GovKeeper.GetGovernanceAccount(ctx).GetAddress().String()
-	contentMsg, err := v1.NewLegacyContent(v1beta1.NewTextProposal("Test", "description"), govAcc)
-	require.NoError(t, err)
-
-	submitTime := ctx.HeaderInfo().Time
-	params, _ := suite.GovKeeper.Params.Get(ctx)
-	depositPeriod := params.MaxDepositPeriod
-
-	proposal, err := v1.NewProposal([]sdk.Msg{contentMsg}, 1, submitTime, submitTime.Add(*depositPeriod), "", "text proposal", "description", "cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", v1.ProposalType_PROPOSAL_TYPE_STANDARD)
-	require.NoError(t, err)
-
-	err = suite.GovKeeper.ActivateVotingPeriod(ctx, proposal)
-	require.NoError(t, err)
-
-	// execute operation
-	op := simulation.SimulateMsgVote(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper, simulation.NewSharedState())
-	operationMsg, _, err := op(r, app.BaseApp, ctx, accounts, "")
-	require.NoError(t, err)
-
-	var msg v1.MsgVote
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	require.NoError(t, err)
-	require.True(t, operationMsg.OK)
-	require.Equal(t, uint64(1), msg.ProposalId)
-	require.Equal(t, "cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", msg.Voter)
-	require.Equal(t, v1.OptionYes, msg.Option)
-	require.Equal(t, simulation.TypeMsgVote, sdk.MsgTypeURL(&msg))
-}
-
-// TestSimulateMsgVoteWeighted tests the normal scenario of a valid message of type TypeMsgVoteWeighted.
-// Abnormal scenarios, where errors occur, are not tested here.
-func TestSimulateMsgVoteWeighted(t *testing.T) {
-	suite, ctx := createTestSuite(t, false)
-	app := suite.App
-	blockTime := time.Now().UTC()
-	ctx = ctx.WithHeaderInfo(header.Info{Time: blockTime})
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, ctx, 3)
-
-	// setup a proposal
-	govAcc := suite.GovKeeper.GetGovernanceAccount(ctx).GetAddress().String()
-	contentMsg, err := v1.NewLegacyContent(v1beta1.NewTextProposal("Test", "description"), govAcc)
-	require.NoError(t, err)
-	submitTime := ctx.HeaderInfo().Time
-	params, _ := suite.GovKeeper.Params.Get(ctx)
-	depositPeriod := params.MaxDepositPeriod
-
-	proposal, err := v1.NewProposal([]sdk.Msg{contentMsg}, 1, submitTime, submitTime.Add(*depositPeriod), "", "text proposal", "test", "cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", v1.ProposalType_PROPOSAL_TYPE_STANDARD)
-	require.NoError(t, err)
-
-	err = suite.GovKeeper.ActivateVotingPeriod(ctx, proposal)
-	require.NoError(t, err)
-
-	// execute operation
-	op := simulation.SimulateMsgVoteWeighted(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper, simulation.NewSharedState())
-	operationMsg, _, err := op(r, app.BaseApp, ctx, accounts, "")
-	require.NoError(t, err)
-
-	var msg v1.MsgVoteWeighted
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	require.NoError(t, err)
-	require.True(t, operationMsg.OK)
-	require.Equal(t, uint64(1), msg.ProposalId)
-	require.Equal(t, "cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", msg.Voter)
-	require.True(t, len(msg.Options) >= 1)
-	require.Equal(t, simulation.TypeMsgVoteWeighted, sdk.MsgTypeURL(&msg))
-}
-
-type suite struct {
-	TxConfig      client.TxConfig
-	AccountKeeper authkeeper.AccountKeeper
-	BankKeeper    bankkeeper.Keeper
-	GovKeeper     *keeper.Keeper
-	StakingKeeper *stakingkeeper.Keeper
-	App           *runtime.App
-}
-
-// returns context and an app with updated mint keeper
-func createTestSuite(t *testing.T, isCheckTx bool) (suite, sdk.Context) {
-	t.Helper()
-	res := suite{}
-
-	app, err := simtestutil.Setup(
-		depinject.Configs(
-			configurator.NewAppConfig(
-				configurator.AccountsModule(),
-				configurator.AuthModule(),
-				configurator.TxModule(),
-				configurator.BankModule(),
-				configurator.StakingModule(),
-				configurator.ConsensusModule(),
-				configurator.GovModule(),
-				configurator.ProtocolPoolModule(),
-			),
-			depinject.Supply(log.NewNopLogger()),
-		),
-		&res.TxConfig, &res.AccountKeeper, &res.BankKeeper, &res.GovKeeper, &res.StakingKeeper)
-	require.NoError(t, err)
-
-	ctx := app.BaseApp.NewContext(isCheckTx)
-
-	res.App = app
-	return res, ctx
-}
-
-func getTestingAccounts(
-	t *testing.T, r *rand.Rand,
-	accountKeeper authkeeper.AccountKeeper, bankKeeper bankkeeper.Keeper, stakingKeeper *stakingkeeper.Keeper,
-	ctx sdk.Context, n int,
-) []simtypes.Account {
-	t.Helper()
-	accounts := simtypes.RandomAccounts(r, n)
-
-	initAmt := stakingKeeper.TokensFromConsensusPower(ctx, 200)
-	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
-
-	// add coins to the accounts
-	for _, account := range accounts {
-		acc := accountKeeper.NewAccountWithAddress(ctx, account.Address)
-		accountKeeper.SetAccount(ctx, acc)
-		require.NoError(t, testutil.FundAccount(ctx, bankKeeper, account.Address, initCoins))
-	}
-
-	return accounts
-}
diff --git a/tests/sims/nft/app_config.go b/tests/sims/nft/app_config.go
deleted file mode 100644
index 83f60f874c0d..000000000000
--- a/tests/sims/nft/app_config.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package nft
-
-import (
-	_ "cosmossdk.io/x/accounts"       // import as blank for app wiring
-	_ "cosmossdk.io/x/auth"           // import as blank for app wiring
-	_ "cosmossdk.io/x/auth/tx/config" // import as blank for app wiring
-	_ "cosmossdk.io/x/bank"           // import as blank for app wiring
-	_ "cosmossdk.io/x/consensus"      // import as blank for app wiring
-	_ "cosmossdk.io/x/mint"           // import as blank for app wiring
-	_ "cosmossdk.io/x/nft/module"     // import as blank for app wiring
-	_ "cosmossdk.io/x/staking"        // import as blank for app wiring
-
-	"github.com/cosmos/cosmos-sdk/testutil/configurator"
-	_ "github.com/cosmos/cosmos-sdk/x/genutil" // import as blank for app wiring
-)
-
-var AppConfig = configurator.NewAppConfig(
-	configurator.AccountsModule(),
-	configurator.AuthModule(),
-	configurator.BankModule(),
-	configurator.StakingModule(),
-	configurator.TxModule(),
-	configurator.ConsensusModule(),
-	configurator.GenutilModule(),
-	configurator.MintModule(),
-	configurator.NFTModule(),
-)
diff --git a/tests/sims/nft/operations_test.go b/tests/sims/nft/operations_test.go
deleted file mode 100644
index ee2e92603645..000000000000
--- a/tests/sims/nft/operations_test.go
+++ /dev/null
@@ -1,141 +0,0 @@
-package nft
-
-import (
-	"math/rand"
-	"testing"
-	"time"
-
-	"github.com/cosmos/gogoproto/proto"
-	"github.com/stretchr/testify/suite"
-
-	"cosmossdk.io/core/header"
-	"cosmossdk.io/depinject"
-	"cosmossdk.io/log"
-	authkeeper "cosmossdk.io/x/auth/keeper"
-	bankkeeper "cosmossdk.io/x/bank/keeper"
-	banktestutil "cosmossdk.io/x/bank/testutil"
-	"cosmossdk.io/x/nft"
-	nftkeeper "cosmossdk.io/x/nft/keeper"
-	"cosmossdk.io/x/nft/simulation"
-	stakingkeeper "cosmossdk.io/x/staking/keeper"
-
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
-	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
-	"github.com/cosmos/cosmos-sdk/runtime"
-	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
-)
-
-type SimTestSuite struct {
-	suite.Suite
-
-	ctx sdk.Context
-
-	app               *runtime.App
-	codec             codec.Codec
-	interfaceRegistry codectypes.InterfaceRegistry
-	txConfig          client.TxConfig
-	accountKeeper     authkeeper.AccountKeeper
-	bankKeeper        bankkeeper.Keeper
-	stakingKeeper     *stakingkeeper.Keeper
-	nftKeeper         nftkeeper.Keeper
-}
-
-func (suite *SimTestSuite) SetupTest() {
-	app, err := simtestutil.Setup(
-		depinject.Configs(
-			AppConfig,
-			depinject.Supply(log.NewNopLogger()),
-		),
-		&suite.codec,
-		&suite.interfaceRegistry,
-		&suite.txConfig,
-		&suite.accountKeeper,
-		&suite.bankKeeper,
-		&suite.stakingKeeper,
-		&suite.nftKeeper,
-	)
-	suite.Require().NoError(err)
-
-	suite.app = app
-	suite.ctx = app.BaseApp.NewContext(false)
-}
-
-func (suite *SimTestSuite) TestWeightedOperations() {
-	weightedOps := simulation.WeightedOperations(
-		suite.interfaceRegistry,
-		make(simtypes.AppParams),
-		suite.codec,
-		suite.txConfig,
-		suite.accountKeeper,
-		suite.bankKeeper,
-		suite.nftKeeper,
-	)
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accs := suite.getTestingAccounts(r, 3)
-
-	expected := []struct {
-		weight     int
-		opMsgRoute string
-		opMsgName  string
-	}{
-		{simulation.WeightSend, nft.ModuleName, simulation.TypeMsgSend},
-	}
-
-	for i, w := range weightedOps {
-		operationMsg, _, err := w.Op()(r, suite.app.BaseApp, suite.ctx, accs, "")
-		suite.Require().NoError(err)
-
-		// the following checks are very much dependent from the ordering of the output given
-		// by WeightedOperations. if the ordering in WeightedOperations changes some tests
-		// will fail
-		suite.Require().Equal(expected[i].weight, w.Weight(), "weight should be the same")
-		suite.Require().Equal(expected[i].opMsgRoute, operationMsg.Route, "route should be the same")
-		suite.Require().Equal(expected[i].opMsgName, operationMsg.Name, "operation Msg name should be the same")
-	}
-}
-
-func (suite *SimTestSuite) getTestingAccounts(r *rand.Rand, n int) []simtypes.Account {
-	accounts := simtypes.RandomAccounts(r, n)
-
-	initAmt := suite.stakingKeeper.TokensFromConsensusPower(suite.ctx, 200000)
-	initCoins := sdk.NewCoins(sdk.NewCoin("stake", initAmt))
-
-	// add coins to the accounts
-	for _, account := range accounts {
-		acc := suite.accountKeeper.NewAccountWithAddress(suite.ctx, account.Address)
-		suite.accountKeeper.SetAccount(suite.ctx, acc)
-		suite.Require().NoError(banktestutil.FundAccount(suite.ctx, suite.bankKeeper, account.Address, initCoins))
-	}
-
-	return accounts
-}
-
-func (suite *SimTestSuite) TestSimulateMsgSend() {
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := suite.getTestingAccounts(r, 2)
-	blockTime := time.Now().UTC()
-	ctx := suite.ctx.WithHeaderInfo(header.Info{Time: blockTime})
-
-	// execute operation
-	registry := suite.interfaceRegistry
-	op := simulation.SimulateMsgSend(codec.NewProtoCodec(registry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.nftKeeper)
-	operationMsg, futureOperations, err := op(r, suite.app.BaseApp, ctx, accounts, "")
-	suite.Require().NoError(err)
-
-	var msg nft.MsgSend
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	suite.Require().NoError(err)
-	suite.Require().True(operationMsg.OK)
-	suite.Require().Len(futureOperations, 0)
-}
-
-func TestSimTestSuite(t *testing.T) {
-	suite.Run(t, new(SimTestSuite))
-}
diff --git a/tests/sims/protocolpool/app_config.go b/tests/sims/protocolpool/app_config.go
deleted file mode 100644
index e388d4102e24..000000000000
--- a/tests/sims/protocolpool/app_config.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package protocolpool
-
-import (
-	_ "cosmossdk.io/x/accounts"       // import as blank for app wiring
-	_ "cosmossdk.io/x/auth"           // import as blank for app wiring
-	_ "cosmossdk.io/x/auth/tx/config" // import as blank for app wiring
-	_ "cosmossdk.io/x/bank"           // import as blank for app wiring
-	_ "cosmossdk.io/x/consensus"      // import as blank for app wiring
-	_ "cosmossdk.io/x/distribution"   // import as blank for app wiring
-	_ "cosmossdk.io/x/mint"           // import as blank for app wiring
-	_ "cosmossdk.io/x/protocolpool"   // import as blank for app wiring
-	_ "cosmossdk.io/x/staking"        // import as blank for app wiring
-
-	"github.com/cosmos/cosmos-sdk/testutil/configurator"
-	_ "github.com/cosmos/cosmos-sdk/x/genutil" // import as blank for app wiring
-)
-
-var AppConfig = configurator.NewAppConfig(
-	configurator.AccountsModule(),
-	configurator.AuthModule(),
-	configurator.BankModule(),
-	configurator.StakingModule(),
-	configurator.TxModule(),
-	configurator.ConsensusModule(),
-	configurator.GenutilModule(),
-	configurator.DistributionModule(),
-	configurator.MintModule(),
-	configurator.ProtocolPoolModule(),
-)
diff --git a/tests/sims/protocolpool/operations_test.go b/tests/sims/protocolpool/operations_test.go
deleted file mode 100644
index bdfaf0970c90..000000000000
--- a/tests/sims/protocolpool/operations_test.go
+++ /dev/null
@@ -1,148 +0,0 @@
-package protocolpool
-
-import (
-	"math/rand"
-	"testing"
-
-	"github.com/cosmos/gogoproto/proto"
-	"github.com/stretchr/testify/require"
-
-	"cosmossdk.io/depinject"
-	"cosmossdk.io/log"
-	authkeeper "cosmossdk.io/x/auth/keeper"
-	bankkeeper "cosmossdk.io/x/bank/keeper"
-	banktestutil "cosmossdk.io/x/bank/testutil"
-	"cosmossdk.io/x/protocolpool/keeper"
-	"cosmossdk.io/x/protocolpool/simulation"
-	"cosmossdk.io/x/protocolpool/types"
-	stakingkeeper "cosmossdk.io/x/staking/keeper"
-
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
-	"github.com/cosmos/cosmos-sdk/runtime"
-	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
-)
-
-type suite struct {
-	Ctx sdk.Context
-	App *runtime.App
-
-	TxConfig      client.TxConfig
-	Cdc           codec.Codec
-	AccountKeeper authkeeper.AccountKeeper
-	BankKeeper    bankkeeper.Keeper
-	StakingKeeper *stakingkeeper.Keeper
-	PoolKeeper    keeper.Keeper
-}
-
-func setUpTest(t *testing.T) suite {
-	t.Helper()
-	res := suite{}
-
-	var (
-		appBuilder *runtime.AppBuilder
-		err        error
-	)
-
-	app, err := simtestutil.Setup(
-		depinject.Configs(
-			AppConfig,
-			depinject.Supply(log.NewNopLogger()),
-		),
-		&res.AccountKeeper,
-		&res.BankKeeper,
-		&res.Cdc,
-		&appBuilder,
-		&res.StakingKeeper,
-		&res.PoolKeeper,
-		&res.TxConfig,
-	)
-	require.NoError(t, err)
-
-	res.App = app
-	res.Ctx = app.BaseApp.NewContext(false)
-	return res
-}
-
-// TestWeightedOperations tests the weights of the operations.
-func TestWeightedOperations(t *testing.T) {
-	suite := setUpTest(t)
-
-	appParams := make(simtypes.AppParams)
-
-	weightedOps := simulation.WeightedOperations(appParams, suite.Cdc, suite.TxConfig, suite.AccountKeeper,
-		suite.BankKeeper, suite.PoolKeeper)
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accs := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, suite.Ctx, 3)
-
-	expected := []struct {
-		weight     int
-		opMsgRoute string
-		opMsgName  string
-	}{
-		{simulation.DefaultWeightMsgFundCommunityPool, types.ModuleName, sdk.MsgTypeURL(&types.MsgFundCommunityPool{})},
-	}
-
-	for i, w := range weightedOps {
-		operationMsg, _, err := w.Op()(r, suite.App.BaseApp, suite.Ctx, accs, "")
-		require.NoError(t, err)
-
-		// the following checks are very much dependent from the ordering of the output given
-		// by WeightedOperations. if the ordering in WeightedOperations changes some tests
-		// will fail
-		require.Equal(t, expected[i].weight, w.Weight(), "weight should be the same")
-		require.Equal(t, expected[i].opMsgRoute, operationMsg.Route, "route should be the same")
-		require.Equal(t, expected[i].opMsgName, operationMsg.Name, "operation Msg name should be the same")
-	}
-}
-
-// TestSimulateMsgFundCommunityPool tests the normal scenario of a valid message of type TypeMsgFundCommunityPool.
-// Abonormal scenarios, where the message is created by an errors, are not tested here.
-func TestSimulateMsgFundCommunityPool(t *testing.T) {
-	suite := setUpTest(t)
-
-	// setup 3 accounts
-	s := rand.NewSource(1)
-	r := rand.New(s)
-	accounts := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, suite.Ctx, 3)
-
-	// execute operation
-	op := simulation.SimulateMsgFundCommunityPool(suite.TxConfig, suite.AccountKeeper, suite.BankKeeper, suite.PoolKeeper)
-	operationMsg, futureOperations, err := op(r, suite.App.BaseApp, suite.Ctx, accounts, "")
-	require.NoError(t, err)
-
-	var msg types.MsgFundCommunityPool
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	require.NoError(t, err)
-	require.True(t, operationMsg.OK)
-	require.Equal(t, "4896096stake", msg.Amount.String())
-	require.Equal(t, "cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r", msg.Depositor)
-	require.Equal(t, sdk.MsgTypeURL(&types.MsgFundCommunityPool{}), sdk.MsgTypeURL(&msg))
-	require.Len(t, futureOperations, 0)
-}
-
-func getTestingAccounts(
-	t *testing.T, r *rand.Rand,
-	accountKeeper authkeeper.AccountKeeper, bankKeeper bankkeeper.Keeper,
-	stakingKeeper *stakingkeeper.Keeper, ctx sdk.Context, n int,
-) []simtypes.Account {
-	t.Helper()
-	accounts := simtypes.RandomAccounts(r, n)
-
-	initAmt := stakingKeeper.TokensFromConsensusPower(ctx, 200)
-	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
-
-	// add coins to the accounts
-	for _, account := range accounts {
-		acc := accountKeeper.NewAccountWithAddress(ctx, account.Address)
-		accountKeeper.SetAccount(ctx, acc)
-		require.NoError(t, banktestutil.FundAccount(ctx, bankKeeper, account.Address, initCoins))
-	}
-
-	return accounts
-}
diff --git a/tests/sims/slashing/app_config.go b/tests/sims/slashing/app_config.go
deleted file mode 100644
index 038672031f21..000000000000
--- a/tests/sims/slashing/app_config.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package slashing
-
-import (
-	_ "cosmossdk.io/x/accounts"       // import as blank for app wiring
-	_ "cosmossdk.io/x/auth"           // import as blank for app wiring
-	_ "cosmossdk.io/x/auth/tx/config" // import as blank for app wiring
-	_ "cosmossdk.io/x/bank"           // import as blank for app wiring
-	_ "cosmossdk.io/x/consensus"      // import as blank for app wiring
-	_ "cosmossdk.io/x/distribution"   // import as blank for app wiring
-	_ "cosmossdk.io/x/mint"           // import as blank for app wiring
-	_ "cosmossdk.io/x/protocolpool"   // import as blank for app wiring
-	_ "cosmossdk.io/x/slashing"       // import as blank for app wiring
-	_ "cosmossdk.io/x/staking"        // import as blank for app wiring
-
-	"github.com/cosmos/cosmos-sdk/testutil/configurator"
-	_ "github.com/cosmos/cosmos-sdk/x/genutil" // import as blank for app wiring
-)
-
-var AppConfig = configurator.NewAppConfig(
-	configurator.AccountsModule(),
-	configurator.AuthModule(),
-	configurator.BankModule(),
-	configurator.StakingModule(),
-	configurator.SlashingModule(),
-	configurator.TxModule(),
-	configurator.ConsensusModule(),
-	configurator.GenutilModule(),
-	configurator.MintModule(),
-	configurator.DistributionModule(),
-	configurator.ProtocolPoolModule(),
-)
diff --git a/tests/sims/slashing/operations_test.go b/tests/sims/slashing/operations_test.go
deleted file mode 100644
index b0df7052dab2..000000000000
--- a/tests/sims/slashing/operations_test.go
+++ /dev/null
@@ -1,228 +0,0 @@
-package slashing
-
-import (
-	"fmt"
-	"math/rand"
-	"testing"
-	"time"
-
-	abci "github.com/cometbft/cometbft/api/cometbft/abci/v1"
-	cmttypes "github.com/cometbft/cometbft/types"
-	"github.com/cosmos/gogoproto/proto"
-	"github.com/stretchr/testify/suite"
-
-	"cosmossdk.io/collections"
-	"cosmossdk.io/core/header"
-	"cosmossdk.io/depinject"
-	"cosmossdk.io/log"
-	"cosmossdk.io/math"
-	authkeeper "cosmossdk.io/x/auth/keeper"
-	bankkeeper "cosmossdk.io/x/bank/keeper"
-	banktestutil "cosmossdk.io/x/bank/testutil"
-	distributionkeeper "cosmossdk.io/x/distribution/keeper"
-	distrtypes "cosmossdk.io/x/distribution/types"
-	mintkeeper "cosmossdk.io/x/mint/keeper"
-	minttypes "cosmossdk.io/x/mint/types"
-	slashingkeeper "cosmossdk.io/x/slashing/keeper"
-	"cosmossdk.io/x/slashing/simulation"
-	"cosmossdk.io/x/slashing/types"
-	stakingkeeper "cosmossdk.io/x/staking/keeper"
-	stakingtypes "cosmossdk.io/x/staking/types"
-
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
-	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
-	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
-	"github.com/cosmos/cosmos-sdk/runtime"
-	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
-)
-
-type SimTestSuite struct {
-	suite.Suite
-
-	ctx      sdk.Context
-	r        *rand.Rand
-	accounts []simtypes.Account
-
-	app               *runtime.App
-	codec             codec.Codec
-	interfaceRegistry codectypes.InterfaceRegistry
-	txConfig          client.TxConfig
-	accountKeeper     authkeeper.AccountKeeper
-	bankKeeper        bankkeeper.Keeper
-	stakingKeeper     *stakingkeeper.Keeper
-	slashingKeeper    slashingkeeper.Keeper
-	distrKeeper       distributionkeeper.Keeper
-	mintKeeper        mintkeeper.Keeper
-}
-
-func (suite *SimTestSuite) SetupTest() {
-	s := rand.NewSource(1)
-	suite.r = rand.New(s)
-	accounts := simtypes.RandomAccounts(suite.r, 4)
-
-	// create validator (non random as using a seed)
-	createValidator := func() (*cmttypes.ValidatorSet, error) {
-		account := accounts[0]
-		cmtPk, err := cryptocodec.ToCmtPubKeyInterface(account.ConsKey.PubKey())
-		if err != nil {
-			return nil, fmt.Errorf("failed to create pubkey: %w", err)
-		}
-
-		validator := cmttypes.NewValidator(cmtPk, 1)
-
-		return cmttypes.NewValidatorSet([]*cmttypes.Validator{validator}), nil
-	}
-
-	startupCfg := simtestutil.DefaultStartUpConfig()
-	startupCfg.ValidatorSet = createValidator
-
-	app, err := simtestutil.SetupWithConfiguration(
-		depinject.Configs(
-			AppConfig,
-			depinject.Supply(log.NewNopLogger()),
-		),
-		startupCfg,
-		&suite.codec,
-		&suite.interfaceRegistry,
-		&suite.txConfig,
-		&suite.accountKeeper,
-		&suite.bankKeeper,
-		&suite.stakingKeeper,
-		&suite.mintKeeper,
-		&suite.slashingKeeper,
-		&suite.distrKeeper,
-	)
-
-	suite.Require().NoError(err)
-	suite.app = app
-	suite.ctx = app.BaseApp.NewContext(false)
-
-	// remove genesis validator account
-	suite.accounts = accounts[1:]
-
-	initAmt := suite.stakingKeeper.TokensFromConsensusPower(suite.ctx, 200)
-	initCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, initAmt))
-
-	// add coins to the accounts
-	for _, account := range suite.accounts {
-		acc := suite.accountKeeper.NewAccountWithAddress(suite.ctx, account.Address)
-		suite.accountKeeper.SetAccount(suite.ctx, acc)
-		suite.Require().NoError(banktestutil.FundAccount(suite.ctx, suite.bankKeeper, account.Address, initCoins))
-	}
-	suite.Require().NoError(suite.mintKeeper.Params.Set(suite.ctx, minttypes.DefaultParams()))
-	suite.Require().NoError(suite.mintKeeper.Minter.Set(suite.ctx, minttypes.DefaultInitialMinter()))
-}
-
-func TestSimTestSuite(t *testing.T) {
-	suite.Run(t, new(SimTestSuite))
-}
-
-// TestWeightedOperations tests the weights of the operations.
-func (suite *SimTestSuite) TestWeightedOperations() {
-	ctx := suite.ctx.WithChainID("test-chain")
-	appParams := make(simtypes.AppParams)
-
-	expected := []struct {
-		weight     int
-		opMsgRoute string
-		opMsgName  string
-	}{
-		{simulation.DefaultWeightMsgUnjail, types.ModuleName, sdk.MsgTypeURL(&types.MsgUnjail{})},
-	}
-
-	weightedOps := simulation.WeightedOperations(suite.interfaceRegistry, appParams, suite.codec, suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.slashingKeeper, suite.stakingKeeper)
-	for i, w := range weightedOps {
-		operationMsg, _, err := w.Op()(suite.r, suite.app.BaseApp, ctx, suite.accounts, ctx.ChainID())
-		suite.Require().NoError(err)
-
-		// the following checks are very much dependent from the ordering of the output given
-		// by WeightedOperations. if the ordering in WeightedOperations changes some tests
-		// will fail
-		suite.Require().Equal(expected[i].weight, w.Weight(), "weight should be the same")
-		suite.Require().Equal(expected[i].opMsgRoute, operationMsg.Route, "route should be the same")
-		suite.Require().Equal(expected[i].opMsgName, operationMsg.Name, "operation Msg name should be the same")
-	}
-}
-
-// TestSimulateMsgUnjail tests the normal scenario of a valid message of type types.MsgUnjail.
-// Abonormal scenarios, where the message is created by an errors, are not tested here.
-func (suite *SimTestSuite) TestSimulateMsgUnjail() {
-	blockTime := time.Now().UTC()
-	ctx := suite.ctx.WithHeaderInfo(header.Info{Time: blockTime})
-
-	// setup accounts[0] as validator0
-	validator0, err := getTestingValidator0(ctx, suite.stakingKeeper, suite.accounts)
-	suite.Require().NoError(err)
-
-	// setup validator0 by consensus address
-	err = suite.stakingKeeper.SetValidatorByConsAddr(ctx, validator0)
-	suite.Require().NoError(err)
-
-	val0ConsAddress, err := validator0.GetConsAddr()
-	suite.Require().NoError(err)
-	val0ConsAddressStr, err := suite.stakingKeeper.ConsensusAddressCodec().BytesToString(val0ConsAddress)
-	suite.Require().NoError(err)
-	info := types.NewValidatorSigningInfo(val0ConsAddressStr, int64(4),
-		time.Unix(2, 0), false, int64(10))
-	err = suite.slashingKeeper.ValidatorSigningInfo.Set(ctx, val0ConsAddress, info)
-	suite.Require().NoError(err)
-	// put validator0 in jail
-	suite.Require().NoError(suite.stakingKeeper.Jail(ctx, val0ConsAddress))
-
-	// setup self delegation
-	delTokens := suite.stakingKeeper.TokensFromConsensusPower(ctx, 2)
-	validator0, issuedShares := validator0.AddTokensFromDel(delTokens)
-	val0AccAddress, err := sdk.ValAddressFromBech32(validator0.OperatorAddress)
-	suite.Require().NoError(err)
-	selfDelegation := stakingtypes.NewDelegation(suite.accounts[0].Address.String(), validator0.GetOperator(), issuedShares)
-	suite.Require().NoError(suite.stakingKeeper.SetDelegation(ctx, selfDelegation))
-	suite.Require().NoError(suite.distrKeeper.DelegatorStartingInfo.Set(ctx, collections.Join(val0AccAddress, sdk.AccAddress(val0AccAddress)), distrtypes.NewDelegatorStartingInfo(2, math.LegacyOneDec(), 200)))
-
-	// begin a new block
-	_, err = suite.app.FinalizeBlock(&abci.FinalizeBlockRequest{Height: suite.app.LastBlockHeight() + 1, Hash: suite.app.LastCommitID().Hash, Time: blockTime})
-	suite.Require().NoError(err)
-
-	// execute operation
-	op := simulation.SimulateMsgUnjail(codec.NewProtoCodec(suite.interfaceRegistry), suite.txConfig, suite.accountKeeper, suite.bankKeeper, suite.slashingKeeper, suite.stakingKeeper)
-	operationMsg, futureOperations, err := op(suite.r, suite.app.BaseApp, ctx, suite.accounts, "")
-	suite.Require().NoError(err)
-
-	var msg types.MsgUnjail
-	err = proto.Unmarshal(operationMsg.Msg, &msg)
-	suite.Require().NoError(err)
-	suite.Require().True(operationMsg.OK)
-	suite.Require().Equal("cosmosvaloper1p8wcgrjr4pjju90xg6u9cgq55dxwq8j7epjs3u", msg.ValidatorAddr)
-	suite.Require().Len(futureOperations, 0)
-}
-
-func getTestingValidator0(ctx sdk.Context, stakingKeeper *stakingkeeper.Keeper, accounts []simtypes.Account) (stakingtypes.Validator, error) {
-	commission0 := stakingtypes.NewCommission(math.LegacyZeroDec(), math.LegacyOneDec(), math.LegacyOneDec())
-	return getTestingValidator(ctx, stakingKeeper, accounts, commission0, 0)
-}
-
-func getTestingValidator(ctx sdk.Context, stakingKeeper *stakingkeeper.Keeper, accounts []simtypes.Account, commission stakingtypes.Commission, n int) (stakingtypes.Validator, error) {
-	account := accounts[n]
-	valPubKey := account.ConsKey.PubKey()
-	valAddr := sdk.ValAddress(account.PubKey.Address().Bytes())
-	validator, err := stakingtypes.NewValidator(valAddr.String(), valPubKey, stakingtypes.Description{})
-	if err != nil {
-		return stakingtypes.Validator{}, fmt.Errorf("failed to create validator: %w", err)
-	}
-
-	validator, err = validator.SetInitialCommission(commission)
-	if err != nil {
-		return stakingtypes.Validator{}, fmt.Errorf("failed to set initial commission: %w", err)
-	}
-
-	validator.DelegatorShares = math.LegacyNewDec(100)
-	validator.Tokens = math.NewInt(1000000)
-
-	err = stakingKeeper.SetValidator(ctx, validator)
-	if err != nil {
-		return stakingtypes.Validator{}, err
-	}
-	return validator, nil
-}
diff --git a/testutil/sims/simulation_helpers.go b/testutil/sims/simulation_helpers.go
index 1712d9986ac5..e88135f458a1 100644
--- a/testutil/sims/simulation_helpers.go
+++ b/testutil/sims/simulation_helpers.go
@@ -9,76 +9,13 @@ import (
 
 	dbm "github.com/cosmos/cosmos-db"
 
-	"cosmossdk.io/log"
 	storetypes "cosmossdk.io/store/types"
 
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/runtime"
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/kv"
-	"github.com/cosmos/cosmos-sdk/types/module"
 	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
 )
 
-// SetupSimulation creates the config, db (levelDB), temporary directory and logger for the simulation tests.
-// If `skip` is false it skips the current test. `skip` should be set using the `FlagEnabledValue` flag.
-// Returns error on an invalid db instantiation or temp dir creation.
-func SetupSimulation(config simtypes.Config, dirPrefix, dbName string, verbose, skip bool) (dbm.DB, string, log.Logger, bool, error) {
-	if !skip {
-		return nil, "", nil, true, nil
-	}
-
-	var logger log.Logger
-	if verbose {
-		logger = log.NewLogger(os.Stdout)
-	} else {
-		logger = log.NewNopLogger()
-	}
-
-	dir, err := os.MkdirTemp("", dirPrefix)
-	if err != nil {
-		return nil, "", nil, false, err
-	}
-
-	db, err := dbm.NewDB(dbName, dbm.BackendType(config.DBBackend), dir)
-	if err != nil {
-		return nil, "", nil, false, err
-	}
-
-	return db, dir, logger, false, nil
-}
-
-// SimulationOperations retrieves the simulation params from the provided file path
-// and returns all the modules weighted operations
-func SimulationOperations(app runtime.AppSimI, cdc codec.Codec, config simtypes.Config, txConfig client.TxConfig) []simtypes.WeightedOperation {
-	signingCtx := cdc.InterfaceRegistry().SigningContext()
-	simState := module.SimulationState{
-		AppParams:      make(simtypes.AppParams),
-		Cdc:            cdc,
-		AddressCodec:   signingCtx.AddressCodec(),
-		ValidatorCodec: signingCtx.ValidatorAddressCodec(),
-		TxConfig:       txConfig,
-		BondDenom:      sdk.DefaultBondDenom,
-	}
-
-	if config.ParamsFile != "" {
-		bz, err := os.ReadFile(config.ParamsFile)
-		if err != nil {
-			panic(err)
-		}
-
-		err = json.Unmarshal(bz, &simState.AppParams)
-		if err != nil {
-			panic(err)
-		}
-	}
-
-	simState.LegacyProposalContents = app.SimulationManager().GetProposalContents(simState) //nolint:staticcheck // we're testing the old way here
-	simState.ProposalMsgs = app.SimulationManager().GetProposalMsgs(simState)
-	return app.SimulationManager().WeightedOperations(simState)
-}
-
 // CheckExportSimulation exports the app state and simulation parameters to JSON
 // if the export paths are defined.
 func CheckExportSimulation(app runtime.AppSimI, config simtypes.Config, params simtypes.Params) error {
@@ -109,10 +46,10 @@ func CheckExportSimulation(app runtime.AppSimI, config simtypes.Config, params s
 }
 
 // PrintStats prints the corresponding statistics from the app DB.
-func PrintStats(db dbm.DB) {
-	fmt.Println("\nLevelDB Stats")
-	fmt.Println(db.Stats()["leveldb.stats"])
-	fmt.Println("LevelDB cached block size", db.Stats()["leveldb.cachedblock"])
+func PrintStats(db dbm.DB, logLine func(args ...any)) {
+	logLine("\nLevelDB Stats")
+	logLine(db.Stats()["leveldb.stats"])
+	logLine("LevelDB cached block size", db.Stats()["leveldb.cachedblock"])
 }
 
 // GetSimulationLog unmarshals the KVPair's Value to the corresponding type based on the
diff --git a/testutil/sims/state_helpers.go b/testutil/sims/state_helpers.go
index 631ec379b81f..0b97aa66bac2 100644
--- a/testutil/sims/state_helpers.go
+++ b/testutil/sims/state_helpers.go
@@ -2,8 +2,9 @@ package sims
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/json"
-	"errors"
+	"fmt"
 	"io"
 	"math/rand"
 	"os"
@@ -250,31 +251,38 @@ func AppStateRandomizedFn(
 
 // AppStateFromGenesisFileFn util function to generate the genesis AppState
 // from a genesis.json file.
-func AppStateFromGenesisFileFn(r io.Reader, cdc codec.JSONCodec, genesisFile string) (genutiltypes.AppGenesis, []simtypes.Account, error) {
+func AppStateFromGenesisFileFn(_ io.Reader, cdc codec.JSONCodec, genesisFile string) (genutiltypes.AppGenesis, []simtypes.Account, error) {
 	file, err := os.Open(filepath.Clean(genesisFile))
 	if err != nil {
 		panic(err)
 	}
+	defer file.Close()
 
 	genesis, err := genutiltypes.AppGenesisFromReader(bufio.NewReader(file))
 	if err != nil {
-		return *genesis, nil, err
+		return genutiltypes.AppGenesis{}, nil, err
 	}
 
-	if err := file.Close(); err != nil {
-		return *genesis, nil, err
+	appStateJSON := genesis.AppState
+	newAccs, err := AccountsFromAppState(cdc, appStateJSON)
+	if err != nil {
+		panic(err)
 	}
 
+	return *genesis, newAccs, nil
+}
+
+func AccountsFromAppState(cdc codec.JSONCodec, appStateJSON json.RawMessage) ([]simtypes.Account, error) {
 	var appState map[string]json.RawMessage
-	if err = json.Unmarshal(genesis.AppState, &appState); err != nil {
-		return *genesis, nil, err
+	if err := json.Unmarshal(appStateJSON, &appState); err != nil {
+		return nil, err
 	}
 
 	var authGenesis authtypes.GenesisState
 	if appState[testutil.AuthModuleName] != nil {
 		cdc.MustUnmarshalJSON(appState[testutil.AuthModuleName], &authGenesis)
 	}
-
+	r := bufio.NewReader(bytes.NewReader(appStateJSON)) // any deterministic source
 	newAccs := make([]simtypes.Account, len(authGenesis.Accounts))
 	for i, acc := range authGenesis.Accounts {
 		// Pick a random private key, since we don't know the actual key
@@ -282,20 +290,19 @@ func AppStateFromGenesisFileFn(r io.Reader, cdc codec.JSONCodec, genesisFile str
 		// and these keys are never actually used to sign by mock CometBFT.
 		privkeySeed := make([]byte, 15)
 		if _, err := r.Read(privkeySeed); err != nil {
-			panic(err)
+			return nil, err
 		}
 
 		privKey := secp256k1.GenPrivKeyFromSecret(privkeySeed)
 
 		a, ok := acc.GetCachedValue().(sdk.AccountI)
 		if !ok {
-			return *genesis, nil, errors.New("expected account")
+			return nil, fmt.Errorf("expected account")
 		}
 
 		// create simulator accounts
 		simAcc := simtypes.Account{PrivKey: privKey, PubKey: privKey.PubKey(), Address: a.GetAddress(), ConsKey: ed25519.GenPrivKeyFromSecret(privkeySeed)}
 		newAccs[i] = simAcc
 	}
-
-	return *genesis, newAccs, nil
+	return newAccs, nil
 }
diff --git a/testutils/sims/runner.go b/testutils/sims/runner.go
index 34acc544bdc0..6b9b6a09e535 100644
--- a/testutils/sims/runner.go
+++ b/testutils/sims/runner.go
@@ -1,15 +1,18 @@
 package sims
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
+	"os"
 	"path/filepath"
 	"testing"
 
 	dbm "github.com/cosmos/cosmos-db"
 	"github.com/stretchr/testify/require"
 
-	"cosmossdk.io/log"
+	"cosmossdk.io/core/log"
+	tlog "cosmossdk.io/log"
 
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	"github.com/cosmos/cosmos-sdk/client"
@@ -18,7 +21,10 @@ import (
 	"github.com/cosmos/cosmos-sdk/runtime"
 	"github.com/cosmos/cosmos-sdk/server"
 	servertypes "github.com/cosmos/cosmos-sdk/server/types"
+	"github.com/cosmos/cosmos-sdk/simsx"
 	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
 	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
 	"github.com/cosmos/cosmos-sdk/x/simulation"
 	"github.com/cosmos/cosmos-sdk/x/simulation/client/cli"
@@ -66,7 +72,7 @@ func Run[T SimulationApp](
 		baseAppOptions ...func(*baseapp.BaseApp),
 	) T,
 	setupStateFactory func(app T) SimStateFactory,
-	postRunActions ...func(t *testing.T, app TestInstance[T]),
+	postRunActions ...func(t testing.TB, app TestInstance[T]),
 ) {
 	t.Helper()
 	RunWithSeeds(t, appFactory, setupStateFactory, defaultSeeds, nil, postRunActions...)
@@ -80,7 +86,7 @@ func Run[T SimulationApp](
 // The execution is deterministic and can be used for fuzz tests as well.
 //
 // The system under test is isolated for each run but unlike the old runsim command, there is no Process separation.
-// This means, global caches may be reused for example. This implementation build upon the vanialla Go stdlib test framework.
+// This means, global caches may be reused for example. This implementation build upon the vanilla Go stdlib test framework.
 func RunWithSeeds[T SimulationApp](
 	t *testing.T,
 	appFactory func(
@@ -94,7 +100,7 @@ func RunWithSeeds[T SimulationApp](
 	setupStateFactory func(app T) SimStateFactory,
 	seeds []int64,
 	fuzzSeed []byte,
-	postRunActions ...func(t *testing.T, app TestInstance[T]),
+	postRunActions ...func(t testing.TB, app TestInstance[T]),
 ) {
 	t.Helper()
 	cfg := cli.NewConfigFromFlags()
@@ -103,46 +109,82 @@ func RunWithSeeds[T SimulationApp](
 		seed := seeds[i]
 		t.Run(fmt.Sprintf("seed: %d", seed), func(t *testing.T) {
 			t.Parallel()
-			// setup environment
-			tCfg := cfg.With(t, seed, fuzzSeed)
-			testInstance := NewSimulationAppInstance(t, tCfg, appFactory)
-			var runLogger log.Logger
-			if cli.FlagVerboseValue {
-				runLogger = log.NewTestLogger(t)
-			} else {
-				runLogger = log.NewTestLoggerInfo(t)
-			}
-			runLogger = runLogger.With("seed", tCfg.Seed)
-
-			app := testInstance.App
-			stateFactory := setupStateFactory(app)
-			simParams, err := simulation.SimulateFromSeedX(
-				t,
-				runLogger,
-				WriteToDebugLog(runLogger),
-				app.GetBaseApp(),
-				stateFactory.AppStateFn,
-				simtypes.RandomAccounts, // Replace with own random account function if using keys other than secp256k1
-				simtestutil.SimulationOperations(app, stateFactory.Codec, tCfg, testInstance.App.TxConfig()),
-				stateFactory.BlockedAddr,
-				tCfg,
-				stateFactory.Codec,
-				app.TxConfig().SigningContext().AddressCodec(),
-				testInstance.ExecLogWriter,
-			)
-			require.NoError(t, err)
-			err = simtestutil.CheckExportSimulation(app, tCfg, simParams)
-			require.NoError(t, err)
-			if tCfg.Commit {
-				simtestutil.PrintStats(testInstance.DB)
-			}
-			for _, step := range postRunActions {
-				step(t, testInstance)
-			}
+			RunWithSeed(t, cfg, appFactory, setupStateFactory, seed, fuzzSeed, postRunActions...)
 		})
 	}
 }
 
+func RunWithSeed[T SimulationApp](
+	tb testing.TB,
+	cfg simtypes.Config,
+	appFactory func(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest bool, appOpts servertypes.AppOptions, baseAppOptions ...func(*baseapp.BaseApp)) T,
+	setupStateFactory func(app T) SimStateFactory,
+	seed int64,
+	fuzzSeed []byte,
+	postRunActions ...func(t testing.TB, app TestInstance[T]),
+) {
+	tb.Helper()
+	// setup environment
+	tCfg := cfg.With(tb, seed, fuzzSeed)
+	testInstance := NewSimulationAppInstance(tb, tCfg, appFactory)
+	var runLogger tlog.Logger
+	if cli.FlagVerboseValue {
+		runLogger = tlog.NewTestLogger(tb)
+	} else {
+		runLogger = tlog.NewTestLoggerInfo(tb)
+	}
+	runLogger = runLogger.With("seed", tCfg.Seed)
+
+	app := testInstance.App
+	stateFactory := setupStateFactory(app)
+	ops, reporter := prepareWeightedOps(app.SimulationManager(), stateFactory, tCfg, testInstance.App.TxConfig(), runLogger)
+	simParams, err := simulation.SimulateFromSeedX(tb, runLogger, WriteToDebugLog(runLogger), app.GetBaseApp(), stateFactory.AppStateFn, simtypes.RandomAccounts, ops, stateFactory.BlockedAddr, tCfg, stateFactory.Codec, testInstance.ExecLogWriter)
+	require.NoError(tb, err)
+	err = simtestutil.CheckExportSimulation(app, tCfg, simParams)
+	require.NoError(tb, err)
+	if tCfg.Commit {
+		simtestutil.PrintStats(testInstance.DB, tb.Log)
+	}
+	// not using tb.Log to always print the summary
+	fmt.Printf("+++ DONE (seed: %d): \n%s\n", seed, reporter.Summary().String())
+	for _, step := range postRunActions {
+		step(tb, testInstance)
+	}
+}
+
+type (
+	HasWeightedOperationsX interface {
+		WeightedOperationsX(weight simsx.WeightSource, reg simsx.Registry)
+	}
+	HasWeightedOperationsXWithProposals interface {
+		WeightedOperationsX(weights simsx.WeightSource, reg simsx.Registry, proposals []simtypes.WeightedProposalMsg,
+			legacyProposals []simtypes.WeightedProposalContent) //nolint: staticcheck // used for legacy proposal types
+	}
+	HasProposalMsgsX interface {
+		ProposalMsgsX(weights simsx.WeightSource, reg simsx.Registry)
+	}
+)
+
+type (
+	HasLegacyWeightedOperations interface {
+		// WeightedOperations simulation operations (i.e msgs) with their respective weight
+		WeightedOperations(simState module.SimulationState) []simtypes.WeightedOperation
+	}
+	// HasLegacyProposalMsgs defines the messages that can be used to simulate governance (v1) proposals
+	// Deprecated replaced by HasProposalMsgsX
+	HasLegacyProposalMsgs interface {
+		// ProposalMsgs msg fu	nctions used to simulate governance proposals
+		ProposalMsgs(simState module.SimulationState) []simtypes.WeightedProposalMsg
+	}
+
+	// HasLegacyProposalContents defines the contents that can be used to simulate legacy governance (v1beta1) proposals
+	// Deprecated replaced by HasProposalMsgsX
+	HasLegacyProposalContents interface {
+		// ProposalContents content functions used to simulate governance proposals
+		ProposalContents(simState module.SimulationState) []simtypes.WeightedProposalContent //nolint:staticcheck // legacy v1beta1 governance
+	}
+)
+
 // TestInstance is a generic type that represents an instance of a SimulationApp used for testing simulations.
 // It contains the following fields:
 //   - App: The instance of the SimulationApp under test.
@@ -151,6 +193,73 @@ func RunWithSeeds[T SimulationApp](
 //   - Cfg: The configuration flags for the simulator.
 //   - AppLogger: The logger used for logging in the app during the simulation, with seed value attached.
 //   - ExecLogWriter: Captures block and operation data coming from the simulation
+//
+// included to avoid cyclic dependency in testutils/sims
+func prepareWeightedOps(
+	sm *module.SimulationManager,
+	stateFact SimStateFactory,
+	config simtypes.Config,
+	txConfig client.TxConfig,
+	logger log.Logger,
+) (simulation.WeightedOperations, *simsx.BasicSimulationReporter) {
+	cdc := stateFact.Codec
+	signingCtx := cdc.InterfaceRegistry().SigningContext()
+	simState := module.SimulationState{
+		AppParams:      make(simtypes.AppParams),
+		Cdc:            cdc,
+		AddressCodec:   signingCtx.AddressCodec(),
+		ValidatorCodec: signingCtx.ValidatorAddressCodec(),
+		TxConfig:       txConfig,
+		BondDenom:      sdk.DefaultBondDenom,
+	}
+
+	if config.ParamsFile != "" {
+		bz, err := os.ReadFile(config.ParamsFile)
+		if err != nil {
+			panic(err)
+		}
+
+		err = json.Unmarshal(bz, &simState.AppParams)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	simState.LegacyProposalContents = sm.GetProposalContents(simState) //nolint:staticcheck // we're testing the old way here
+
+	weights := simsx.ParamWeightSource(simState.AppParams)
+	reporter := simsx.NewBasicSimulationReporter()
+
+	pReg := simsx.NewSimsProposalRegistryAdapter(reporter, sm.AccountSource, sm.BalanceSource, txConfig.SigningContext().AddressCodec(), logger)
+	wProps := make([]simtypes.WeightedProposalMsg, 0, len(sm.Modules))
+
+	// add gov proposals types
+	for _, m := range sm.Modules {
+		switch xm := m.(type) {
+		case HasProposalMsgsX:
+			xm.ProposalMsgsX(weights, pReg)
+		case HasLegacyProposalMsgs:
+			wProps = append(wProps, xm.ProposalMsgs(simState)...)
+		}
+	}
+	simState.ProposalMsgs = append(wProps, pReg.ToLegacyObjects()...)
+
+	oReg := simsx.NewSimsMsgRegistryAdapter(reporter, sm.AccountSource, sm.BalanceSource, txConfig, logger)
+	wOps := make([]simtypes.WeightedOperation, 0, len(sm.Modules))
+	for _, m := range sm.Modules {
+		// add operations
+		switch xm := m.(type) {
+		case HasWeightedOperationsX:
+			xm.WeightedOperationsX(weights, oReg)
+		case HasWeightedOperationsXWithProposals:
+			xm.WeightedOperationsX(weights, oReg, simState.ProposalMsgs, simState.LegacyProposalContents)
+		case HasLegacyWeightedOperations:
+			wOps = append(wOps, xm.WeightedOperations(simState)...)
+		}
+	}
+	return append(wOps, oReg.ToLegacyObjects()...), reporter
+}
+
 type TestInstance[T SimulationApp] struct {
 	App           T
 	DB            dbm.DB
@@ -166,31 +275,34 @@ type TestInstance[T SimulationApp] struct {
 // The function then initializes a logger based on the verbosity flag and sets the logger's seed to the test configuration's seed.
 // The database is closed and cleaned up on test completion.
 func NewSimulationAppInstance[T SimulationApp](
-	t *testing.T,
+	tb testing.TB,
 	tCfg simtypes.Config,
 	appFactory func(logger log.Logger, db dbm.DB, traceStore io.Writer, loadLatest bool, appOpts servertypes.AppOptions, baseAppOptions ...func(*baseapp.BaseApp)) T,
 ) TestInstance[T] {
-	t.Helper()
-	workDir := t.TempDir()
+	tb.Helper()
+	workDir := tb.TempDir()
 	dbDir := filepath.Join(workDir, "leveldb-app-sim")
-	var logger log.Logger
+	var logger tlog.Logger
 	if cli.FlagVerboseValue {
-		logger = log.NewTestLogger(t)
+		logger = tlog.NewTestLogger(tb)
 	} else {
-		logger = log.NewTestLoggerError(t)
+		logger = tlog.NewTestLoggerError(tb)
 	}
 	logger = logger.With("seed", tCfg.Seed)
 
 	db, err := dbm.NewDB("Simulation", dbm.BackendType(tCfg.DBBackend), dbDir)
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		require.NoError(t, db.Close())
+	require.NoError(tb, err)
+	tb.Cleanup(func() {
+		require.NoError(tb, db.Close())
 	})
 	appOptions := make(simtestutil.AppOptionsMap)
 	appOptions[flags.FlagHome] = workDir
 	appOptions[server.FlagInvCheckPeriod] = cli.FlagPeriodValue
-
-	app := appFactory(logger, db, nil, true, appOptions, baseapp.SetChainID(SimAppChainID))
+	opts := []func(*baseapp.BaseApp){baseapp.SetChainID(SimAppChainID)}
+	if tCfg.FauxMerkle {
+		opts = append(opts, FauxMerkleModeOpt)
+	}
+	app := appFactory(logger, db, nil, true, appOptions, opts...)
 	if !cli.FlagSigverifyTxValue {
 		app.SetNotSigverifyTx()
 	}
diff --git a/types/module/simulation.go b/types/module/simulation.go
index 20bb46ba1976..22767cbb8d82 100644
--- a/types/module/simulation.go
+++ b/types/module/simulation.go
@@ -1,6 +1,7 @@
 package module
 
 import (
+	"context"
 	"encoding/json"
 	"math/rand"
 	"sort"
@@ -12,48 +13,68 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/simulation"
 )
 
 // AppModuleSimulation defines the standard functions that every module should expose
 // for the SDK blockchain simulator
 type AppModuleSimulation interface {
-	// randomized genesis states
+	// GenerateGenesisState randomized genesis states
 	GenerateGenesisState(input *SimulationState)
 
-	// register a func to decode the each module's defined types from their corresponding store key
+	// RegisterStoreDecoder register a func to decode the each module's defined types from their corresponding store key
 	RegisterStoreDecoder(simulation.StoreDecoderRegistry)
-
-	// simulation operations (i.e msgs) with their respective weight
-	WeightedOperations(simState SimulationState) []simulation.WeightedOperation
 }
+type (
+	HasLegacyWeightedOperations interface {
+		// WeightedOperations simulation operations (i.e msgs) with their respective weight
+		WeightedOperations(simState SimulationState) []simulation.WeightedOperation
+	}
+	// HasLegacyProposalMsgs defines the messages that can be used to simulate governance (v1) proposals
+	// Deprecated replaced by HasProposalMsgsX
+	HasLegacyProposalMsgs interface {
+		// ProposalMsgs msg functions used to simulate governance proposals
+		ProposalMsgs(simState SimulationState) []simulation.WeightedProposalMsg
+	}
 
-// HasProposalMsgs defines the messages that can be used to simulate governance (v1) proposals
-type HasProposalMsgs interface {
-	// msg functions used to simulate governance proposals
-	ProposalMsgs(simState SimulationState) []simulation.WeightedProposalMsg
-}
+	// HasLegacyProposalContents defines the contents that can be used to simulate legacy governance (v1beta1) proposals
+	// Deprecated replaced by HasProposalMsgsX
+	HasLegacyProposalContents interface {
+		// ProposalContents content functions used to simulate governance proposals
+		ProposalContents(simState SimulationState) []simulation.WeightedProposalContent //nolint:staticcheck // legacy v1beta1 governance
+	}
+)
 
-// HasProposalContents defines the contents that can be used to simulate legacy governance (v1beta1) proposals
-type HasProposalContents interface {
-	// content functions used to simulate governance proposals
-	ProposalContents(simState SimulationState) []simulation.WeightedProposalContent //nolint:staticcheck // legacy v1beta1 governance
-}
+type (
+	AccountSource interface {
+		GetAccount(ctx context.Context, addr sdk.AccAddress) sdk.AccountI
+		GetModuleAddress(moduleName string) sdk.AccAddress
+	}
+	BalanceSource interface {
+		SpendableCoins(ctx context.Context, addr sdk.AccAddress) sdk.Coins
+		IsSendEnabledDenom(ctx context.Context, denom string) bool
+	}
+)
 
 // SimulationManager defines a simulation manager that provides the high level utility
 // for managing and executing simulation functionalities for a group of modules
 type SimulationManager struct {
 	Modules       []AppModuleSimulation           // array of app modules; we use an array for deterministic simulation tests
 	StoreDecoders simulation.StoreDecoderRegistry // functions to decode the key-value pairs from each module's store
+	AccountSource AccountSource
+	BalanceSource BalanceSource
 }
 
 // NewSimulationManager creates a new SimulationManager object
 //
 // CONTRACT: All the modules provided must be also registered on the module Manager
-func NewSimulationManager(modules ...AppModuleSimulation) *SimulationManager {
+func NewSimulationManager(ak AccountSource, bk BalanceSource, modules ...AppModuleSimulation) *SimulationManager {
 	return &SimulationManager{
 		Modules:       modules,
 		StoreDecoders: make(simulation.StoreDecoderRegistry),
+		AccountSource: ak,
+		BalanceSource: bk,
 	}
 }
 
@@ -63,15 +84,14 @@ func NewSimulationManager(modules ...AppModuleSimulation) *SimulationManager {
 // with the same moduleName.
 // Then it attempts to cast every provided AppModule into an AppModuleSimulation.
 // If the cast succeeds, its included, otherwise it is excluded.
-func NewSimulationManagerFromAppModules(modules map[string]appmodule.AppModule, overrideModules map[string]AppModuleSimulation) *SimulationManager {
-	simModules := []AppModuleSimulation{}
+func NewSimulationManagerFromAppModules(ak AccountSource, bk BalanceSource, modules map[string]appmodule.AppModule, overrideModules map[string]AppModuleSimulation) *SimulationManager {
 	appModuleNamesSorted := make([]string, 0, len(modules))
 	for moduleName := range modules {
 		appModuleNamesSorted = append(appModuleNamesSorted, moduleName)
 	}
-
 	sort.Strings(appModuleNamesSorted)
 
+	var simModules []AppModuleSimulation
 	for _, moduleName := range appModuleNamesSorted {
 		// for every module, see if we override it. If so, use override.
 		// Else, if we can cast the app module into a simulation module add it.
@@ -86,7 +106,7 @@ func NewSimulationManagerFromAppModules(modules map[string]appmodule.AppModule,
 			// cannot cast, so we continue
 		}
 	}
-	return NewSimulationManager(simModules...)
+	return NewSimulationManager(ak, bk, simModules...)
 }
 
 // Deprecated: Use GetProposalMsgs instead.
@@ -95,7 +115,7 @@ func NewSimulationManagerFromAppModules(modules map[string]appmodule.AppModule,
 func (sm *SimulationManager) GetProposalContents(simState SimulationState) []simulation.WeightedProposalContent {
 	wContents := make([]simulation.WeightedProposalContent, 0, len(sm.Modules))
 	for _, module := range sm.Modules {
-		if module, ok := module.(HasProposalContents); ok {
+		if module, ok := module.(HasLegacyProposalContents); ok {
 			wContents = append(wContents, module.ProposalContents(simState)...)
 		}
 	}
@@ -103,19 +123,6 @@ func (sm *SimulationManager) GetProposalContents(simState SimulationState) []sim
 	return wContents
 }
 
-// GetProposalMsgs returns each module's proposal msg generator function
-// with their default operation weight and key.
-func (sm *SimulationManager) GetProposalMsgs(simState SimulationState) []simulation.WeightedProposalMsg {
-	wContents := make([]simulation.WeightedProposalMsg, 0, len(sm.Modules))
-	for _, module := range sm.Modules {
-		if module, ok := module.(HasProposalMsgs); ok {
-			wContents = append(wContents, module.ProposalMsgs(simState)...)
-		}
-	}
-
-	return wContents
-}
-
 // RegisterStoreDecoders registers each of the modules' store decoders into a map
 func (sm *SimulationManager) RegisterStoreDecoders() {
 	for _, module := range sm.Modules {
@@ -131,16 +138,6 @@ func (sm *SimulationManager) GenerateGenesisStates(simState *SimulationState) {
 	}
 }
 
-// WeightedOperations returns all the modules' weighted operations of an application
-func (sm *SimulationManager) WeightedOperations(simState SimulationState) []simulation.WeightedOperation {
-	wOps := make([]simulation.WeightedOperation, 0, len(sm.Modules))
-	for _, module := range sm.Modules {
-		wOps = append(wOps, module.WeightedOperations(simState)...)
-	}
-
-	return wOps
-}
-
 // SimulationState is the input parameters used on each of the module's randomized
 // GenesisState generator function
 type SimulationState struct {
diff --git a/types/simulation/account.go b/types/simulation/account.go
index d046ea23e284..0bc7c79fc1f3 100644
--- a/types/simulation/account.go
+++ b/types/simulation/account.go
@@ -14,10 +14,11 @@ import (
 // eventually more useful data can be placed in here.
 // (e.g. number of coins)
 type Account struct {
-	PrivKey cryptotypes.PrivKey
-	PubKey  cryptotypes.PubKey
-	Address sdk.AccAddress
-	ConsKey cryptotypes.PrivKey
+	PrivKey       cryptotypes.PrivKey
+	PubKey        cryptotypes.PubKey
+	Address       sdk.AccAddress
+	ConsKey       cryptotypes.PrivKey
+	AddressBech32 string
 }
 
 // Equals returns true if two accounts are equal
@@ -50,10 +51,11 @@ func RandomAccounts(r *rand.Rand, n int) []Account {
 		}
 		idx[string(addr.Bytes())] = struct{}{}
 		accs[i] = Account{
-			Address: addr,
-			PrivKey: privKey,
-			PubKey:  pubKey,
-			ConsKey: ed25519.GenPrivKeyFromSecret(privkeySeed),
+			Address:       addr,
+			PrivKey:       privKey,
+			PubKey:        pubKey,
+			ConsKey:       ed25519.GenPrivKeyFromSecret(privkeySeed),
+			AddressBech32: addr.String(),
 		}
 		i++
 	}
diff --git a/types/simulation/config.go b/types/simulation/config.go
index 07cd6d4c69d5..6f93684d0822 100644
--- a/types/simulation/config.go
+++ b/types/simulation/config.go
@@ -25,7 +25,8 @@ type Config struct {
 	DBBackend   string // custom db backend type
 	BlockMaxGas int64  // custom max gas for block
 	FuzzSeed    []byte
-	T           testing.TB
+	TB          testing.TB
+	FauxMerkle  bool
 }
 
 func (c Config) shallowCopy() Config {
@@ -33,10 +34,10 @@ func (c Config) shallowCopy() Config {
 }
 
 // With sets the values of t, seed, and fuzzSeed in a copy of the Config and returns the copy.
-func (c Config) With(t *testing.T, seed int64, fuzzSeed []byte) Config {
-	t.Helper()
+func (c Config) With(tb testing.TB, seed int64, fuzzSeed []byte) Config {
+	tb.Helper()
 	r := c.shallowCopy()
-	r.T = t
+	r.TB = tb
 	r.Seed = seed
 	r.FuzzSeed = fuzzSeed
 	return r
diff --git a/x/simulation/client/cli/flags.go b/x/simulation/client/cli/flags.go
index 409e2aabf80a..706e27eeba7a 100644
--- a/x/simulation/client/cli/flags.go
+++ b/x/simulation/client/cli/flags.go
@@ -30,6 +30,7 @@ var (
 	FlagPeriodValue      uint
 	FlagGenesisTimeValue int64
 	FlagSigverifyTxValue bool
+	FlagFauxMerkle       bool
 )
 
 // GetSimulatorFlags gets the values of all the available simulation flags
@@ -54,6 +55,7 @@ func GetSimulatorFlags() {
 	flag.UintVar(&FlagPeriodValue, "Period", 0, "run slow invariants only once every period assertions")
 	flag.Int64Var(&FlagGenesisTimeValue, "GenesisTime", time.Now().Unix(), "use current time as genesis UNIX time for default")
 	flag.BoolVar(&FlagSigverifyTxValue, "SigverifyTx", true, "whether to sigverify check for transaction ")
+	flag.BoolVar(&FlagFauxMerkle, "FauxMerkle", false, "use faux merkle instead of iavl")
 }
 
 // NewConfigFromFlags creates a simulation from the retrieved values of the flags.
@@ -73,5 +75,6 @@ func NewConfigFromFlags() simulation.Config {
 		Lean:               FlagLeanValue,
 		Commit:             FlagCommitValue,
 		DBBackend:          FlagDBBackendValue,
+		FauxMerkle:         FlagFauxMerkle,
 	}
 }
diff --git a/x/simulation/log.go b/x/simulation/log.go
index c1f9c439e10b..4547e8f96d05 100644
--- a/x/simulation/log.go
+++ b/x/simulation/log.go
@@ -76,7 +76,7 @@ func createLogFile(seed int64) *os.File {
 	if err != nil {
 		panic(err)
 	}
-	fmt.Printf("Logs to writing to %s\n", filePath)
+	fmt.Printf("Logs to writing to %q\n", filePath)
 
 	return f
 }
diff --git a/x/simulation/operation.go b/x/simulation/operation.go
index 8146ef15273a..e0cf06f3f173 100644
--- a/x/simulation/operation.go
+++ b/x/simulation/operation.go
@@ -76,7 +76,7 @@ func NewOperationQueue() OperationQueue {
 }
 
 // queueOperations adds all future operations into the operation queue.
-func queueOperations(queuedOps OperationQueue, queuedTimeOps, futureOps []simulation.FutureOperation) {
+func queueOperations(queuedOps OperationQueue, queuedTimeOps *[]simulation.FutureOperation, futureOps []simulation.FutureOperation) {
 	if futureOps == nil {
 		return
 	}
@@ -96,15 +96,15 @@ func queueOperations(queuedOps OperationQueue, queuedTimeOps, futureOps []simula
 		// TODO: Replace with proper sorted data structure, so don't have the
 		// copy entire slice
 		index := sort.Search(
-			len(queuedTimeOps),
+			len(*queuedTimeOps),
 			func(i int) bool {
-				return queuedTimeOps[i].BlockTime.After(futureOp.BlockTime)
+				return (*queuedTimeOps)[i].BlockTime.After(futureOp.BlockTime)
 			},
 		)
 
-		queuedTimeOps = append(queuedTimeOps, simulation.FutureOperation{})
-		copy(queuedTimeOps[index+1:], queuedTimeOps[index:])
-		queuedTimeOps[index] = futureOp
+		*queuedTimeOps = append(*queuedTimeOps, simulation.FutureOperation{})
+		copy((*queuedTimeOps)[index+1:], (*queuedTimeOps)[index:])
+		(*queuedTimeOps)[index] = futureOp
 	}
 }
 
diff --git a/x/simulation/simulate.go b/x/simulation/simulate.go
index cd4fbe590799..e29c0693693c 100644
--- a/x/simulation/simulate.go
+++ b/x/simulation/simulate.go
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"io"
 	"math/rand"
+	"slices"
 	"testing"
 	"time"
 
@@ -21,7 +22,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/types/simulation"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
 )
 
 const AverageBlockTime = 6 * time.Second
@@ -30,12 +31,12 @@ const AverageBlockTime = 6 * time.Second
 func initChain(
 	r *rand.Rand,
 	params Params,
-	accounts []simulation.Account,
+	accounts []simtypes.Account,
 	app *baseapp.BaseApp,
-	appStateFn simulation.AppStateFn,
-	config simulation.Config,
+	appStateFn simtypes.AppStateFn,
+	config simtypes.Config,
 	cdc codec.JSONCodec,
-) (mockValidators, time.Time, []simulation.Account, string) {
+) (mockValidators, time.Time, []simtypes.Account, string) {
 	blockMaxGas := int64(-1)
 	if config.BlockMaxGas > 0 {
 		blockMaxGas = config.BlockMaxGas
@@ -64,17 +65,17 @@ func SimulateFromSeed( // exists for backwards compatibility only
 	logger corelog.Logger,
 	w io.Writer,
 	app *baseapp.BaseApp,
-	appStateFn simulation.AppStateFn,
-	randAccFn simulation.RandomAccountFn,
+	appStateFn simtypes.AppStateFn,
+	randAccFn simtypes.RandomAccountFn,
 	ops WeightedOperations,
 	blockedAddrs map[string]bool,
-	config simulation.Config,
+	config simtypes.Config,
 	cdc codec.JSONCodec,
 	addressCodec address.Codec,
 ) (exportedParams Params, err error) {
 	tb.Helper()
 	mode, _, _ := getTestingMode(tb)
-	return SimulateFromSeedX(tb, logger, w, app, appStateFn, randAccFn, ops, blockedAddrs, config, cdc, addressCodec, NewLogWriter(mode))
+	return SimulateFromSeedX(tb, logger, w, app, appStateFn, randAccFn, ops, blockedAddrs, config, cdc, NewLogWriter(mode))
 }
 
 // SimulateFromSeedX tests an application by running the provided
@@ -84,16 +85,20 @@ func SimulateFromSeedX(
 	logger corelog.Logger,
 	w io.Writer,
 	app *baseapp.BaseApp,
-	appStateFn simulation.AppStateFn,
-	randAccFn simulation.RandomAccountFn,
+	appStateFn simtypes.AppStateFn,
+	randAccFn simtypes.RandomAccountFn,
 	ops WeightedOperations,
 	blockedAddrs map[string]bool,
-	config simulation.Config,
+	config simtypes.Config,
 	cdc codec.JSONCodec,
-	addressCodec address.Codec,
 	logWriter LogWriter,
 ) (exportedParams Params, err error) {
 	tb.Helper()
+	defer func() {
+		if err != nil {
+			logWriter.PrintLogs()
+		}
+	}()
 	// in case we have to end early, don't os.Exit so that we can run cleanup code.
 	testingMode, _, b := getTestingMode(tb)
 
@@ -120,25 +125,15 @@ func SimulateFromSeedX(
 	config.ChainID = chainID
 
 	// remove module account address if they exist in accs
-	var tmpAccs []simulation.Account
-
-	for _, acc := range accs {
-		accAddr, err := addressCodec.BytesToString(acc.Address)
-		if err != nil {
-			return params, err
-		}
-		if !blockedAddrs[accAddr] {
-			tmpAccs = append(tmpAccs, acc)
-		}
-	}
-
-	accs = tmpAccs
+	accs = slices.DeleteFunc(accs, func(acc simtypes.Account) bool {
+		return blockedAddrs[acc.AddressBech32]
+	})
 	nextValidators := validators
 
 	var (
 		pastTimes          []time.Time
 		pastVoteInfos      [][]abci.VoteInfo
-		timeOperationQueue []simulation.FutureOperation
+		timeOperationQueue []simtypes.FutureOperation
 
 		blockHeight     = int64(config.InitialBlockHeight)
 		proposerAddress = validators.randomProposer(r)
@@ -168,7 +163,7 @@ func SimulateFromSeedX(
 		eventStats.Tally,
 		ops,
 		operationQueue,
-		timeOperationQueue,
+		&timeOperationQueue,
 		logWriter,
 		config,
 	)
@@ -191,6 +186,10 @@ func SimulateFromSeedX(
 		exportedParams = params
 	}
 
+	if _, err := app.FinalizeBlock(finalizeBlockReq); err != nil {
+		return params, fmt.Errorf("block finalization failed at height %d: %w", blockHeight, err)
+	}
+
 	for blockHeight < int64(config.NumBlocks+config.InitialBlockHeight) {
 		pastTimes = append(pastTimes, blockTime)
 		pastVoteInfos = append(pastVoteInfos, finalizeBlockReq.DecidedLastCommit.Votes)
@@ -219,15 +218,14 @@ func SimulateFromSeedX(
 			tb, operationQueue, blockTime, int(blockHeight), r, app, ctx, accs, logWriter,
 			eventStats.Tally, config.Lean, config.ChainID,
 		)
-
 		numQueuedTimeOpsRan, timeFutureOps := runQueuedTimeOperations(tb,
-			timeOperationQueue, int(blockHeight), blockTime,
+			&timeOperationQueue, int(blockHeight), blockTime,
 			r, app, ctx, accs, logWriter, eventStats.Tally,
 			config.Lean, config.ChainID,
 		)
 
 		futureOps = append(futureOps, timeFutureOps...)
-		queueOperations(operationQueue, timeOperationQueue, futureOps)
+		queueOperations(operationQueue, &timeOperationQueue, futureOps)
 
 		// run standard operations
 		operations := blockSimulator(r, app, ctx, accs, cmtproto.Header{
@@ -237,7 +235,6 @@ func SimulateFromSeedX(
 			ChainID:         config.ChainID,
 		})
 		opCount += operations + numQueuedOpsRan + numQueuedTimeOpsRan
-
 		blockHeight++
 
 		logWriter.AddEntry(EndBlockEntry(blockTime, blockHeight))
@@ -272,7 +269,6 @@ func SimulateFromSeedX(
 			exportedParams = params
 		}
 	}
-
 	logger.Info("Simulation complete", "height", blockHeight, "block-time", blockTime, "opsCount", opCount,
 		"run-time", time.Since(startTime), "app-hash", hex.EncodeToString(app.LastCommitID().Hash))
 
@@ -287,9 +283,9 @@ func SimulateFromSeedX(
 
 type blockSimFn func(
 	r *rand.Rand,
-	app *baseapp.BaseApp,
+	app simtypes.AppEntrypoint,
 	ctx sdk.Context,
-	accounts []simulation.Account,
+	accounts []simtypes.Account,
 	header cmtproto.Header,
 ) (opCount int)
 
@@ -297,8 +293,8 @@ type blockSimFn func(
 // parameters being passed every time, to minimize memory overhead.
 func createBlockSimulator(tb testing.TB, printProgress bool, w io.Writer, params Params,
 	event func(route, op, evResult string), ops WeightedOperations,
-	operationQueue OperationQueue, timeOperationQueue []simulation.FutureOperation,
-	logWriter LogWriter, config simulation.Config,
+	operationQueue OperationQueue, timeOperationQueue *[]simtypes.FutureOperation,
+	logWriter LogWriter, config simtypes.Config,
 ) blockSimFn {
 	tb.Helper()
 	lastBlockSizeState := 0 // state for [4 * uniform distribution]
@@ -306,7 +302,7 @@ func createBlockSimulator(tb testing.TB, printProgress bool, w io.Writer, params
 	selectOp := ops.getSelectOpFn()
 
 	return func(
-		r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accounts []simulation.Account, header cmtproto.Header,
+		r *rand.Rand, app simtypes.AppEntrypoint, ctx sdk.Context, accounts []simtypes.Account, header cmtproto.Header,
 	) (opCount int) {
 		_, _ = fmt.Fprintf(
 			w, "\rSimulating... block %d/%d, operation %d/%d.",
@@ -315,7 +311,7 @@ func createBlockSimulator(tb testing.TB, printProgress bool, w io.Writer, params
 		lastBlockSizeState, blocksize = getBlockSize(r, params, lastBlockSizeState, config.BlockSize)
 
 		type opAndR struct {
-			op   simulation.Operation
+			op   simtypes.Operation
 			rand *rand.Rand
 		}
 
@@ -363,11 +359,11 @@ Comment: %s`,
 	}
 }
 
-func runQueuedOperations(tb testing.TB, queueOps map[int][]simulation.Operation,
+func runQueuedOperations(tb testing.TB, queueOps map[int][]simtypes.Operation,
 	blockTime time.Time, height int, r *rand.Rand, app *baseapp.BaseApp,
-	ctx sdk.Context, accounts []simulation.Account, logWriter LogWriter,
+	ctx sdk.Context, accounts []simtypes.Account, logWriter LogWriter,
 	event func(route, op, evResult string), lean bool, chainID string,
-) (numOpsRan int, allFutureOps []simulation.FutureOperation) {
+) (numOpsRan int, allFutureOps []simtypes.FutureOperation) {
 	tb.Helper()
 	queuedOp, ok := queueOps[height]
 	if !ok {
@@ -375,11 +371,15 @@ func runQueuedOperations(tb testing.TB, queueOps map[int][]simulation.Operation,
 	}
 
 	// Keep all future operations
-	allFutureOps = make([]simulation.FutureOperation, 0)
+	allFutureOps = make([]simtypes.FutureOperation, 0)
 
 	numOpsRan = len(queuedOp)
 	for i := 0; i < numOpsRan; i++ {
 		opMsg, futureOps, err := queuedOp[i](r, app, ctx, accounts, chainID)
+		if err != nil {
+			logWriter.PrintLogs()
+			tb.FailNow()
+		}
 		if len(futureOps) > 0 {
 			allFutureOps = append(allFutureOps, futureOps...)
 		}
@@ -387,49 +387,44 @@ func runQueuedOperations(tb testing.TB, queueOps map[int][]simulation.Operation,
 		opMsg.LogEvent(event)
 
 		if !lean || opMsg.OK {
-			logWriter.AddEntry((QueuedMsgEntry(blockTime, int64(height), opMsg)))
+			logWriter.AddEntry(QueuedMsgEntry(blockTime, int64(height), opMsg))
 		}
 
-		if err != nil {
-			logWriter.PrintLogs()
-			tb.FailNow()
-		}
 	}
 	delete(queueOps, height)
 
 	return numOpsRan, allFutureOps
 }
 
-func runQueuedTimeOperations(tb testing.TB, queueOps []simulation.FutureOperation,
+func runQueuedTimeOperations(tb testing.TB, queueOps *[]simtypes.FutureOperation,
 	height int, currentTime time.Time, r *rand.Rand,
-	app *baseapp.BaseApp, ctx sdk.Context, accounts []simulation.Account,
+	app *baseapp.BaseApp, ctx sdk.Context, accounts []simtypes.Account,
 	logWriter LogWriter, event func(route, op, evResult string),
 	lean bool, chainID string,
-) (numOpsRan int, allFutureOps []simulation.FutureOperation) {
+) (numOpsRan int, allFutureOps []simtypes.FutureOperation) {
 	tb.Helper()
 	// Keep all future operations
-	allFutureOps = make([]simulation.FutureOperation, 0)
-
 	numOpsRan = 0
-	for len(queueOps) > 0 && currentTime.After(queueOps[0].BlockTime) {
-		opMsg, futureOps, err := queueOps[0].Op(r, app, ctx, accounts, chainID)
+	for len(*queueOps) > 0 && currentTime.After((*queueOps)[0].BlockTime) {
+		if qOp := (*queueOps)[0]; qOp.Op != nil {
+			opMsg, futureOps, err := qOp.Op(r, app, ctx, accounts, chainID)
 
-		opMsg.LogEvent(event)
+			opMsg.LogEvent(event)
 
-		if !lean || opMsg.OK {
-			logWriter.AddEntry(QueuedMsgEntry(currentTime, int64(height), opMsg))
-		}
+			if !lean || opMsg.OK {
+				logWriter.AddEntry(QueuedMsgEntry(currentTime, int64(height), opMsg))
+			}
 
-		if err != nil {
-			logWriter.PrintLogs()
-			tb.FailNow()
-		}
+			if err != nil {
+				logWriter.PrintLogs()
+				tb.Fatal(err)
+			}
 
-		if len(futureOps) > 0 {
-			allFutureOps = append(allFutureOps, futureOps...)
+			if len(futureOps) > 0 {
+				allFutureOps = append(allFutureOps, futureOps...)
+			}
 		}
-
-		queueOps = queueOps[1:]
+		*queueOps = slices.Delete(*queueOps, 0, 1)
 		numOpsRan++
 	}
 
diff --git a/x/simulation/simulate_test.go b/x/simulation/simulate_test.go
new file mode 100644
index 000000000000..83989dbb198e
--- /dev/null
+++ b/x/simulation/simulate_test.go
@@ -0,0 +1,57 @@
+package simulation
+
+import (
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+)
+
+func TestRunQueuedTimeOperations(t *testing.T) {
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	ctx := sdk.Context{}
+	lw := NewLogWriter(true)
+	noopEvent := func(route, op, evResult string) {}
+	var acc []simtypes.Account
+	noOp := simtypes.FutureOperation{
+		Op: func(gotR *rand.Rand, gotApp simtypes.AppEntrypoint, ctx sdk.Context, accounts []simtypes.Account, chainID string) (OperationMsg simtypes.OperationMsg, futureOps []simtypes.FutureOperation, err error) {
+			return simtypes.OperationMsg{}, nil, nil
+		},
+	}
+	futureOp := simtypes.FutureOperation{
+		Op: func(gotR *rand.Rand, gotApp simtypes.AppEntrypoint, ctx sdk.Context, accounts []simtypes.Account, chainID string) (OperationMsg simtypes.OperationMsg, futureOps []simtypes.FutureOperation, err error) {
+			return simtypes.OperationMsg{}, []simtypes.FutureOperation{noOp}, nil
+		},
+	}
+
+	specs := map[string]struct {
+		queueOps []simtypes.FutureOperation
+		expOps   []simtypes.FutureOperation
+	}{
+		"empty": {},
+		"single": {
+			queueOps: []simtypes.FutureOperation{noOp},
+		},
+		"multi": {
+			queueOps: []simtypes.FutureOperation{noOp, noOp},
+		},
+		"future op": {
+			queueOps: []simtypes.FutureOperation{futureOp},
+			expOps:   []simtypes.FutureOperation{noOp},
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			expOps := len(spec.queueOps)
+			n, fOps := runQueuedTimeOperations(t, &spec.queueOps, 0, time.Now(), r, nil, ctx, acc, lw, noopEvent, false, "testing")
+			require.Equal(t, expOps, n)
+			assert.Empty(t, spec.queueOps)
+			assert.Equal(t, spec.expOps, fOps)
+		})
+	}
+}