Repository: osmosis-labs/osmosis
Pull request #5131 (2023-05-09 00:20:05)

[CL Message Audit] MsgCreateIncentive
<!-- < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < ☺
v                               ✰  Thanks for creating a PR! ✰    
v    Before smashing the submit button please review the checkboxes.
v    If a checkbox is n/a - please still include it but + a little note why
v    If your PR doesn't close an issue, that's OK!  Just remove the Closes: #XXX line!
☺ > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >  -->

Closes: #XXX
clickup: https://app.clickup.com/37420681/v/dc/13nzm9-19460/13nzm9-35660


## Brief Changelog
- Docs improvements on confusing parts of the message flow
- Misc
     -  combined incentiveDenom, incentiveAmount to be incentiveCoin

## Testing and Verifying
- all functions tested


Patch:
diff --git a/.golangci.yml b/.golangci.yml
index 3a89ed212..ba9195a2e 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -35,7 +35,6 @@ linters:
     - staticcheck
     - stylecheck
     - tenv
-    - thelper
     - testpackage
     - typecheck
     - unconvert
diff --git a/app/upgrades/v15/constants.go b/app/upgrades/v15/constants.go
index 351396832..47eb55cdb 100644
--- a/app/upgrades/v15/constants.go
+++ b/app/upgrades/v15/constants.go
@@ -15,11 +15,9 @@ import (
 const UpgradeName = "v15"
 
 // pool ids to migrate
-const (
-	stOSMO_OSMOPoolId   = 833
-	stJUNO_JUNOPoolId   = 817
-	stSTARS_STARSPoolId = 810
-)
+const stOSMO_OSMOPoolId = 833
+const stJUNO_JUNOPoolId = 817
+const stSTARS_STARSPoolId = 810
 
 var Upgrade = upgrades.Upgrade{
 	UpgradeName:          UpgradeName,
diff --git a/go.mod b/go.mod
index 74afecead..a9479ee91 100644
--- a/go.mod
+++ b/go.mod
@@ -241,7 +241,7 @@ require (
 	github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/polyfloyd/go-errorlint v1.4.0 // indirect
-	github.com/prometheus/client_golang v1.15.1
+	github.com/prometheus/client_golang v1.15.0
 	github.com/prometheus/client_model v0.3.0 // indirect
 	github.com/prometheus/common v0.42.0 // indirect
 	github.com/prometheus/procfs v0.9.0 // indirect
diff --git a/go.sum b/go.sum
index 15e1539e6..7c3e0395f 100644
--- a/go.sum
+++ b/go.sum
@@ -990,8 +990,8 @@ github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3O
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
 github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
 github.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
-github.com/prometheus/client_golang v1.15.1 h1:8tXpTmJbyH5lydzFPoxSIJ0J46jdh3tylbvM1xCv0LI=
-github.com/prometheus/client_golang v1.15.1/go.mod h1:e9yaBhRPU2pPNsZwE+JdQl0KEt1N9XgF6zxWmaC0xOk=
+github.com/prometheus/client_golang v1.15.0 h1:5fCgGYogn0hFdhyhLbw7hEsWxufKtY9klyvdNfFlFhM=
+github.com/prometheus/client_golang v1.15.0/go.mod h1:e9yaBhRPU2pPNsZwE+JdQl0KEt1N9XgF6zxWmaC0xOk=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
diff --git a/proto/osmosis/concentrated-liquidity/tx.proto b/proto/osmosis/concentrated-liquidity/tx.proto
index 090e986a5..9eb4711b8 100644
--- a/proto/osmosis/concentrated-liquidity/tx.proto
+++ b/proto/osmosis/concentrated-liquidity/tx.proto
@@ -159,23 +159,21 @@ message MsgCollectIncentivesResponse {
 message MsgCreateIncentive {
   uint64 pool_id = 1 [ (gogoproto.moretags) = "yaml:\"pool_id\"" ];
   string sender = 2 [ (gogoproto.moretags) = "yaml:\"sender\"" ];
-  string incentive_denom = 3;
-  string incentive_amount = 4 [
-    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
-    (gogoproto.moretags) = "yaml:\"incentive_amount\"",
+  cosmos.base.v1beta1.Coin incentive_coin = 3 [
+    (gogoproto.moretags) = "yaml:\"incentive_coin\"",
     (gogoproto.nullable) = false
   ];
-  string emission_rate = 5 [
+  string emission_rate = 4 [
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
     (gogoproto.moretags) = "yaml:\"emission_rate\"",
     (gogoproto.nullable) = false
   ];
-  google.protobuf.Timestamp start_time = 6 [
+  google.protobuf.Timestamp start_time = 5 [
     (gogoproto.nullable) = false,
     (gogoproto.stdtime) = true,
     (gogoproto.moretags) = "yaml:\"start_time\""
   ];
-  google.protobuf.Duration min_uptime = 7 [
+  google.protobuf.Duration min_uptime = 6 [
     (gogoproto.nullable) = false,
     (gogoproto.stdduration) = true,
     (gogoproto.jsontag) = "duration,omitempty",
diff --git a/simulation/executor/log.go b/simulation/executor/log.go
index 000c39c51..d429497a4 100644
--- a/simulation/executor/log.go
+++ b/simulation/executor/log.go
@@ -16,7 +16,6 @@ type LogWriter interface {
 
 // LogWriter - return a dummy or standard log writer given the testingmode
 func NewLogWriter(tb testing.TB) LogWriter {
-	tb.Helper()
 	// TODO: Figure out whats going on / why here
 	testingMode, _, _ := getTestingMode(tb)
 
diff --git a/simulation/executor/simulate.go b/simulation/executor/simulate.go
index ffc060ad5..ef65f3ab6 100644
--- a/simulation/executor/simulate.go
+++ b/simulation/executor/simulate.go
@@ -45,7 +45,6 @@ func SimulateFromSeed(
 	initFunctions InitFunctions,
 	config Config,
 ) (lastCommitId storetypes.CommitID, stopEarly bool, err error) {
-	tb.Helper()
 	// in case we have to end early, don't os.Exit so that we can run cleanup code.
 	// TODO: Understand exit pattern, this is so screwed up. Then delete ^
 
@@ -123,7 +122,6 @@ func cursedInitializationLogic(
 	initFunctions InitFunctions,
 	config *Config,
 ) (*simtypes.SimCtx, *simState, Params, error) {
-	tb.Helper()
 	fmt.Fprintf(w, "Starting SimulateFromSeed with randomness created with seed %d\n", int(config.Seed))
 
 	r := rand.New(rand.NewSource(config.Seed))
@@ -158,7 +156,7 @@ func cursedInitializationLogic(
 	// must set version in order to generate hashes
 	initialHeader.Version.Block = 11
 
-	simState := newSimulatorState(tb, simParams, initialHeader, w, validators, *config)
+	simState := newSimulatorState(simParams, initialHeader, tb, w, validators, *config)
 
 	// TODO: If simulation has a param export path configured, export params here.
 
diff --git a/simulation/executor/simulate_dev.go b/simulation/executor/simulate_dev.go
index 0f629e1e7..da0584e3e 100644
--- a/simulation/executor/simulate_dev.go
+++ b/simulation/executor/simulate_dev.go
@@ -50,8 +50,7 @@ type simState struct {
 	config Config
 }
 
-func newSimulatorState(tb testing.TB, simParams Params, initialHeader tmproto.Header, w io.Writer, validators mockValidators, config Config) *simState {
-	tb.Helper()
+func newSimulatorState(simParams Params, initialHeader tmproto.Header, tb testing.TB, w io.Writer, validators mockValidators, config Config) *simState {
 	return &simState{
 		simParams:      simParams,
 		header:         initialHeader,
diff --git a/simulation/executor/util.go b/simulation/executor/util.go
index d0d886aa4..f9b777fd5 100644
--- a/simulation/executor/util.go
+++ b/simulation/executor/util.go
@@ -9,7 +9,6 @@ import (
 )
 
 func getTestingMode(tb testing.TB) (testingMode bool, t *testing.T, b *testing.B) {
-	tb.Helper()
 	testingMode = false
 
 	if _t, ok := tb.(*testing.T); ok {
diff --git a/x/concentrated-liquidity/client/cli/query.go b/x/concentrated-liquidity/client/cli/query.go
index 429151db5..d55c5a96d 100644
--- a/x/concentrated-liquidity/client/cli/query.go
+++ b/x/concentrated-liquidity/client/cli/query.go
@@ -30,8 +30,7 @@ func GetUserPositions() (*osmocli.QueryDescriptor, *queryproto.UserPositionsRequ
 			Long: `{{.Short}}{{.ExampleHeader}}
 {{.CommandPrefix}} user-positions osmo12smx2wdlyttvyzvzg54y2vnqwq2qjateuf7thj`,
 			Flags:               osmocli.FlagDesc{OptionalFlags: []*flag.FlagSet{FlagSetJustPoolId()}},
-			CustomFlagOverrides: poolIdFlagOverride,
-		},
+			CustomFlagOverrides: poolIdFlagOverride},
 		&queryproto.UserPositionsRequest{}
 }
 
@@ -40,8 +39,7 @@ func GetCmdPools() (*osmocli.QueryDescriptor, *queryproto.PoolsRequest) {
 		Use:   "pools",
 		Short: "Query pools",
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} pools`,
-	}, &queryproto.PoolsRequest{}
+{{.CommandPrefix}} pools`}, &queryproto.PoolsRequest{}
 }
 
 func GetClaimableFees() (*osmocli.QueryDescriptor, *queryproto.ClaimableFeesRequest) {
@@ -49,8 +47,7 @@ func GetClaimableFees() (*osmocli.QueryDescriptor, *queryproto.ClaimableFeesRequ
 		Use:   "claimable-fees [positionID]",
 		Short: "Query claimable fees",
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} claimable-fees 53`,
-	}, &queryproto.ClaimableFeesRequest{}
+{{.CommandPrefix}} claimable-fees 53`}, &queryproto.ClaimableFeesRequest{}
 }
 
 func GetClaimableIncentives() (*osmocli.QueryDescriptor, *queryproto.ClaimableIncentivesRequest) {
@@ -58,6 +55,5 @@ func GetClaimableIncentives() (*osmocli.QueryDescriptor, *queryproto.ClaimableIn
 		Use:   "claimable-incentives [positionID]",
 		Short: "Query claimable incentives",
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} claimable-fees 53`,
-	}, &queryproto.ClaimableIncentivesRequest{}
+{{.CommandPrefix}} claimable-fees 53`}, &queryproto.ClaimableIncentivesRequest{}
 }
diff --git a/x/concentrated-liquidity/client/cli/tx.go b/x/concentrated-liquidity/client/cli/tx.go
index d1e502524..4bfcef221 100644
--- a/x/concentrated-liquidity/client/cli/tx.go
+++ b/x/concentrated-liquidity/client/cli/tx.go
@@ -237,7 +237,6 @@ func parseCreateConcentratedLiquidityPoolArgsToContent(cmd *cobra.Command, denom
 
 	return content, nil
 }
-
 func parsePoolIdToTickSpacingRecordsArgsToContent(cmd *cobra.Command) (govtypes.Content, error) {
 	title, err := cmd.Flags().GetString(govcli.FlagTitle)
 	if err != nil {
diff --git a/x/concentrated-liquidity/incentives.go b/x/concentrated-liquidity/incentives.go
index 5a8f2d8aa..05e74100a 100644
--- a/x/concentrated-liquidity/incentives.go
+++ b/x/concentrated-liquidity/incentives.go
@@ -918,16 +918,25 @@ func (k Keeper) collectIncentives(ctx sdk.Context, sender sdk.AccAddress, positi
 	return collectedIncentivesForPosition, forfeitedIncentivesForPosition, nil
 }
 
-// createIncentive creates an incentive record in state for the given pool
-func (k Keeper) CreateIncentive(ctx sdk.Context, poolId uint64, sender sdk.AccAddress, incentiveDenom string, incentiveAmount sdk.Int, emissionRate sdk.Dec, startTime time.Time, minUptime time.Duration) (types.IncentiveRecord, error) {
+// createIncentive creates an incentive record in state for the given pool.
+//
+// Upon successful creation, it bank sends the incentives from the owner address to the pool address and returns the incentives record.
+// Returns error if:
+// - poolId is invalid
+// - incentiveAmount is invalid (zero or negative).
+// - emissionRate is invalid (zero or negative)
+// - startTime is < blockTime.
+// - minUptime is not an authorizedUptime.
+// - other internal database or math errors.
+func (k Keeper) CreateIncentive(ctx sdk.Context, poolId uint64, sender sdk.AccAddress, incentiveCoin sdk.Coin, emissionRate sdk.Dec, startTime time.Time, minUptime time.Duration) (types.IncentiveRecord, error) {
 	pool, err := k.getPoolById(ctx, poolId)
 	if err != nil {
 		return types.IncentiveRecord{}, err
 	}
 
-	// Ensure incentive amount is nonzero and nonnegative
-	if !incentiveAmount.IsPositive() {
-		return types.IncentiveRecord{}, types.NonPositiveIncentiveAmountError{PoolId: poolId, IncentiveAmount: incentiveAmount.ToDec()}
+	// checks if the Coin has a non-negative amount and the denom is valid.
+	if !incentiveCoin.IsValid() || incentiveCoin.IsZero() {
+		return types.IncentiveRecord{}, types.InvalidIncentiveCoinError{PoolId: poolId, IncentiveCoin: incentiveCoin}
 	}
 
 	// Ensure start time is >= current blocktime
@@ -960,11 +969,9 @@ func (k Keeper) CreateIncentive(ctx sdk.Context, poolId uint64, sender sdk.AccAd
 		return types.IncentiveRecord{}, types.InvalidMinUptimeError{PoolId: poolId, MinUptime: minUptime, AuthorizedUptimes: authorizedUptimes}
 	}
 
-	// Ensure sender has balance for incentive denom
-	incentiveCoin := sdk.NewCoin(incentiveDenom, incentiveAmount)
 	senderHasBalance := k.bankKeeper.HasBalance(ctx, sender, incentiveCoin)
 	if !senderHasBalance {
-		return types.IncentiveRecord{}, types.IncentiveInsufficientBalanceError{PoolId: poolId, IncentiveDenom: incentiveDenom, IncentiveAmount: incentiveAmount}
+		return types.IncentiveRecord{}, types.IncentiveInsufficientBalanceError{PoolId: poolId, IncentiveDenom: incentiveCoin.Denom, IncentiveAmount: incentiveCoin.Amount}
 	}
 
 	// Sync global uptime accumulators to current blocktime to ensure consistency in reward emissions
@@ -974,14 +981,14 @@ func (k Keeper) CreateIncentive(ctx sdk.Context, poolId uint64, sender sdk.AccAd
 	}
 
 	incentiveRecordBody := types.IncentiveRecordBody{
-		RemainingAmount: incentiveAmount.ToDec(),
+		RemainingAmount: incentiveCoin.Amount.ToDec(),
 		EmissionRate:    emissionRate,
 		StartTime:       startTime,
 	}
 	// Set up incentive record to put in state
 	incentiveRecord := types.IncentiveRecord{
 		PoolId:               poolId,
-		IncentiveDenom:       incentiveDenom,
+		IncentiveDenom:       incentiveCoin.Denom,
 		IncentiveCreatorAddr: sender.String(),
 		IncentiveRecordBody:  incentiveRecordBody,
 		MinUptime:            minUptime,
@@ -994,7 +1001,7 @@ func (k Keeper) CreateIncentive(ctx sdk.Context, poolId uint64, sender sdk.AccAd
 	}
 
 	// Fixed gas consumption per incentive creation to prevent spam
-	ctx.GasMeter().ConsumeGas(uint64(types.BaseGasFeeForNewIncentive*len(existingRecordsForUptime)), "cl incentive creation")
+	ctx.GasMeter().ConsumeGas(uint64(types.BaseGasFeeForNewIncentive*len(existingRecordsForUptime)), "cl incentive creation fee")
 
 	// Set incentive record in state
 	err = k.setIncentiveRecord(ctx, incentiveRecord)
diff --git a/x/concentrated-liquidity/math/math.go b/x/concentrated-liquidity/math/math.go
index 17d85eee9..985df2fba 100644
--- a/x/concentrated-liquidity/math/math.go
+++ b/x/concentrated-liquidity/math/math.go
@@ -6,7 +6,9 @@ import (
 	"github.com/osmosis-labs/osmosis/osmomath"
 )
 
-var smallestDec = sdk.SmallestDec()
+var (
+	smallestDec = sdk.SmallestDec()
+)
 
 // liquidity0 takes an amount of asset0 in the pool as well as the sqrtpCur and the nextPrice
 // sqrtPriceA is the smaller of sqrtpCur and the nextPrice
diff --git a/x/concentrated-liquidity/msg_server.go b/x/concentrated-liquidity/msg_server.go
index 9f9fb1e26..9807c0235 100644
--- a/x/concentrated-liquidity/msg_server.go
+++ b/x/concentrated-liquidity/msg_server.go
@@ -160,7 +160,7 @@ func (server msgServer) CollectFees(goCtx context.Context, msg *types.MsgCollect
 	return &types.MsgCollectFeesResponse{CollectedFees: totalCollectedFees}, nil
 }
 
-// CollectIncentives collects incentives for all given PositionIds in a given range that belong to sender.
+// CollectIncentives collects incentives for all positions in given range that belong to sender
 func (server msgServer) CollectIncentives(goCtx context.Context, msg *types.MsgCollectIncentives) (*types.MsgCollectIncentivesResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
@@ -205,7 +205,7 @@ func (server msgServer) CreateIncentive(goCtx context.Context, msg *types.MsgCre
 		return nil, err
 	}
 
-	incentiveRecord, err := server.keeper.CreateIncentive(ctx, msg.PoolId, sender, msg.IncentiveDenom, msg.IncentiveAmount, msg.EmissionRate, msg.StartTime, msg.MinUptime)
+	incentiveRecord, err := server.keeper.CreateIncentive(ctx, msg.PoolId, sender, msg.IncentiveCoin, msg.EmissionRate, msg.StartTime, msg.MinUptime)
 	if err != nil {
 		return nil, err
 	}
@@ -221,8 +221,7 @@ func (server msgServer) CreateIncentive(goCtx context.Context, msg *types.MsgCre
 			sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory),
 			sdk.NewAttribute(sdk.AttributeKeySender, msg.Sender),
 			sdk.NewAttribute(types.AttributeKeyPoolId, strconv.FormatUint(msg.PoolId, 10)),
-			sdk.NewAttribute(types.AttributeIncentiveDenom, msg.IncentiveDenom),
-			sdk.NewAttribute(types.AttributeIncentiveAmount, msg.IncentiveAmount.String()),
+			sdk.NewAttribute(types.AttributeIncentiveCoin, msg.IncentiveCoin.String()),
 			sdk.NewAttribute(types.AttributeIncentiveEmissionRate, msg.EmissionRate.String()),
 			sdk.NewAttribute(types.AttributeIncentiveStartTime, msg.StartTime.String()),
 			sdk.NewAttribute(types.AttributeIncentiveMinUptime, msg.MinUptime.String()),
diff --git a/x/concentrated-liquidity/simulation/sim_msgs.go b/x/concentrated-liquidity/simulation/sim_msgs.go
index 6ee2808ce..7de8a512c 100644
--- a/x/concentrated-liquidity/simulation/sim_msgs.go
+++ b/x/concentrated-liquidity/simulation/sim_msgs.go
@@ -3,6 +3,7 @@ package simulation
 import (
 	"errors"
 	"fmt"
+
 	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -249,15 +250,15 @@ func RandMsgCreateIncentives(k clkeeper.Keeper, sim *osmosimtypes.SimCtx, ctx sd
 
 	// Get the duration value at the random index
 	randomDuration := durations[randomDurationIndex]
+	incentiveCoin := sdk.NewCoin(incentivesTokens[0].Denom, incentivesTokens[0].Amount)
 
 	return &cltypes.MsgCreateIncentive{
-		PoolId:          clPool.GetId(),
-		Sender:          incentiveCreator.Address.String(),
-		IncentiveDenom:  incentivesTokens[0].Denom,
-		IncentiveAmount: incentivesTokens[0].Amount,
-		EmissionRate:    randEmissionVal,
-		StartTime:       startTime,
-		MinUptime:       randomDuration,
+		PoolId:        clPool.GetId(),
+		Sender:        incentiveCreator.Address.String(),
+		IncentiveCoin: incentiveCoin,
+		EmissionRate:  randEmissionVal,
+		StartTime:     startTime,
+		MinUptime:     randomDuration,
 	}, nil
 }
 
diff --git a/x/concentrated-liquidity/types/constants.go b/x/concentrated-liquidity/types/constants.go
index a7d6faabd..132025a38 100644
--- a/x/concentrated-liquidity/types/constants.go
+++ b/x/concentrated-liquidity/types/constants.go
@@ -28,8 +28,7 @@ var (
 		sdk.MustNewDecFromStr("0.001"),  // 0.1%
 		sdk.MustNewDecFromStr("0.002"),  // 0.2%
 		sdk.MustNewDecFromStr("0.003"),  // 0.3%
-		sdk.MustNewDecFromStr("0.005"),
-	} // 0.5%
+		sdk.MustNewDecFromStr("0.005")}  // 0.5%
 	BaseGasFeeForNewIncentive     = 10_000
 	DefaultBalancerSharesDiscount = sdk.MustNewDecFromStr("0.05")
 	// By default, we only authorize one nanosecond (one block) uptime as an option
diff --git a/x/concentrated-liquidity/types/errors.go b/x/concentrated-liquidity/types/errors.go
index bbd2fc50b..30ae269fe 100644
--- a/x/concentrated-liquidity/types/errors.go
+++ b/x/concentrated-liquidity/types/errors.go
@@ -365,13 +365,13 @@ func (e BalancerRecordNotClearedError) Error() string {
 	return fmt.Sprintf("balancer record was not cleared after reward claiming. CL pool id (%d), Balancer pool ID (%d), Uptime index (%d)", e.ClPoolId, e.BalancerPoolId, e.UptimeIndex)
 }
 
-type NonPositiveIncentiveAmountError struct {
-	PoolId          uint64
-	IncentiveAmount sdk.Dec
+type InvalidIncentiveCoinError struct {
+	PoolId        uint64
+	IncentiveCoin sdk.Coin
 }
 
-func (e NonPositiveIncentiveAmountError) Error() string {
-	return fmt.Sprintf("incentive amount must be position (nonzero and nonnegative). Pool id (%d), incentive amount (%s)", e.PoolId, e.IncentiveAmount)
+func (e InvalidIncentiveCoinError) Error() string {
+	return fmt.Sprintf("incentive coin denom must be valid and have non negative amount Pool id (%d), incentive coin (%s)", e.PoolId, e.IncentiveCoin)
 }
 
 type NonPositiveEmissionRateError struct {
diff --git a/x/concentrated-liquidity/types/events.go b/x/concentrated-liquidity/types/events.go
index 9b82e920a..e13ea7844 100644
--- a/x/concentrated-liquidity/types/events.go
+++ b/x/concentrated-liquidity/types/events.go
@@ -27,8 +27,7 @@ const (
 	TypeEvtPoolJoined              = "pool_joined"
 	TypeEvtPoolExited              = "pool_exited"
 	TypeEvtTokenSwapped            = "token_swapped"
-	AttributeIncentiveDenom        = "incentive_denom"
-	AttributeIncentiveAmount       = "incentive_amount"
+	AttributeIncentiveCoin         = "incentive_coin"
 	AttributeIncentiveEmissionRate = "incentive_emission_rate"
 	AttributeIncentiveStartTime    = "incentive_start_time"
 	AttributeIncentiveMinUptime    = "incentive_min_uptime"
diff --git a/x/concentrated-liquidity/types/msgs.go b/x/concentrated-liquidity/types/msgs.go
index 6eee4877c..57cb362ef 100644
--- a/x/concentrated-liquidity/types/msgs.go
+++ b/x/concentrated-liquidity/types/msgs.go
@@ -189,8 +189,8 @@ func (msg MsgCreateIncentive) ValidateBasic() error {
 		return fmt.Errorf("Invalid sender address (%s)", err)
 	}
 
-	if !msg.IncentiveAmount.IsPositive() {
-		return NonPositiveIncentiveAmountError{PoolId: msg.PoolId, IncentiveAmount: msg.IncentiveAmount.ToDec()}
+	if !msg.IncentiveCoin.IsValid() {
+		return InvalidIncentiveCoinError{PoolId: msg.PoolId, IncentiveCoin: msg.IncentiveCoin}
 	}
 
 	if !msg.EmissionRate.IsPositive() {
diff --git a/x/concentrated-liquidity/types/tx.pb.go b/x/concentrated-liquidity/types/tx.pb.go
index 7b92a8252..27e419414 100644
--- a/x/concentrated-liquidity/types/tx.pb.go
+++ b/x/concentrated-liquidity/types/tx.pb.go
@@ -587,13 +587,12 @@ func (m *MsgCollectIncentivesResponse) GetForfeitedIncentives() []types.Coin {
 
 // ===================== MsgCreateIncentive
 type MsgCreateIncentive struct {
-	PoolId          uint64                                 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
-	Sender          string                                 `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
-	IncentiveDenom  string                                 `protobuf:"bytes,3,opt,name=incentive_denom,json=incentiveDenom,proto3" json:"incentive_denom,omitempty"`
-	IncentiveAmount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=incentive_amount,json=incentiveAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"incentive_amount" yaml:"incentive_amount"`
-	EmissionRate    github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,5,opt,name=emission_rate,json=emissionRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"emission_rate" yaml:"emission_rate"`
-	StartTime       time.Time                              `protobuf:"bytes,6,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time" yaml:"start_time"`
-	MinUptime       time.Duration                          `protobuf:"bytes,7,opt,name=min_uptime,json=minUptime,proto3,stdduration" json:"duration,omitempty" yaml:"min_uptime"`
+	PoolId        uint64                                 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
+	Sender        string                                 `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
+	IncentiveCoin types.Coin                             `protobuf:"bytes,3,opt,name=incentive_coin,json=incentiveCoin,proto3" json:"incentive_coin" yaml:"incentive_coin"`
+	EmissionRate  github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=emission_rate,json=emissionRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"emission_rate" yaml:"emission_rate"`
+	StartTime     time.Time                              `protobuf:"bytes,5,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time" yaml:"start_time"`
+	MinUptime     time.Duration                          `protobuf:"bytes,6,opt,name=min_uptime,json=minUptime,proto3,stdduration" json:"duration,omitempty" yaml:"min_uptime"`
 }
 
 func (m *MsgCreateIncentive) Reset()         { *m = MsgCreateIncentive{} }
@@ -643,11 +642,11 @@ func (m *MsgCreateIncentive) GetSender() string {
 	return ""
 }
 
-func (m *MsgCreateIncentive) GetIncentiveDenom() string {
+func (m *MsgCreateIncentive) GetIncentiveCoin() types.Coin {
 	if m != nil {
-		return m.IncentiveDenom
+		return m.IncentiveCoin
 	}
-	return ""
+	return types.Coin{}
 }
 
 func (m *MsgCreateIncentive) GetStartTime() time.Time {
@@ -845,87 +844,87 @@ func init() {
 }
 
 var fileDescriptor_1f1fff802923d7db = []byte{
-	// 1278 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0x4d, 0x6f, 0x1b, 0xc5,
-	0x1b, 0xcf, 0xda, 0xce, 0xdb, 0xa4, 0x76, 0xe2, 0x4d, 0x9a, 0xb8, 0xdb, 0xfe, 0xbd, 0xd1, 0xfc,
-	0x05, 0x0d, 0x82, 0xec, 0x76, 0x53, 0x2a, 0x20, 0x08, 0xd1, 0x38, 0x51, 0x24, 0x23, 0x45, 0x42,
-	0xab, 0x54, 0xa0, 0x0a, 0xc9, 0x5a, 0x7b, 0x27, 0xce, 0x10, 0xef, 0x8e, 0xe3, 0x19, 0x27, 0xf5,
-	0x81, 0x53, 0xb9, 0x54, 0x20, 0xb5, 0x42, 0x42, 0xe2, 0x1b, 0xf0, 0x15, 0xb8, 0x72, 0xeb, 0xb1,
-	0x17, 0x24, 0x84, 0x90, 0x41, 0xc9, 0x8d, 0x0b, 0xc2, 0x9f, 0x00, 0xed, 0xce, 0xee, 0xac, 0xb3,
-	0x4e, 0xd4, 0xac, 0xf3, 0x72, 0xe1, 0x94, 0xcc, 0x33, 0xcf, 0xef, 0xf7, 0xcc, 0x3c, 0x6f, 0xf3,
-	0xac, 0xc1, 0x5d, 0x42, 0x1d, 0x42, 0x31, 0xd5, 0x6b, 0xc4, 0xad, 0x21, 0x97, 0xb5, 0x2c, 0x86,
-	0xec, 0xe5, 0x06, 0xde, 0x6f, 0x63, 0x1b, 0xb3, 0x8e, 0xce, 0x9e, 0x68, 0xcd, 0x16, 0x61, 0x44,
-	0x7e, 0x23, 0x50, 0xd4, 0xfa, 0x15, 0x85, 0x9e, 0x76, 0x60, 0x54, 0x11, 0xb3, 0x0c, 0x65, 0xae,
-	0x4e, 0xea, 0xc4, 0x47, 0xe8, 0xde, 0x7f, 0x1c, 0xac, 0xa8, 0x75, 0x42, 0xea, 0x0d, 0xa4, 0xfb,
-	0xab, 0x6a, 0x7b, 0x47, 0x67, 0xd8, 0x41, 0x94, 0x59, 0x4e, 0x33, 0x50, 0x28, 0xc6, 0x15, 0xec,
-	0x76, 0xcb, 0x62, 0x98, 0xb8, 0xe1, 0x7e, 0xcd, 0x37, 0xaf, 0x57, 0x2d, 0x8a, 0xf4, 0xc0, 0x96,
-	0x5e, 0x23, 0x38, 0xd8, 0x87, 0xcf, 0x46, 0x41, 0x7e, 0x8b, 0xd6, 0xd7, 0x5b, 0xc8, 0x62, 0xe8,
-	0x53, 0x42, 0xb1, 0x87, 0x95, 0xdf, 0x06, 0xe3, 0x4d, 0x42, 0x1a, 0x15, 0x6c, 0x17, 0xa4, 0x45,
-	0x69, 0x29, 0x53, 0x92, 0x7b, 0x5d, 0x35, 0xd7, 0xb1, 0x9c, 0xc6, 0x2a, 0x0c, 0x36, 0xa0, 0x39,
-	0xe6, 0xfd, 0x57, 0xb6, 0xe5, 0xb7, 0xc0, 0x18, 0x45, 0xae, 0x8d, 0x5a, 0x85, 0xd4, 0xa2, 0xb4,
-	0x34, 0x59, 0xca, 0xf7, 0xba, 0x6a, 0x96, 0xeb, 0x72, 0x39, 0x34, 0x03, 0x05, 0xf9, 0x5d, 0x00,
-	0x1a, 0xe4, 0x10, 0xb5, 0x2a, 0x0c, 0xd7, 0xf6, 0x0a, 0xe9, 0x45, 0x69, 0x29, 0x5d, 0xba, 0xd9,
-	0xeb, 0xaa, 0x79, 0xae, 0x1e, 0xed, 0x41, 0x73, 0xd2, 0x5f, 0x6c, 0xe3, 0xda, 0x9e, 0x87, 0x6a,
-	0x37, 0x9b, 0x21, 0x2a, 0x13, 0x47, 0x45, 0x7b, 0xd0, 0x9c, 0xf4, 0x17, 0x3e, 0xaa, 0x02, 0x72,
-	0x8c, 0xec, 0x21, 0xb7, 0x62, 0x23, 0x8a, 0x5b, 0xc8, 0xbe, 0x57, 0x18, 0x5d, 0x94, 0x96, 0xa6,
-	0x56, 0x6e, 0x69, 0xdc, 0x25, 0x9a, 0xe7, 0x92, 0xd0, 0xfd, 0xda, 0x3a, 0xc1, 0x6e, 0xe9, 0x7f,
-	0x2f, 0xbb, 0xea, 0x48, 0xaf, 0xab, 0xde, 0xe4, 0xc4, 0x27, 0xe1, 0xd0, 0xcc, 0xfa, 0x82, 0x8d,
-	0x60, 0x3d, 0x60, 0xc0, 0x28, 0x8c, 0x5d, 0xc4, 0x80, 0x11, 0x33, 0x60, 0xc8, 0x07, 0x20, 0xcf,
-	0x35, 0x1c, 0xec, 0x56, 0x2c, 0x87, 0xb4, 0x5d, 0x76, 0xaf, 0x30, 0xee, 0xfb, 0xf8, 0x13, 0x8f,
-	0xe8, 0xb7, 0xae, 0xfa, 0x66, 0x1d, 0xb3, 0xdd, 0x76, 0x55, 0xab, 0x11, 0x47, 0x0f, 0x22, 0xcd,
-	0xff, 0x2c, 0x53, 0x7b, 0x4f, 0x67, 0x9d, 0x26, 0xa2, 0x5a, 0xd9, 0x65, 0xbd, 0xae, 0x5a, 0xe8,
-	0x37, 0xd9, 0x47, 0x08, 0xcd, 0x69, 0x5f, 0xb6, 0x85, 0xdd, 0x35, 0x2e, 0x39, 0xcd, 0xae, 0x51,
-	0x98, 0xb8, 0x5c, 0xbb, 0xc6, 0x80, 0x5d, 0x03, 0xfe, 0x9e, 0x06, 0xb7, 0x06, 0x72, 0xd1, 0x44,
-	0xb4, 0x49, 0x5c, 0x8a, 0xe4, 0xf7, 0xc0, 0x54, 0x33, 0x90, 0x45, 0x79, 0x39, 0xdf, 0xeb, 0xaa,
-	0x72, 0x98, 0x97, 0x62, 0x13, 0x9a, 0x20, 0x5c, 0x95, 0x6d, 0xf9, 0x31, 0x18, 0x0f, 0x9d, 0xc7,
-	0x13, 0xf4, 0x61, 0xe2, 0x4b, 0x04, 0xa9, 0x2f, 0x5c, 0x16, 0x12, 0x46, 0xdc, 0x86, 0x9f, 0xcd,
-	0x17, 0xe6, 0x36, 0x04, 0xb7, 0x21, 0x3f, 0x02, 0x93, 0x5f, 0x12, 0xec, 0x56, 0xbc, 0x92, 0xf7,
-	0xb3, 0x7e, 0x6a, 0x45, 0xd1, 0x78, 0xb9, 0x6b, 0x61, 0xb9, 0x6b, 0xdb, 0x61, 0x3f, 0x28, 0xdd,
-	0x09, 0x72, 0x6b, 0x86, 0xf3, 0x09, 0x28, 0x7c, 0xf1, 0x87, 0x2a, 0x99, 0x13, 0xde, 0xda, 0x53,
-	0x96, 0x0f, 0x41, 0x5e, 0x74, 0x9f, 0x4a, 0xcd, 0xf7, 0xb5, 0xed, 0x97, 0x46, 0xb2, 0xe8, 0x6e,
-	0xa0, 0x5a, 0x14, 0xdd, 0x01, 0x42, 0x68, 0xce, 0x08, 0xd9, 0x7a, 0x20, 0xfa, 0x29, 0x05, 0x66,
-	0xb6, 0x68, 0x7d, 0xcd, 0xb6, 0xb7, 0x89, 0xe8, 0x34, 0x43, 0x47, 0x35, 0x41, 0xd7, 0x19, 0xec,
-	0x04, 0xe9, 0xab, 0xee, 0x04, 0x99, 0x4b, 0xed, 0x04, 0xf0, 0x9b, 0x14, 0x28, 0xc4, 0x5d, 0xf7,
-	0x9f, 0x2d, 0x0c, 0xf8, 0xb7, 0x04, 0x66, 0xb7, 0x68, 0xfd, 0x33, 0xcc, 0x76, 0xed, 0x96, 0x75,
-	0x78, 0xad, 0xb9, 0xc4, 0x40, 0x94, 0xd8, 0x41, 0x2b, 0x0b, 0x2e, 0x58, 0x4e, 0x5c, 0x3c, 0x0b,
-	0xf1, 0xe2, 0xe1, 0x7c, 0xd0, 0x9c, 0x16, 0x22, 0xde, 0x1a, 0xe1, 0x2f, 0x12, 0xb8, 0x7d, 0xca,
-	0x8d, 0x45, 0x0a, 0xf4, 0x45, 0x52, 0xba, 0xc2, 0x48, 0xa6, 0x2e, 0x3b, 0x92, 0x87, 0x20, 0xe7,
-	0x35, 0x7c, 0xd2, 0x68, 0xa0, 0x1a, 0xdb, 0x44, 0x88, 0xca, 0xab, 0xe0, 0x46, 0x5f, 0x98, 0x68,
-	0x41, 0x5a, 0x4c, 0x2f, 0x65, 0x4a, 0x0b, 0xbd, 0xae, 0x3a, 0x3b, 0x10, 0x44, 0x0a, 0xcd, 0xa9,
-	0x28, 0x8a, 0x34, 0x41, 0x18, 0x61, 0x07, 0xcc, 0x9f, 0x34, 0x2c, 0x5c, 0x59, 0x01, 0xb9, 0x1a,
-	0x17, 0x23, 0xbb, 0xb2, 0x83, 0x10, 0x3f, 0x42, 0x92, 0x5a, 0x3e, 0x09, 0x87, 0x66, 0x56, 0x08,
-	0x3c, 0x43, 0xf0, 0x2b, 0x30, 0x17, 0x99, 0x2e, 0xfb, 0x23, 0x21, 0x3e, 0xb8, 0xbe, 0x9b, 0x7f,
-	0x9d, 0x02, 0x77, 0x4e, 0xb3, 0x2f, 0x1c, 0xb0, 0x0f, 0xe6, 0xa2, 0x1b, 0x60, 0xb1, 0xff, 0x7a,
-	0x37, 0xfc, 0x3f, 0x70, 0xc3, 0xed, 0xb8, 0x1b, 0x22, 0x12, 0x68, 0xce, 0x0a, 0x71, 0xdf, 0xd5,
-	0xf7, 0xc1, 0xdc, 0x0e, 0x69, 0xed, 0x20, 0x1c, 0x33, 0x99, 0x4a, 0x68, 0xf2, 0x34, 0x12, 0x68,
-	0xce, 0x0a, 0x71, 0x64, 0x12, 0xfe, 0x9c, 0x01, 0xb2, 0x98, 0x35, 0x84, 0xfc, 0xca, 0x06, 0xdf,
-	0xbb, 0x60, 0x5a, 0x1c, 0xa9, 0x62, 0x23, 0x97, 0x38, 0xbc, 0x6b, 0x98, 0x39, 0x21, 0xde, 0xf0,
-	0xa4, 0x5e, 0x7f, 0x89, 0x14, 0x83, 0xfe, 0x92, 0x49, 0xdc, 0x5f, 0x78, 0xd9, 0x05, 0xfd, 0x25,
-	0xce, 0x07, 0xcd, 0xe8, 0x2c, 0xbc, 0xbf, 0xc8, 0x7b, 0x20, 0x8b, 0x1c, 0x4c, 0xa9, 0x97, 0x5d,
-	0xde, 0xf7, 0x49, 0x30, 0x0f, 0x6c, 0x26, 0x6e, 0x69, 0x73, 0xdc, 0xe4, 0x09, 0x32, 0x68, 0xde,
-	0x08, 0xd7, 0xa6, 0xc5, 0x90, 0xfc, 0x39, 0x00, 0x94, 0x59, 0x2d, 0xc6, 0x07, 0x9b, 0xb1, 0xd7,
-	0x0e, 0x36, 0x61, 0x79, 0x05, 0xe3, 0x7e, 0x84, 0xe5, 0x93, 0xcd, 0xa4, 0x2f, 0xf0, 0x47, 0x1b,
-	0x07, 0x00, 0x6f, 0xc2, 0x6c, 0x37, 0x7d, 0xe6, 0xf1, 0xe0, 0x0d, 0x8e, 0x33, 0x6f, 0x04, 0x5f,
-	0x48, 0xa5, 0xfb, 0x1e, 0xf1, 0x5f, 0x5d, 0x55, 0x0e, 0xbf, 0x99, 0xde, 0x21, 0x0e, 0x66, 0xc8,
-	0x69, 0xb2, 0x4e, 0x64, 0x2e, 0x22, 0x84, 0x3f, 0xf8, 0xe6, 0x1c, 0xec, 0x3e, 0xe2, 0xeb, 0x7f,
-	0xd2, 0x40, 0x19, 0xcc, 0x21, 0x51, 0x48, 0xa7, 0xc4, 0x5c, 0x3a, 0x77, 0xcc, 0x53, 0x17, 0x7b,
-	0x53, 0x86, 0x89, 0x79, 0xfa, 0xda, 0x62, 0x9e, 0xb9, 0xb2, 0x98, 0x8f, 0x5e, 0x75, 0xcc, 0x9f,
-	0x4a, 0x7e, 0xcc, 0x37, 0xdb, 0x6e, 0x1d, 0xef, 0x74, 0xd6, 0x77, 0xad, 0x56, 0x1d, 0xd9, 0xe1,
-	0x7b, 0x7c, 0x6d, 0x4d, 0x7c, 0x17, 0xc0, 0xb3, 0x0f, 0x21, 0x12, 0xb0, 0x04, 0xa6, 0x5d, 0x74,
-	0x58, 0x19, 0x9c, 0x89, 0x94, 0x5e, 0x57, 0x9d, 0xe7, 0xcc, 0x31, 0x05, 0x68, 0x66, 0x5d, 0x24,
-	0xe6, 0x8b, 0xb2, 0xbd, 0xf2, 0x7c, 0x02, 0xa4, 0xb7, 0x68, 0x5d, 0xfe, 0x56, 0x02, 0xb9, 0xd8,
-	0x8f, 0x04, 0xef, 0x6b, 0xe7, 0xfa, 0x65, 0x43, 0x1b, 0xf8, 0xa4, 0x53, 0x1e, 0x0e, 0x8b, 0x14,
-	0x57, 0xfb, 0x4e, 0x02, 0x33, 0x03, 0xf3, 0xdf, 0xea, 0xf9, 0x69, 0xe3, 0x58, 0xa5, 0x34, 0x3c,
-	0x56, 0x1c, 0xea, 0x99, 0x04, 0xb2, 0xb1, 0xaf, 0x9b, 0xf3, 0xb3, 0x9e, 0x00, 0x2a, 0x1f, 0x0f,
-	0x09, 0x14, 0x67, 0x79, 0x2a, 0x81, 0xa9, 0xfe, 0xb9, 0xea, 0x41, 0x02, 0x97, 0x47, 0x30, 0xe5,
-	0xa3, 0xa1, 0x60, 0xe2, 0x14, 0xdf, 0x4b, 0x20, 0x3f, 0x38, 0xe9, 0x7c, 0x98, 0x98, 0x34, 0x02,
-	0x2b, 0xeb, 0x17, 0x00, 0x8b, 0x73, 0x3d, 0x97, 0xc0, 0x74, 0xfc, 0xe9, 0xff, 0x20, 0x69, 0x52,
-	0x0a, 0xa8, 0xb2, 0x36, 0x34, 0x54, 0x9c, 0xe8, 0x47, 0x09, 0x2c, 0x9c, 0xd5, 0x54, 0x12, 0xd0,
-	0x9f, 0x41, 0xa1, 0x94, 0x2f, 0x4c, 0x11, 0x9e, 0xb4, 0xf4, 0xc5, 0xcb, 0xa3, 0xa2, 0xf4, 0xea,
-	0xa8, 0x28, 0xfd, 0x79, 0x54, 0x94, 0x5e, 0x1c, 0x17, 0x47, 0x5e, 0x1d, 0x17, 0x47, 0x7e, 0x3d,
-	0x2e, 0x8e, 0x3c, 0x2e, 0xf5, 0x3d, 0x19, 0x81, 0xb9, 0xe5, 0x86, 0x55, 0xa5, 0xe1, 0x42, 0x3f,
-	0x30, 0x1e, 0xe8, 0x4f, 0xce, 0xfc, 0xc1, 0xd4, 0x7b, 0x52, 0xaa, 0x63, 0x7e, 0xcb, 0xbe, 0xff,
-	0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xe6, 0x13, 0x6c, 0x5f, 0x15, 0x00, 0x00,
+	// 1280 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0x4f, 0x6f, 0x1b, 0x45,
+	0x14, 0xcf, 0xda, 0x4e, 0x5a, 0x4f, 0x6a, 0x27, 0xde, 0xa4, 0xad, 0xbb, 0x2d, 0xde, 0x68, 0x10,
+	0x34, 0x08, 0xba, 0xdb, 0x6d, 0xa9, 0x80, 0x22, 0x44, 0xbb, 0x89, 0x2a, 0x19, 0x29, 0x12, 0x5a,
+	0xa5, 0x02, 0x55, 0x48, 0xab, 0xb5, 0x77, 0xe2, 0x0c, 0xf1, 0xee, 0x38, 0x9e, 0x71, 0x52, 0x1f,
+	0x38, 0x85, 0x4b, 0x05, 0x52, 0x2b, 0x24, 0x24, 0xbe, 0x01, 0x5f, 0x81, 0x8f, 0xd0, 0x63, 0x2f,
+	0x48, 0x08, 0x21, 0x83, 0x92, 0x1b, 0x17, 0x84, 0x3f, 0x01, 0xda, 0x7f, 0xb3, 0xf6, 0x6e, 0xa2,
+	0x66, 0x9d, 0x3f, 0x17, 0x4e, 0xf6, 0xbc, 0x79, 0xbf, 0xdf, 0x9b, 0x79, 0xef, 0xcd, 0x9b, 0x37,
+	0x0b, 0x6e, 0x12, 0xea, 0x10, 0x8a, 0xa9, 0xda, 0x24, 0x6e, 0x13, 0xb9, 0xac, 0x6b, 0x31, 0x64,
+	0xdf, 0x6a, 0xe3, 0xed, 0x1e, 0xb6, 0x31, 0xeb, 0xab, 0xec, 0xa9, 0xd2, 0xe9, 0x12, 0x46, 0xc4,
+	0xb7, 0x42, 0x45, 0x65, 0x54, 0x91, 0xeb, 0x29, 0x3b, 0x5a, 0x03, 0x31, 0x4b, 0x93, 0x16, 0x5b,
+	0xa4, 0x45, 0x7c, 0x84, 0xea, 0xfd, 0x0b, 0xc0, 0x92, 0xdc, 0x22, 0xa4, 0xd5, 0x46, 0xaa, 0x3f,
+	0x6a, 0xf4, 0x36, 0x54, 0x86, 0x1d, 0x44, 0x99, 0xe5, 0x74, 0x42, 0x85, 0x5a, 0x52, 0xc1, 0xee,
+	0x75, 0x2d, 0x86, 0x89, 0x1b, 0xcd, 0x37, 0x7d, 0xf3, 0x6a, 0xc3, 0xa2, 0x48, 0x0d, 0x6d, 0xa9,
+	0x4d, 0x82, 0xc3, 0x79, 0xf8, 0x6c, 0x1a, 0x54, 0xd6, 0x68, 0x6b, 0xa5, 0x8b, 0x2c, 0x86, 0x3e,
+	0x27, 0x14, 0x7b, 0x58, 0xf1, 0x5d, 0x70, 0xa1, 0x43, 0x48, 0xdb, 0xc4, 0x76, 0x55, 0x58, 0x12,
+	0x96, 0x0b, 0xba, 0x38, 0x1c, 0xc8, 0xe5, 0xbe, 0xe5, 0xb4, 0xef, 0xc3, 0x70, 0x02, 0x1a, 0x33,
+	0xde, 0xbf, 0xba, 0x2d, 0xbe, 0x03, 0x66, 0x28, 0x72, 0x6d, 0xd4, 0xad, 0xe6, 0x96, 0x84, 0xe5,
+	0xa2, 0x5e, 0x19, 0x0e, 0xe4, 0x52, 0xa0, 0x1b, 0xc8, 0xa1, 0x11, 0x2a, 0x88, 0xef, 0x03, 0xd0,
+	0x26, 0xbb, 0xa8, 0x6b, 0x32, 0xdc, 0xdc, 0xaa, 0xe6, 0x97, 0x84, 0xe5, 0xbc, 0x7e, 0x79, 0x38,
+	0x90, 0x2b, 0x81, 0x7a, 0x3c, 0x07, 0x8d, 0xa2, 0x3f, 0x58, 0xc7, 0xcd, 0x2d, 0x0f, 0xd5, 0xeb,
+	0x74, 0x22, 0x54, 0x21, 0x89, 0x8a, 0xe7, 0xa0, 0x51, 0xf4, 0x07, 0x3e, 0xca, 0x04, 0x65, 0x46,
+	0xb6, 0x90, 0x6b, 0xda, 0x88, 0xe2, 0x2e, 0xb2, 0x6f, 0x57, 0xa7, 0x97, 0x84, 0xe5, 0xd9, 0x3b,
+	0xd7, 0x94, 0xc0, 0x25, 0x8a, 0xe7, 0x92, 0xc8, 0xfd, 0xca, 0x0a, 0xc1, 0xae, 0xfe, 0xc6, 0xcb,
+	0x81, 0x3c, 0x35, 0x1c, 0xc8, 0x97, 0x03, 0xe2, 0x71, 0x38, 0x34, 0x4a, 0xbe, 0x60, 0x35, 0x1c,
+	0xa7, 0x0c, 0x68, 0xd5, 0x99, 0x93, 0x18, 0xd0, 0x12, 0x06, 0x34, 0x71, 0x07, 0x54, 0x02, 0x0d,
+	0x07, 0xbb, 0xa6, 0xe5, 0x90, 0x9e, 0xcb, 0x6e, 0x57, 0x2f, 0xf8, 0x3e, 0xfe, 0xcc, 0x23, 0xfa,
+	0x7d, 0x20, 0xbf, 0xdd, 0xc2, 0x6c, 0xb3, 0xd7, 0x50, 0x9a, 0xc4, 0x51, 0xc3, 0x48, 0x07, 0x3f,
+	0xb7, 0xa8, 0xbd, 0xa5, 0xb2, 0x7e, 0x07, 0x51, 0xa5, 0xee, 0xb2, 0xe1, 0x40, 0xae, 0x8e, 0x9a,
+	0x1c, 0x21, 0x84, 0xc6, 0x9c, 0x2f, 0x5b, 0xc3, 0xee, 0xc3, 0x40, 0x72, 0x98, 0x5d, 0xad, 0x7a,
+	0xf1, 0x74, 0xed, 0x6a, 0x29, 0xbb, 0x1a, 0xfc, 0x23, 0x0f, 0xae, 0xa5, 0x72, 0xd1, 0x40, 0xb4,
+	0x43, 0x5c, 0x8a, 0xc4, 0x0f, 0xc0, 0x6c, 0x27, 0x94, 0xc5, 0x79, 0x79, 0x65, 0x38, 0x90, 0xc5,
+	0x28, 0x2f, 0xf9, 0x24, 0x34, 0x40, 0x34, 0xaa, 0xdb, 0xe2, 0x13, 0x70, 0x21, 0x72, 0x5e, 0x90,
+	0xa0, 0x0f, 0x32, 0x6f, 0x22, 0x4c, 0x7d, 0xee, 0xb2, 0x88, 0x30, 0xe6, 0xd6, 0xfc, 0x6c, 0x3e,
+	0x31, 0xb7, 0xc6, 0xb9, 0x35, 0xf1, 0x31, 0x28, 0x7e, 0x4d, 0xb0, 0x6b, 0x7a, 0x47, 0xde, 0xcf,
+	0xfa, 0xd9, 0x3b, 0x92, 0x12, 0x1c, 0x77, 0x25, 0x3a, 0xee, 0xca, 0x7a, 0x54, 0x0f, 0xf4, 0x1b,
+	0x61, 0x6e, 0xcd, 0x07, 0x7c, 0x1c, 0x0a, 0x5f, 0xfc, 0x29, 0x0b, 0xc6, 0x45, 0x6f, 0xec, 0x29,
+	0x8b, 0xbb, 0xa0, 0xc2, 0xab, 0x8f, 0xd9, 0xf4, 0x7d, 0x6d, 0xfb, 0x47, 0x23, 0x5b, 0x74, 0x57,
+	0x51, 0x33, 0x8e, 0x6e, 0x8a, 0x10, 0x1a, 0xf3, 0x5c, 0xb6, 0x12, 0x8a, 0x7e, 0xc9, 0x81, 0xf9,
+	0x35, 0xda, 0x7a, 0x68, 0xdb, 0xeb, 0x84, 0x57, 0x9a, 0x89, 0xa3, 0x9a, 0xa1, 0xea, 0xa4, 0x2b,
+	0x41, 0xfe, 0xac, 0x2b, 0x41, 0xe1, 0x54, 0x2b, 0x01, 0xfc, 0x2e, 0x07, 0xaa, 0x49, 0xd7, 0xfd,
+	0x6f, 0x0f, 0x06, 0xfc, 0x47, 0x00, 0x0b, 0x6b, 0xb4, 0xf5, 0x05, 0x66, 0x9b, 0x76, 0xd7, 0xda,
+	0x3d, 0xd7, 0x5c, 0x62, 0x20, 0x4e, 0xec, 0xb0, 0x94, 0x85, 0x1b, 0xac, 0x67, 0x3e, 0x3c, 0x57,
+	0x93, 0x87, 0x27, 0xe0, 0x83, 0xc6, 0x1c, 0x17, 0x05, 0xa5, 0x11, 0xfe, 0x2a, 0x80, 0xeb, 0x87,
+	0xec, 0x98, 0xa7, 0xc0, 0x48, 0x24, 0x85, 0x33, 0x8c, 0x64, 0xee, 0xb4, 0x23, 0xb9, 0x0b, 0xca,
+	0x5e, 0xc1, 0x27, 0xed, 0x36, 0x6a, 0xb2, 0x47, 0x08, 0x51, 0xf1, 0x3e, 0xb8, 0x34, 0x12, 0x26,
+	0x5a, 0x15, 0x96, 0xf2, 0xcb, 0x05, 0xfd, 0xea, 0x70, 0x20, 0x2f, 0xa4, 0x82, 0x48, 0xa1, 0x31,
+	0x1b, 0x47, 0x91, 0x66, 0x08, 0x23, 0xec, 0x83, 0x2b, 0xe3, 0x86, 0xb9, 0x2b, 0x4d, 0x50, 0x6e,
+	0x06, 0x62, 0x64, 0x9b, 0x1b, 0x08, 0x05, 0x4b, 0xc8, 0x72, 0x96, 0xc7, 0xe1, 0xd0, 0x28, 0x71,
+	0x81, 0x67, 0x08, 0x7e, 0x03, 0x16, 0x63, 0xd3, 0x75, 0xbf, 0x25, 0xc4, 0x3b, 0xe7, 0xb7, 0xf3,
+	0x6f, 0x73, 0xe0, 0xc6, 0x61, 0xf6, 0xb9, 0x03, 0xb6, 0xc1, 0x62, 0xbc, 0x03, 0xcc, 0xe7, 0x5f,
+	0xef, 0x86, 0x37, 0x43, 0x37, 0x5c, 0x4f, 0xba, 0x21, 0x26, 0x81, 0xc6, 0x02, 0x17, 0x8f, 0x6c,
+	0x7d, 0x1b, 0x2c, 0x6e, 0x90, 0xee, 0x06, 0xc2, 0x09, 0x93, 0xb9, 0x8c, 0x26, 0x0f, 0x23, 0x81,
+	0xc6, 0x02, 0x17, 0xc7, 0x26, 0xe1, 0x5e, 0x01, 0x88, 0xbc, 0xd7, 0xe0, 0xf2, 0x33, 0x6b, 0x7c,
+	0x4d, 0x50, 0xe6, 0x4b, 0x32, 0xbd, 0xf6, 0x3b, 0xf3, 0x15, 0x34, 0x0e, 0x87, 0x46, 0x89, 0x0b,
+	0x3c, 0x6d, 0x71, 0x0b, 0x94, 0x90, 0x83, 0x29, 0xf5, 0xf2, 0xc3, 0x7b, 0x61, 0xf8, 0x37, 0x50,
+	0x51, 0x7f, 0x94, 0xb9, 0x28, 0x2d, 0x06, 0xe6, 0xc6, 0xc8, 0xa0, 0x71, 0x29, 0x1a, 0x1b, 0x16,
+	0x43, 0xe2, 0x97, 0x00, 0x50, 0x66, 0x75, 0x59, 0xd0, 0x9a, 0x4c, 0xbf, 0xb6, 0x35, 0x89, 0xb6,
+	0x12, 0x36, 0xec, 0x31, 0x36, 0xe8, 0x4d, 0x8a, 0xbe, 0xc0, 0x6f, 0x4e, 0x1c, 0x00, 0xbc, 0x1e,
+	0xb1, 0xd7, 0xf1, 0x99, 0xa3, 0x7e, 0x3a, 0xc9, 0xbc, 0x1a, 0xbe, 0x71, 0xf4, 0xbb, 0x1e, 0xf1,
+	0xdf, 0x03, 0x59, 0x8c, 0x5e, 0x3d, 0xef, 0x11, 0x07, 0x33, 0xe4, 0x74, 0x58, 0x3f, 0x36, 0x17,
+	0x13, 0xc2, 0x9f, 0x7c, 0x73, 0x0e, 0x76, 0x1f, 0x07, 0xe3, 0x7f, 0xf3, 0x40, 0x4a, 0x67, 0x01,
+	0x3f, 0x0a, 0x37, 0xc1, 0x5c, 0xec, 0x76, 0x1b, 0xb9, 0xc4, 0x09, 0xca, 0xab, 0x11, 0x07, 0x73,
+	0xd5, 0x93, 0x7a, 0xb7, 0x42, 0xac, 0x18, 0xde, 0x0a, 0xb9, 0x93, 0xdd, 0x0a, 0x49, 0x3e, 0x68,
+	0xc4, 0x6b, 0x09, 0x6e, 0x85, 0x74, 0xcc, 0xf3, 0xe7, 0x16, 0xf3, 0xc2, 0x99, 0xc5, 0x7c, 0xfa,
+	0xac, 0x63, 0xbe, 0x27, 0xf8, 0x31, 0x7f, 0xd4, 0x73, 0x5b, 0x78, 0xa3, 0xbf, 0xb2, 0x69, 0x75,
+	0x5b, 0xc8, 0x8e, 0x6e, 0xd4, 0x73, 0x2b, 0xc3, 0x9b, 0x00, 0x1e, 0xbd, 0x08, 0x9e, 0x80, 0x3a,
+	0x98, 0x73, 0xd1, 0xae, 0x99, 0xee, 0x6a, 0xa4, 0xe1, 0x40, 0xbe, 0x12, 0x30, 0x27, 0x14, 0xa0,
+	0x51, 0x72, 0x11, 0xef, 0x10, 0xea, 0xf6, 0x9d, 0xe7, 0x17, 0x41, 0x7e, 0x8d, 0xb6, 0xc4, 0xef,
+	0x05, 0x50, 0x4e, 0x3c, 0xf3, 0x3f, 0x54, 0x8e, 0xf5, 0x6d, 0x42, 0x49, 0x3d, 0xca, 0xa4, 0x07,
+	0x93, 0x22, 0xf9, 0xd6, 0x7e, 0x10, 0xc0, 0x7c, 0xaa, 0x83, 0xbb, 0x7f, 0x7c, 0xda, 0x24, 0x56,
+	0xd2, 0x27, 0xc7, 0xf2, 0x45, 0x3d, 0x13, 0x40, 0x29, 0xf1, 0x3e, 0x39, 0x3e, 0xeb, 0x18, 0x50,
+	0xfa, 0x74, 0x42, 0x20, 0x5f, 0xcb, 0x9e, 0x00, 0x66, 0x47, 0x3b, 0xa3, 0x7b, 0x19, 0x5c, 0x1e,
+	0xc3, 0xa4, 0x4f, 0x26, 0x82, 0xf1, 0x55, 0xfc, 0x28, 0x80, 0x4a, 0xba, 0x57, 0xf9, 0x38, 0x33,
+	0x69, 0x0c, 0x96, 0x56, 0x4e, 0x00, 0xe6, 0xeb, 0x7a, 0x2e, 0x80, 0xb9, 0xe4, 0xe5, 0xfd, 0x51,
+	0xd6, 0xa4, 0xe4, 0x50, 0xe9, 0xe1, 0xc4, 0x50, 0xbe, 0xa2, 0x9f, 0x05, 0x70, 0xf5, 0xa8, 0xa2,
+	0x92, 0x81, 0xfe, 0x08, 0x0a, 0xa9, 0x7e, 0x62, 0x8a, 0x68, 0xa5, 0xfa, 0x57, 0x2f, 0xf7, 0x6b,
+	0xc2, 0xab, 0xfd, 0x9a, 0xf0, 0xd7, 0x7e, 0x4d, 0x78, 0x71, 0x50, 0x9b, 0x7a, 0x75, 0x50, 0x9b,
+	0xfa, 0xed, 0xa0, 0x36, 0xf5, 0x44, 0x1f, 0xb9, 0x32, 0x42, 0x73, 0xb7, 0xda, 0x56, 0x83, 0x46,
+	0x03, 0x75, 0x47, 0xbb, 0xa7, 0x3e, 0x3d, 0xf2, 0x93, 0xa7, 0x77, 0xa5, 0x34, 0x66, 0xfc, 0x92,
+	0x7d, 0xf7, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x3a, 0x30, 0x06, 0x21, 0x15, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1777,7 +1776,7 @@ func (m *MsgCreateIncentive) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i -= n10
 	i = encodeVarintTx(dAtA, i, uint64(n10))
 	i--
-	dAtA[i] = 0x3a
+	dAtA[i] = 0x32
 	n11, err11 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):])
 	if err11 != nil {
 		return 0, err11
@@ -1785,7 +1784,7 @@ func (m *MsgCreateIncentive) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i -= n11
 	i = encodeVarintTx(dAtA, i, uint64(n11))
 	i--
-	dAtA[i] = 0x32
+	dAtA[i] = 0x2a
 	{
 		size := m.EmissionRate.Size()
 		i -= size
@@ -1795,24 +1794,17 @@ func (m *MsgCreateIncentive) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i = encodeVarintTx(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x2a
+	dAtA[i] = 0x22
 	{
-		size := m.IncentiveAmount.Size()
-		i -= size
-		if _, err := m.IncentiveAmount.MarshalTo(dAtA[i:]); err != nil {
+		size, err := m.IncentiveCoin.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
 			return 0, err
 		}
+		i -= size
 		i = encodeVarintTx(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x22
-	if len(m.IncentiveDenom) > 0 {
-		i -= len(m.IncentiveDenom)
-		copy(dAtA[i:], m.IncentiveDenom)
-		i = encodeVarintTx(dAtA, i, uint64(len(m.IncentiveDenom)))
-		i--
-		dAtA[i] = 0x1a
-	}
+	dAtA[i] = 0x1a
 	if len(m.Sender) > 0 {
 		i -= len(m.Sender)
 		copy(dAtA[i:], m.Sender)
@@ -1848,21 +1840,21 @@ func (m *MsgCreateIncentiveResponse) MarshalToSizedBuffer(dAtA []byte) (int, err
 	_ = i
 	var l int
 	_ = l
-	n12, err12 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MinUptime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MinUptime):])
-	if err12 != nil {
-		return 0, err12
-	}
-	i -= n12
-	i = encodeVarintTx(dAtA, i, uint64(n12))
-	i--
-	dAtA[i] = 0x2a
-	n13, err13 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):])
+	n13, err13 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MinUptime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MinUptime):])
 	if err13 != nil {
 		return 0, err13
 	}
 	i -= n13
 	i = encodeVarintTx(dAtA, i, uint64(n13))
 	i--
+	dAtA[i] = 0x2a
+	n14, err14 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):])
+	if err14 != nil {
+		return 0, err14
+	}
+	i -= n14
+	i = encodeVarintTx(dAtA, i, uint64(n14))
+	i--
 	dAtA[i] = 0x22
 	{
 		size := m.EmissionRate.Size()
@@ -1922,20 +1914,20 @@ func (m *MsgFungifyChargedPositions) MarshalToSizedBuffer(dAtA []byte) (int, err
 		dAtA[i] = 0x12
 	}
 	if len(m.PositionIds) > 0 {
-		dAtA15 := make([]byte, len(m.PositionIds)*10)
-		var j14 int
+		dAtA16 := make([]byte, len(m.PositionIds)*10)
+		var j15 int
 		for _, num := range m.PositionIds {
 			for num >= 1<<7 {
-				dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j14++
+				j15++
 			}
-			dAtA15[j14] = uint8(num)
-			j14++
+			dAtA16[j15] = uint8(num)
+			j15++
 		}
-		i -= j14
-		copy(dAtA[i:], dAtA15[:j14])
-		i = encodeVarintTx(dAtA, i, uint64(j14))
+		i -= j15
+		copy(dAtA[i:], dAtA16[:j15])
+		i = encodeVarintTx(dAtA, i, uint64(j15))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -2187,11 +2179,7 @@ func (m *MsgCreateIncentive) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTx(uint64(l))
 	}
-	l = len(m.IncentiveDenom)
-	if l > 0 {
-		n += 1 + l + sovTx(uint64(l))
-	}
-	l = m.IncentiveAmount.Size()
+	l = m.IncentiveCoin.Size()
 	n += 1 + l + sovTx(uint64(l))
 	l = m.EmissionRate.Size()
 	n += 1 + l + sovTx(uint64(l))
@@ -3895,41 +3883,9 @@ func (m *MsgCreateIncentive) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IncentiveDenom", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTx
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTx
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTx
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.IncentiveDenom = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IncentiveAmount", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IncentiveCoin", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTx
@@ -3939,27 +3895,26 @@ func (m *MsgCreateIncentive) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthTx
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthTx
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.IncentiveAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.IncentiveCoin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 5:
+		case 4:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field EmissionRate", wireType)
 			}
@@ -3993,7 +3948,7 @@ func (m *MsgCreateIncentive) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 6:
+		case 5:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
 			}
@@ -4026,7 +3981,7 @@ func (m *MsgCreateIncentive) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 7:
+		case 6:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field MinUptime", wireType)
 			}
diff --git a/x/cosmwasmpool/types/keys.go b/x/cosmwasmpool/types/keys.go
index 9ca7d73be..88b4651c8 100644
--- a/x/cosmwasmpool/types/keys.go
+++ b/x/cosmwasmpool/types/keys.go
@@ -12,8 +12,10 @@ const (
 	RouterKey = ModuleName
 )
 
-// PoolsKey defines the store key for pools.
-var PoolsKey = []byte{0x01}
+var (
+	// PoolKey defines the store key for pools.
+	PoolsKey = []byte{0x01}
+)
 
 func FormatPoolsPrefix(poolId uint64) []byte {
 	return append(PoolsKey, sdk.Uint64ToBigEndian(poolId)...)
diff --git a/x/downtime-detector/types/constants.go b/x/downtime-detector/types/constants.go
index 0c6a5392f..86020ed6b 100644
--- a/x/downtime-detector/types/constants.go
+++ b/x/downtime-detector/types/constants.go
@@ -17,10 +17,8 @@ const (
 	QuerierRoute = ModuleName
 )
 
-var (
-	DowntimeToDuration  = btree.NewMap[Downtime, time.Duration](16)
-	DefaultLastDowntime = time.Unix(0, 0)
-)
+var DowntimeToDuration = btree.NewMap[Downtime, time.Duration](16)
+var DefaultLastDowntime = time.Unix(0, 0)
 
 // init initializes the DowntimeToDuration map with mappings
 // from the Duration enum values to their corresponding
diff --git a/x/epochs/client/cli/query.go b/x/epochs/client/cli/query.go
index ea3412304..0fa799b0a 100644
--- a/x/epochs/client/cli/query.go
+++ b/x/epochs/client/cli/query.go
@@ -22,8 +22,7 @@ func GetCmdEpochInfos() (*osmocli.QueryDescriptor, *types.QueryEpochsInfoRequest
 		Short: "Query running epoch infos.",
 		Long: `{{.Short}}{{.ExampleHeader}}
 {{.CommandPrefix}}`,
-		QueryFnName: "EpochInfos",
-	}, &types.QueryEpochsInfoRequest{}
+		QueryFnName: "EpochInfos"}, &types.QueryEpochsInfoRequest{}
 }
 
 func GetCmdCurrentEpoch() (*osmocli.QueryDescriptor, *types.QueryCurrentEpochRequest) {
@@ -31,6 +30,5 @@ func GetCmdCurrentEpoch() (*osmocli.QueryDescriptor, *types.QueryCurrentEpochReq
 		Use:   "current-epoch",
 		Short: "Query current epoch by specified identifier.",
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} day`,
-	}, &types.QueryCurrentEpochRequest{}
+{{.CommandPrefix}} day`}, &types.QueryCurrentEpochRequest{}
 }
diff --git a/x/gamm/client/cli/query.go b/x/gamm/client/cli/query.go
index 43d1fbaa6..c7595a8a5 100644
--- a/x/gamm/client/cli/query.go
+++ b/x/gamm/client/cli/query.go
@@ -55,8 +55,7 @@ func GetCmdPool() (*osmocli.QueryDescriptor, *types.QueryPoolRequest) {
 		// Deprecated: use x/poolmanager's Pool query.
 		// nolint: staticcheck
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} pool 1`,
-	}, &types.QueryPoolRequest{}
+{{.CommandPrefix}} pool 1`}, &types.QueryPoolRequest{}
 }
 
 // TODO: Push this to the SDK.
@@ -86,8 +85,7 @@ func GetCmdPools() (*osmocli.QueryDescriptor, *types.QueryPoolsRequest) {
 		Use:   "pools",
 		Short: "Query pools",
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} pools`,
-	}, &types.QueryPoolsRequest{}
+{{.CommandPrefix}} pools`}, &types.QueryPoolsRequest{}
 }
 
 // nolint: staticcheck
@@ -191,8 +189,7 @@ func GetCmdSpotPrice() (*osmocli.QueryDescriptor, *types.QuerySpotPriceRequest)
 		Short: "Query spot-price (LEGACY, arguments are reversed!!)",
 		Long: `Query spot price (Legacy).{{.ExampleHeader}}
 {{.CommandPrefix}} spot-price 1 uosmo ibc/27394FB092D2ECCD56123C74F36E4C1F926001CEADA9CA97EA622B25F41E5EB2
-`,
-	}, &types.QuerySpotPriceRequest{}
+`}, &types.QuerySpotPriceRequest{}
 }
 
 // Deprecated: use alternate in x/poolmanager.
diff --git a/x/gamm/keeper/migrate.go b/x/gamm/keeper/migrate.go
index 471df1df6..14755c27a 100644
--- a/x/gamm/keeper/migrate.go
+++ b/x/gamm/keeper/migrate.go
@@ -17,8 +17,7 @@ import (
 // Fails if the lp tokens are locked (must instead utilize UnlockAndMigrate function in the superfluid module)
 func (k Keeper) MigrateUnlockedPositionFromBalancerToConcentrated(ctx sdk.Context,
 	sender sdk.AccAddress, sharesToMigrate sdk.Coin,
-	tokenOutMins sdk.Coins,
-) (positionId uint64, amount0, amount1 sdk.Int, liquidity sdk.Dec, joinTime time.Time, poolIdLeaving, poolIdEntering uint64, err error) {
+	tokenOutMins sdk.Coins) (positionId uint64, amount0, amount1 sdk.Int, liquidity sdk.Dec, joinTime time.Time, poolIdLeaving, poolIdEntering uint64, err error) {
 	// Get the balancer poolId by parsing the gamm share denom.
 	poolIdLeaving, err = types.GetPoolIdFromShareDenom(sharesToMigrate.Denom)
 	if err != nil {
diff --git a/x/ibc-hooks/client/cli/query.go b/x/ibc-hooks/client/cli/query.go
index 2a4eb3f58..c17c60294 100644
--- a/x/ibc-hooks/client/cli/query.go
+++ b/x/ibc-hooks/client/cli/query.go
@@ -2,13 +2,12 @@ package cli
 
 import (
 	"fmt"
-	"strings"
-
 	"github.com/cosmos/cosmos-sdk/client/flags"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/version"
 	"github.com/osmosis-labs/osmosis/x/ibc-hooks/keeper"
 	"github.com/spf13/cobra"
+	"strings"
 
 	"github.com/osmosis-labs/osmosis/x/ibc-hooks/types"
 )
diff --git a/x/ibc-hooks/keeper/keeper.go b/x/ibc-hooks/keeper/keeper.go
index 9d14337bc..7562a0fd3 100644
--- a/x/ibc-hooks/keeper/keeper.go
+++ b/x/ibc-hooks/keeper/keeper.go
@@ -2,7 +2,6 @@ package keeper
 
 import (
 	"fmt"
-
 	"github.com/cosmos/cosmos-sdk/types/address"
 
 	"github.com/tendermint/tendermint/libs/log"
diff --git a/x/ibc-rate-limit/types/keys.go b/x/ibc-rate-limit/types/keys.go
index 8a278c9f5..85a5a0726 100644
--- a/x/ibc-rate-limit/types/keys.go
+++ b/x/ibc-rate-limit/types/keys.go
@@ -7,6 +7,8 @@ const (
 
 )
 
-// RouterKey is the message route. Can only contain
-// alphanumeric characters.
-var RouterKey = strings.ReplaceAll(ModuleName, "-", "")
+var (
+	// RouterKey is the message route. Can only contain
+	// alphanumeric characters.
+	RouterKey = strings.ReplaceAll(ModuleName, "-", "")
+)
diff --git a/x/incentives/client/cli/query.go b/x/incentives/client/cli/query.go
index ee17fbe2e..6fbf775ac 100644
--- a/x/incentives/client/cli/query.go
+++ b/x/incentives/client/cli/query.go
@@ -48,8 +48,7 @@ func GetCmdToDistributeCoins() (*osmocli.QueryDescriptor, *types.ModuleToDistrib
 	return &osmocli.QueryDescriptor{
 		Use:   "to-distribute-coins",
 		Short: "Query coins that is going to be distributed",
-		Long:  `{{.Short}}`,
-	}, &types.ModuleToDistributeCoinsRequest{}
+		Long:  `{{.Short}}`}, &types.ModuleToDistributeCoinsRequest{}
 }
 
 // GetCmdGaugeByID returns a gauge by ID.
@@ -59,8 +58,7 @@ func GetCmdGaugeByID() (*osmocli.QueryDescriptor, *types.GaugeByIDRequest) {
 		Short: "Query gauge by id.",
 		Long: `{{.Short}}{{.ExampleHeader}}
 {{.CommandPrefix}} gauge-by-id 1
-`,
-	}, &types.GaugeByIDRequest{}
+`}, &types.GaugeByIDRequest{}
 }
 
 // GetCmdActiveGauges returns active gauges.
@@ -68,8 +66,7 @@ func GetCmdActiveGauges() (*osmocli.QueryDescriptor, *types.ActiveGaugesRequest)
 	return &osmocli.QueryDescriptor{
 		Use:   "active-gauges",
 		Short: "Query active gauges",
-		Long:  `{{.Short}}`,
-	}, &types.ActiveGaugesRequest{}
+		Long:  `{{.Short}}`}, &types.ActiveGaugesRequest{}
 }
 
 // GetCmdActiveGaugesPerDenom returns active gauges for a specified denom.
@@ -78,8 +75,7 @@ func GetCmdActiveGaugesPerDenom() (*osmocli.QueryDescriptor, *types.ActiveGauges
 		Use:   "active-gauges-per-den [den]denom [denom]",
 		Short: "Query active gauges per denom",
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} active-gauges-per-denom gamm/pool/1`,
-	}, &types.ActiveGaugesPerDenomRequest{}
+{{.CommandPrefix}} active-gauges-per-denom gamm/pool/1`}, &types.ActiveGaugesPerDenomRequest{}
 }
 
 // GetCmdUpcomingGauges returns scheduled gauges.
@@ -87,8 +83,7 @@ func GetCmdUpcomingGauges() (*osmocli.QueryDescriptor, *types.UpcomingGaugesRequ
 	return &osmocli.QueryDescriptor{
 		Use:   "upcoming-gauges",
 		Short: "Query upcoming gauges",
-		Long:  `{{.Short}}`,
-	}, &types.UpcomingGaugesRequest{}
+		Long:  `{{.Short}}`}, &types.UpcomingGaugesRequest{}
 }
 
 // GetCmdUpcomingGaugesPerDenom returns scheduled gauges for specified denom..
@@ -96,8 +91,7 @@ func GetCmdUpcomingGaugesPerDenom() (*osmocli.QueryDescriptor, *types.UpcomingGa
 	return &osmocli.QueryDescriptor{
 		Use:   "upcoming-gauges-per-denom [denom]",
 		Short: "Query scheduled gauges per denom",
-		Long:  `{{.Short}}`,
-	}, &types.UpcomingGaugesPerDenomRequest{}
+		Long:  `{{.Short}}`}, &types.UpcomingGaugesPerDenomRequest{}
 }
 
 // GetCmdRewardsEst returns rewards estimation.
diff --git a/x/incentives/keeper/distribute.go b/x/incentives/keeper/distribute.go
index fc273fee0..9342037c2 100644
--- a/x/incentives/keeper/distribute.go
+++ b/x/incentives/keeper/distribute.go
@@ -269,12 +269,12 @@ func (k Keeper) distributeConcentratedLiquidity(ctx sdk.Context, poolId uint64,
 	_, err := k.clk.CreateIncentive(ctx,
 		poolId,
 		sender,
-		incentiveCoin.Denom,
-		incentiveCoin.Amount,
+		incentiveCoin,
 		emissionRate,
 		startTime,
 		minUptime,
 	)
+
 	if err != nil {
 		return err
 	}
diff --git a/x/incentives/types/expected_keepers.go b/x/incentives/types/expected_keepers.go
index bface422c..76e84c1c6 100644
--- a/x/incentives/types/expected_keepers.go
+++ b/x/incentives/types/expected_keepers.go
@@ -47,7 +47,7 @@ type TxFeesKeeper interface {
 }
 
 type ConcentratedLiquidityKeeper interface {
-	CreateIncentive(ctx sdk.Context, poolId uint64, sender sdk.AccAddress, incentiveDenom string, incentiveAmount sdk.Int, emissionRate sdk.Dec, startTime time.Time, minUptime time.Duration) (cltypes.IncentiveRecord, error)
+	CreateIncentive(ctx sdk.Context, poolId uint64, sender sdk.AccAddress, incentiveCoin sdk.Coin, emissionRate sdk.Dec, startTime time.Time, minUptime time.Duration) (cltypes.IncentiveRecord, error)
 	GetPoolFromPoolIdAndConvertToConcentrated(ctx sdk.Context, poolId uint64) (cltypes.ConcentratedPoolExtension, error)
 }
 
diff --git a/x/lockup/client/cli/query.go b/x/lockup/client/cli/query.go
index 8041c88ef..0c8b98e14 100644
--- a/x/lockup/client/cli/query.go
+++ b/x/lockup/client/cli/query.go
@@ -59,8 +59,7 @@ func GetCmdModuleBalance() (*osmocli.QueryDescriptor, *types.ModuleBalanceReques
 	return &osmocli.QueryDescriptor{
 		Use:   "module-balance",
 		Short: "Query module balance",
-		Long:  `{{.Short}}`,
-	}, &types.ModuleBalanceRequest{}
+		Long:  `{{.Short}}`}, &types.ModuleBalanceRequest{}
 }
 
 // GetCmdModuleLockedAmount returns locked balance of the module,
@@ -69,8 +68,7 @@ func GetCmdModuleLockedAmount() (*osmocli.QueryDescriptor, *types.ModuleLockedAm
 	return &osmocli.QueryDescriptor{
 		Use:   "module-locked-amount",
 		Short: "Query locked amount",
-		Long:  `{{.Short}}`,
-	}, &types.ModuleLockedAmountRequest{}
+		Long:  `{{.Short}}`}, &types.ModuleLockedAmountRequest{}
 }
 
 // GetCmdAccountUnlockableCoins returns unlockable coins which has finsihed unlocking.
@@ -117,8 +115,7 @@ func GetCmdAccountUnlockingCoins() (*osmocli.QueryDescriptor, *types.AccountUnlo
 		Use:   "account-unlocking-coins <address>",
 		Short: "Query account's unlocking coins",
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} account-unlocking-coins <address>`,
-	}, &types.AccountUnlockingCoinsRequest{}
+{{.CommandPrefix}} account-unlocking-coins <address>`}, &types.AccountUnlockingCoinsRequest{}
 }
 
 // GetCmdAccountLockedCoins returns locked coins that that are still in a locked state from the specified account.
@@ -138,8 +135,7 @@ func GetCmdAccountLockedPastTime() (*osmocli.QueryDescriptor, *types.AccountLock
 		Short: "Query locked records of an account with unlock time beyond timestamp",
 		Long: `{{.Short}}{{.ExampleHeader}}
 {{.CommandPrefix}} account-locked-pastime <address> <timestamp>
-`,
-	}, &types.AccountLockedPastTimeRequest{}
+`}, &types.AccountLockedPastTimeRequest{}
 }
 
 // GetCmdAccountLockedPastTimeNotUnlockingOnly returns locks of an account with unlock time beyond provided timestamp
@@ -151,8 +147,7 @@ func GetCmdAccountLockedPastTimeNotUnlockingOnly() (*osmocli.QueryDescriptor, *t
 		Long: `{{.Short}}
 Timestamp is UNIX time in seconds.{{.ExampleHeader}}
 {{.CommandPrefix}} account-locked-pastime-not-unlocking <address> <timestamp>
-`,
-	}, &types.AccountLockedPastTimeNotUnlockingOnlyRequest{}
+`}, &types.AccountLockedPastTimeNotUnlockingOnlyRequest{}
 }
 
 // GetCmdAccountUnlockedBeforeTime returns locks with unlock time before the provided timestamp.
diff --git a/x/pool-incentives/keeper/hooks.go b/x/pool-incentives/keeper/hooks.go
index f57e40bee..7576eb724 100644
--- a/x/pool-incentives/keeper/hooks.go
+++ b/x/pool-incentives/keeper/hooks.go
@@ -71,12 +71,15 @@ func (h Hooks) AfterConcentratedPoolCreated(ctx sdk.Context, sender sdk.AccAddre
 
 // AfterInitialPoolPositionCreated is a noop.
 func (h Hooks) AfterInitialPoolPositionCreated(ctx sdk.Context, sender sdk.AccAddress, poolId uint64) {
+
 }
 
 // AfterLastPoolPositionRemoved is a noop.
 func (h Hooks) AfterLastPoolPositionRemoved(ctx sdk.Context, sender sdk.AccAddress, poolId uint64) {
+
 }
 
 // AfterConcentratedPoolSwap is a noop.
 func (h Hooks) AfterConcentratedPoolSwap(ctx sdk.Context, sender sdk.AccAddress, poolId uint64) {
+
 }
diff --git a/x/poolmanager/client/cli/query.go b/x/poolmanager/client/cli/query.go
index cc1087f4f..31d9171bd 100644
--- a/x/poolmanager/client/cli/query.go
+++ b/x/poolmanager/client/cli/query.go
@@ -74,8 +74,7 @@ func GetCmdPool() (*osmocli.QueryDescriptor, *queryproto.PoolRequest) {
 		Use:   "pool [poolID]",
 		Short: "Query pool",
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} pool 1`,
-	}, &queryproto.PoolRequest{}
+{{.CommandPrefix}} pool 1`}, &queryproto.PoolRequest{}
 }
 
 func GetCmdSpotPrice() (*osmocli.QueryDescriptor, *queryproto.SpotPriceRequest) {
@@ -84,8 +83,7 @@ func GetCmdSpotPrice() (*osmocli.QueryDescriptor, *queryproto.SpotPriceRequest)
 		Short: "Query spot-price",
 		Long: `Query spot-price
 {{.CommandPrefix}} spot-price 1 uosmo ibc/27394FB092D2ECCD56123C74F36E4C1F926001CEADA9CA97EA622B25F41E5EB2
-`,
-	}, &queryproto.SpotPriceRequest{}
+`}, &queryproto.SpotPriceRequest{}
 }
 
 func EstimateSwapExactAmountInParseArgs(args []string, fs *flag.FlagSet) (proto.Message, error) {
diff --git a/x/poolmanager/client/cli/tx.go b/x/poolmanager/client/cli/tx.go
index a8c2bc198..9a5daad9f 100644
--- a/x/poolmanager/client/cli/tx.go
+++ b/x/poolmanager/client/cli/tx.go
@@ -56,7 +56,6 @@ func NewSwapExactAmountOutCmd() (*osmocli.TxCliDesc, *types.MsgSwapExactAmountOu
 		Flags:            osmocli.FlagDesc{RequiredFlags: []*flag.FlagSet{FlagSetMultihopSwapRoutes()}},
 	}, &types.MsgSwapExactAmountOut{}
 }
-
 func NewBuildSwapExactAmountInMsg(clientCtx client.Context, tokenInStr, tokenOutMinAmtStr string, txf tx.Factory, fs *flag.FlagSet) (tx.Factory, sdk.Msg, error) {
 	routes, err := swapAmountInRoutes(fs)
 	if err != nil {
diff --git a/x/poolmanager/router.go b/x/poolmanager/router.go
index dd2e1f8a2..aa103f154 100644
--- a/x/poolmanager/router.go
+++ b/x/poolmanager/router.go
@@ -12,8 +12,10 @@ import (
 	"github.com/osmosis-labs/osmosis/v15/x/poolmanager/types"
 )
 
-// 1 << 256 - 1 where 256 is the max bit length defined for sdk.Int
-var intMaxValue = sdk.NewIntFromBigInt(new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(1)))
+var (
+	// 1 << 256 - 1 where 256 is the max bit length defined for sdk.Int
+	intMaxValue = sdk.NewIntFromBigInt(new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(1)))
+)
 
 // RouteExactAmountIn defines the input denom and input amount for the first pool,
 // the output of the first pool is chained as the input for the next routed pool
diff --git a/x/protorev/keeper/epoch_hook.go b/x/protorev/keeper/epoch_hook.go
index 1e640d2e4..c1326ebcb 100644
--- a/x/protorev/keeper/epoch_hook.go
+++ b/x/protorev/keeper/epoch_hook.go
@@ -16,7 +16,9 @@ type LiquidityPoolStruct struct {
 	PoolId    uint64
 }
 
-var _ epochstypes.EpochHooks = EpochHooks{}
+var (
+	_ epochstypes.EpochHooks = EpochHooks{}
+)
 
 func (k Keeper) EpochHooks() epochstypes.EpochHooks {
 	return EpochHooks{k}
diff --git a/x/protorev/keeper/posthandler.go b/x/protorev/keeper/posthandler.go
index a17c8ae50..295a36969 100644
--- a/x/protorev/keeper/posthandler.go
+++ b/x/protorev/keeper/posthandler.go
@@ -169,8 +169,7 @@ func extractSwapInPools(routes []poolmanagertypes.SwapAmountInRoute, tokenInDeno
 		swappedPools = append(swappedPools, SwapToBackrun{
 			PoolId:        route.PoolId,
 			TokenOutDenom: route.TokenOutDenom,
-			TokenInDenom:  prevTokenIn,
-		})
+			TokenInDenom:  prevTokenIn})
 
 		prevTokenIn = route.TokenOutDenom
 	}
@@ -188,8 +187,7 @@ func extractSwapOutPools(routes []poolmanagertypes.SwapAmountOutRoute, tokenOutD
 		swappedPools = append(swappedPools, SwapToBackrun{
 			PoolId:        route.PoolId,
 			TokenOutDenom: prevTokenOut,
-			TokenInDenom:  route.TokenInDenom,
-		})
+			TokenInDenom:  route.TokenInDenom})
 
 		prevTokenOut = route.TokenInDenom
 	}
diff --git a/x/protorev/keeper/rebalance.go b/x/protorev/keeper/rebalance.go
index 7f260eb96..7e97a4a0e 100644
--- a/x/protorev/keeper/rebalance.go
+++ b/x/protorev/keeper/rebalance.go
@@ -79,6 +79,7 @@ func (k Keeper) ConvertProfits(ctx sdk.Context, inputCoin sdk.Coin, profit sdk.I
 		types.OsmosisDenomination,
 		conversionPool.GetSwapFee(ctx),
 	)
+
 	if err != nil {
 		return profit, err
 	}
diff --git a/x/protorev/types/constants.go b/x/protorev/types/constants.go
index 254eefb80..f2974579e 100644
--- a/x/protorev/types/constants.go
+++ b/x/protorev/types/constants.go
@@ -30,16 +30,12 @@ const MaxPoolPointsPerBlock uint64 = 200
 // ---------------- Module Profit Splitting Constants ---------------- //
 
 // Year 1 (20% of total profit)
-const (
-	Phase1Length      uint64 = 365
-	ProfitSplitPhase1 int64  = 20
-)
+const Phase1Length uint64 = 365
+const ProfitSplitPhase1 int64 = 20
 
 // Year 2 (10% of total profit)
-const (
-	Phase2Length      uint64 = 730
-	ProfitSplitPhase2 int64  = 10
-)
+const Phase2Length uint64 = 730
+const ProfitSplitPhase2 int64 = 10
 
 // All other years (5% of total profit)
 const ProfitSplitPhase3 int64 = 5
diff --git a/x/superfluid/keeper/migrate.go b/x/superfluid/keeper/migrate.go
index b9a5ea10f..7dbec203f 100644
--- a/x/superfluid/keeper/migrate.go
+++ b/x/superfluid/keeper/migrate.go
@@ -53,8 +53,7 @@ func (k Keeper) migrateSuperfluidBondedBalancerToConcentrated(ctx sdk.Context,
 	synthDenomBeforeMigration string,
 	concentratedPool cltypes.ConcentratedPoolExtension,
 	remainingLockTime time.Duration,
-	tokenOutMins sdk.Coins,
-) (positionId uint64, amount0, amount1 sdk.Int, liquidity sdk.Dec, joinTime time.Time, gammLockId, concentratedLockId uint64, err error) {
+	tokenOutMins sdk.Coins) (positionId uint64, amount0, amount1 sdk.Int, liquidity sdk.Dec, joinTime time.Time, gammLockId, concentratedLockId uint64, err error) {
 	// Get the validator address from the synth denom and ensure it is a valid address.
 	valAddr := strings.Split(synthDenomBeforeMigration, "/")[4]
 	_, err = sdk.ValAddressFromBech32(valAddr)
@@ -121,8 +120,7 @@ func (k Keeper) migrateSuperfluidUnbondingBalancerToConcentrated(ctx sdk.Context
 	synthDenomBeforeMigration string,
 	concentratedPool cltypes.ConcentratedPoolExtension,
 	remainingLockTime time.Duration,
-	tokenOutMins sdk.Coins,
-) (positionId uint64, amount0, amount1 sdk.Int, liquidity sdk.Dec, joinTime time.Time, gammLockId, concentratedLockId uint64, err error) {
+	tokenOutMins sdk.Coins) (positionId uint64, amount0, amount1 sdk.Int, liquidity sdk.Dec, joinTime time.Time, gammLockId, concentratedLockId uint64, err error) {
 	// Get the validator address from the synth denom and ensure it is a valid address.
 	valAddr := strings.Split(synthDenomBeforeMigration, "/")[4]
 	_, err = sdk.ValAddressFromBech32(valAddr)
@@ -206,8 +204,7 @@ func (k Keeper) migrateNonSuperfluidLockBalancerToConcentrated(ctx sdk.Context,
 	sharesToMigrate sdk.Coin,
 	concentratedPool cltypes.ConcentratedPoolExtension,
 	remainingLockTime time.Duration,
-	tokenOutMins sdk.Coins,
-) (positionId uint64, amount0, amount1 sdk.Int, liquidity sdk.Dec, joinTime time.Time, gammLockId, concentratedLockId uint64, err error) {
+	tokenOutMins sdk.Coins) (positionId uint64, amount0, amount1 sdk.Int, liquidity sdk.Dec, joinTime time.Time, gammLockId, concentratedLockId uint64, err error) {
 	// Save unlocking state of lock before force unlocking
 	wasUnlocking := preMigrationLock.IsUnlocking()
 
diff --git a/x/superfluid/types/msgs.go b/x/superfluid/types/msgs.go
index 38f77e667..e35017498 100644
--- a/x/superfluid/types/msgs.go
+++ b/x/superfluid/types/msgs.go
@@ -362,7 +362,6 @@ func (msg MsgAddToConcentratedLiquiditySuperfluidPosition) Route() string { retu
 func (msg MsgAddToConcentratedLiquiditySuperfluidPosition) Type() string {
 	return TypeMsgAddToConcentratedLiquiditySuperfluidPosition
 }
-
 func (msg MsgAddToConcentratedLiquiditySuperfluidPosition) ValidateBasic() error {
 	_, err := sdk.AccAddressFromBech32(msg.Sender)
 	if err != nil {
diff --git a/x/twap/client/cli/query.go b/x/twap/client/cli/query.go
index a8b33696c..78479c9d0 100644
--- a/x/twap/client/cli/query.go
+++ b/x/twap/client/cli/query.go
@@ -61,6 +61,7 @@ Example:
 				StartTime:  startTime,
 				EndTime:    &endTime,
 			})
+
 			if err != nil {
 				return err
 			}
@@ -112,6 +113,7 @@ Example:
 				StartTime:  startTime,
 				EndTime:    &endTime,
 			})
+
 			if err != nil {
 				return err
 			}


Test patch:
diff --git a/app/upgrades/v13/upgrade_test.go b/app/upgrades/v13/upgrade_test.go
index d0a0b3167..9043a9685 100644
--- a/app/upgrades/v13/upgrade_test.go
+++ b/app/upgrades/v13/upgrade_test.go
@@ -2,9 +2,8 @@ package v13_test
 
 import (
 	"fmt"
-	"testing"
-
 	ibchookstypes "github.com/osmosis-labs/osmosis/x/ibc-hooks/types"
+	"testing"
 
 	ibcratelimittypes "github.com/osmosis-labs/osmosis/v15/x/ibc-rate-limit/types"
 
@@ -56,8 +55,8 @@ func (suite *UpgradeTestSuite) TestUpgrade() {
 			"Test that the upgrade succeeds",
 			func() {
 				// The module doesn't need an account anymore, but when the upgrade happened we did:
-				// acc := suite.App.AccountKeeper.GetAccount(suite.Ctx, ibc_hooks.WasmHookModuleAccountAddr)
-				// suite.App.AccountKeeper.RemoveAccount(suite.Ctx, acc)
+				//acc := suite.App.AccountKeeper.GetAccount(suite.Ctx, ibc_hooks.WasmHookModuleAccountAddr)
+				//suite.App.AccountKeeper.RemoveAccount(suite.Ctx, acc)
 
 				// Because of SDK version map bug, we can't do the following, and instaed do a massive hack
 				// vm := suite.App.UpgradeKeeper.GetModuleVersionMap(suite.Ctx)
@@ -71,15 +70,15 @@ func (suite *UpgradeTestSuite) TestUpgrade() {
 				versionStore.Delete([]byte(ibchookstypes.ModuleName))
 
 				// Same comment as above: this was the case when the upgrade happened, but we don't have accounts anymore
-				// hasAcc := suite.App.AccountKeeper.HasAccount(suite.Ctx, ibc_hooks.WasmHookModuleAccountAddr)
-				// suite.Require().False(hasAcc)
+				//hasAcc := suite.App.AccountKeeper.HasAccount(suite.Ctx, ibc_hooks.WasmHookModuleAccountAddr)
+				//suite.Require().False(hasAcc)
 
 			},
 			func() { dummyUpgrade(suite) },
 			func() {
 				// Same comment as pre-upgrade. We had an account, but now we don't anymore
-				// hasAcc := suite.App.AccountKeeper.HasAccount(suite.Ctx, ibc_hooks.WasmHookModuleAccountAddr)
-				// suite.Require().True(hasAcc)
+				//hasAcc := suite.App.AccountKeeper.HasAccount(suite.Ctx, ibc_hooks.WasmHookModuleAccountAddr)
+				//suite.Require().True(hasAcc)
 			},
 		},
 		{
diff --git a/app/upgrades/v15/upgrade_test.go b/app/upgrades/v15/upgrade_test.go
index ea7c326e7..bd0370796 100644
--- a/app/upgrades/v15/upgrade_test.go
+++ b/app/upgrades/v15/upgrade_test.go
@@ -50,7 +50,9 @@ func (suite *UpgradeTestSuite) TestMigrateNextPoolIdAndCreatePool() {
 		expectedNextPoolId uint64 = 1
 	)
 
-	gammKeeperType := reflect.TypeOf(&gamm.Keeper{})
+	var (
+		gammKeeperType = reflect.TypeOf(&gamm.Keeper{})
+	)
 
 	ctx := suite.Ctx
 	gammKeeper := suite.App.GAMMKeeper
@@ -179,7 +181,7 @@ func (suite *UpgradeTestSuite) TestRegisterOsmoIonMetadata() {
 	uosmoMetadata, found := suite.App.BankKeeper.GetDenomMetaData(ctx, "uosmo")
 	suite.Require().False(found)
 
-	_, found = suite.App.BankKeeper.GetDenomMetaData(ctx, "uion")
+	uionMetadata, found := suite.App.BankKeeper.GetDenomMetaData(ctx, "uion")
 	suite.Require().False(found)
 
 	// system under test.
@@ -188,7 +190,7 @@ func (suite *UpgradeTestSuite) TestRegisterOsmoIonMetadata() {
 	uosmoMetadata, found = suite.App.BankKeeper.GetDenomMetaData(ctx, "uosmo")
 	suite.Require().True(found)
 
-	uionMetadata, found := suite.App.BankKeeper.GetDenomMetaData(ctx, "uion")
+	uionMetadata, found = suite.App.BankKeeper.GetDenomMetaData(ctx, "uion")
 	suite.Require().True(found)
 
 	suite.Require().Equal(expectedUosmodenom, uosmoMetadata.Base)
@@ -247,6 +249,7 @@ func (suite *UpgradeTestSuite) TestSetRateLimits() {
 	// This is the last one. If the others failed the upgrade would've panicked before adding this one
 	state, err = suite.App.WasmKeeper.QuerySmart(suite.Ctx, addr, []byte(`{"get_quotas": {"channel_id": "any", "denom": "ibc/E6931F78057F7CC5DA0FD6CEF82FF39373A6E0452BF1FD76910B93292CF356C1"}}`))
 	suite.Require().Greaterf(len(state), 0, "state should not be empty")
+
 }
 
 func (suite *UpgradeTestSuite) validateCons(coinsA, coinsB sdk.Coins) {
diff --git a/app/upgrades/v16/upgrades_test.go b/app/upgrades/v16/upgrades_test.go
index d77cfadb1..ac1d41bc8 100644
--- a/app/upgrades/v16/upgrades_test.go
+++ b/app/upgrades/v16/upgrades_test.go
@@ -35,7 +35,7 @@ func dummyUpgrade(suite *UpgradeTestSuite) {
 	plan := upgradetypes.Plan{Name: "v16", Height: dummyUpgradeHeight}
 	err := suite.App.UpgradeKeeper.ScheduleUpgrade(suite.Ctx, plan)
 	suite.Require().NoError(err)
-	_, exists := suite.App.UpgradeKeeper.GetUpgradePlan(suite.Ctx)
+	plan, exists := suite.App.UpgradeKeeper.GetUpgradePlan(suite.Ctx)
 	suite.Require().True(exists)
 
 	suite.Ctx = suite.Ctx.WithBlockHeight(dummyUpgradeHeight)
diff --git a/app/upgrades/v4/upgrade_test.go b/app/upgrades/v4/upgrade_test.go
index a8ad0fe0c..e35424f68 100644
--- a/app/upgrades/v4/upgrade_test.go
+++ b/app/upgrades/v4/upgrade_test.go
@@ -66,7 +66,7 @@ func (suite *UpgradeTestSuite) TestUpgradePayments() {
 				plan := upgradetypes.Plan{Name: "v4", Height: dummyUpgradeHeight}
 				err := suite.app.UpgradeKeeper.ScheduleUpgrade(suite.ctx, plan)
 				suite.Require().NoError(err)
-				_, exists := suite.app.UpgradeKeeper.GetUpgradePlan(suite.ctx)
+				plan, exists := suite.app.UpgradeKeeper.GetUpgradePlan(suite.ctx)
 				suite.Require().True(exists)
 
 				suite.ctx = suite.ctx.WithBlockHeight(dummyUpgradeHeight)
diff --git a/app/upgrades/v9/upgrade_test.go b/app/upgrades/v9/upgrade_test.go
index badf960b2..667d890b6 100644
--- a/app/upgrades/v9/upgrade_test.go
+++ b/app/upgrades/v9/upgrade_test.go
@@ -30,7 +30,7 @@ func (suite *UpgradeTestSuite) TestUpgradePayments() {
 				plan := upgradetypes.Plan{Name: "v9", Height: dummyUpgradeHeight}
 				err := suite.App.UpgradeKeeper.ScheduleUpgrade(suite.Ctx, plan)
 				suite.Require().NoError(err)
-				_, exists := suite.App.UpgradeKeeper.GetUpgradePlan(suite.Ctx)
+				plan, exists := suite.App.UpgradeKeeper.GetUpgradePlan(suite.Ctx)
 				suite.Require().True(exists)
 
 				suite.Ctx = suite.Ctx.WithBlockHeight(dummyUpgradeHeight)
diff --git a/tests/cl-genesis-positions/convert.go b/tests/cl-genesis-positions/convert.go
index 7708f9d56..bf63e6578 100644
--- a/tests/cl-genesis-positions/convert.go
+++ b/tests/cl-genesis-positions/convert.go
@@ -45,7 +45,9 @@ type OsmosisApp struct {
 	TestAccs    []sdk.AccAddress
 }
 
-var osmosisPrecision = 6
+var (
+	osmosisPrecision = 6
+)
 
 func ReadSubgraphDataFromDisk(subgraphFilePath string) []SubgraphPosition {
 	// read in the data from file
@@ -191,6 +193,7 @@ func ConvertSubgraphToOsmosisGenesis(positionCreatorAddresses []sdk.AccAddress,
 			TokenMinAmount0: sdk.ZeroInt(),
 			TokenMinAmount1: sdk.ZeroInt(),
 		})
+
 		if err != nil {
 			fmt.Printf("\n\n\nWARNING: Failed to create position: %v\n\n\n", err)
 			fmt.Printf("attempted creation between ticks (%s) and (%s), desired amount 0: (%s), desired amount 1 (%s)\n", lowerTickOsmosis, upperTickOsmosis, depositedAmount0, depositedAmount1)
@@ -270,7 +273,7 @@ func writeStateToDisk(state map[string]json.RawMessage) {
 		panic(err)
 	}
 
-	err = os.WriteFile(pathToFilesFromRoot+osmosisGenesisFileName, stateBz, 0o644)
+	err = os.WriteFile(pathToFilesFromRoot+osmosisGenesisFileName, stateBz, 0644)
 	if err != nil {
 		panic(err)
 	}
@@ -284,7 +287,7 @@ func writeBigBangPositionsToState(positions []BigBangPosition) {
 	if err != nil {
 		panic(err)
 	}
-	err = os.WriteFile(pathToFilesFromRoot+bigbangPosiionsFileName, positionsBytes, 0o644)
+	err = os.WriteFile(pathToFilesFromRoot+bigbangPosiionsFileName, positionsBytes, 0644)
 	if err != nil {
 		panic(err)
 	}
diff --git a/tests/cl-genesis-positions/get_data.go b/tests/cl-genesis-positions/get_data.go
index ae3eb157a..ae47d5d83 100644
--- a/tests/cl-genesis-positions/get_data.go
+++ b/tests/cl-genesis-positions/get_data.go
@@ -96,7 +96,7 @@ func GetUniV3SubgraphData(pathToSaveAt string) {
 		return
 	}
 
-	if err := os.WriteFile(pathToSaveAt, jsonData, 0o644); err != nil {
+	if err := os.WriteFile(pathToSaveAt, jsonData, 0644); err != nil {
 		fmt.Println("Error writing JSON file:", err)
 		return
 	}
diff --git a/tests/cl-genesis-positions/local_accounts.go b/tests/cl-genesis-positions/local_accounts.go
index a6d1260ea..b2169a7e7 100644
--- a/tests/cl-genesis-positions/local_accounts.go
+++ b/tests/cl-genesis-positions/local_accounts.go
@@ -1,14 +1,15 @@
 package main
 
 import (
-	"context"
-	"fmt"
-	"log"
 	"os/user"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/ignite/cli/ignite/pkg/cosmosaccount"
 	"github.com/ignite/cli/ignite/pkg/cosmosclient"
+
+	"context"
+	"fmt"
+	"log"
 )
 
 const (
diff --git a/tests/cl-go-client/main.go b/tests/cl-go-client/main.go
index 61633e9ee..0783b9c8a 100644
--- a/tests/cl-go-client/main.go
+++ b/tests/cl-go-client/main.go
@@ -159,6 +159,7 @@ func createPosition(client cosmosclient.Client, poolId uint64, senderKeyringAcco
 		TokenMinAmount1: tokenMinAmount1,
 	}
 	txResp, err := client.BroadcastTx(senderKeyringAccountName, msg)
+
 	if err != nil {
 		log.Fatal(err)
 	}
diff --git a/tests/e2e/configurer/chain/chain.go b/tests/e2e/configurer/chain/chain.go
index 2d7f2319b..ace37b761 100644
--- a/tests/e2e/configurer/chain/chain.go
+++ b/tests/e2e/configurer/chain/chain.go
@@ -59,7 +59,6 @@ const (
 )
 
 func New(t *testing.T, containerManager *containers.Manager, id string, initValidatorConfigs []*initialization.NodeConfig) *Config {
-	t.Helper()
 	numVal := float32(len(initValidatorConfigs))
 	return &Config{
 		ChainMeta: initialization.ChainMeta{
diff --git a/tests/e2e/configurer/chain/node.go b/tests/e2e/configurer/chain/node.go
index d71629ea5..425902ba8 100644
--- a/tests/e2e/configurer/chain/node.go
+++ b/tests/e2e/configurer/chain/node.go
@@ -32,7 +32,6 @@ type NodeConfig struct {
 
 // NewNodeConfig returens new initialized NodeConfig.
 func NewNodeConfig(t *testing.T, initNode *initialization.Node, initConfig *initialization.NodeConfig, chainId string, containerManager *containers.Manager) *NodeConfig {
-	t.Helper()
 	return &NodeConfig{
 		Node:             *initNode,
 		SnapshotInterval: initConfig.SnapshotInterval,
diff --git a/tests/e2e/configurer/chain/queries.go b/tests/e2e/configurer/chain/queries.go
index 1da3ee1f0..ce9c9be99 100644
--- a/tests/e2e/configurer/chain/queries.go
+++ b/tests/e2e/configurer/chain/queries.go
@@ -281,7 +281,6 @@ func (n *NodeConfig) QueryConcentratedPositions(address string) []model.Position
 	require.NoError(n.t, err)
 	return positionsResponse.Positions
 }
-
 func (n *NodeConfig) QueryConcentratedPool(poolId uint64) (cltypes.ConcentratedPoolExtension, error) {
 	path := fmt.Sprintf("/osmosis/poolmanager/v1beta1/pools/%d", poolId)
 	bz, err := n.QueryGRPCGateway(path)
diff --git a/tests/e2e/configurer/current.go b/tests/e2e/configurer/current.go
index d344c8404..31c0bcf1c 100644
--- a/tests/e2e/configurer/current.go
+++ b/tests/e2e/configurer/current.go
@@ -17,7 +17,6 @@ type CurrentBranchConfigurer struct {
 var _ Configurer = (*CurrentBranchConfigurer)(nil)
 
 func NewCurrentBranchConfigurer(t *testing.T, chainConfigs []*chain.Config, setupTests setupFn, containerManager *containers.Manager) Configurer {
-	t.Helper()
 	return &CurrentBranchConfigurer{
 		baseConfigurer: baseConfigurer{
 			chainConfigs:     chainConfigs,
diff --git a/tests/e2e/configurer/factory.go b/tests/e2e/configurer/factory.go
index c745430b8..4e902ef94 100644
--- a/tests/e2e/configurer/factory.go
+++ b/tests/e2e/configurer/factory.go
@@ -106,7 +106,6 @@ var (
 // - If !isIBCEnabled and !isUpgradeEnabled, we only need one chain at the current
 // Git branch version of the Osmosis code.
 func New(t *testing.T, isIBCEnabled, isDebugLogEnabled bool, upgradeSettings UpgradeSettings) (Configurer, error) {
-	t.Helper()
 	containerManager, err := containers.NewManager(upgradeSettings.IsEnabled, upgradeSettings.ForkHeight > 0, isDebugLogEnabled)
 	if err != nil {
 		return nil, err
diff --git a/tests/e2e/configurer/upgrade.go b/tests/e2e/configurer/upgrade.go
index c137bcc6c..db913239d 100644
--- a/tests/e2e/configurer/upgrade.go
+++ b/tests/e2e/configurer/upgrade.go
@@ -31,7 +31,6 @@ type UpgradeConfigurer struct {
 var _ Configurer = (*UpgradeConfigurer)(nil)
 
 func NewUpgradeConfigurer(t *testing.T, chainConfigs []*chain.Config, setupTests setupFn, containerManager *containers.Manager, upgradeVersion string, forkHeight int64) Configurer {
-	t.Helper()
 	return &UpgradeConfigurer{
 		baseConfigurer: baseConfigurer{
 			chainConfigs:     chainConfigs,
diff --git a/tests/e2e/containers/containers.go b/tests/e2e/containers/containers.go
index ac5611384..1a8a63cf3 100644
--- a/tests/e2e/containers/containers.go
+++ b/tests/e2e/containers/containers.go
@@ -72,7 +72,6 @@ func NewManager(isUpgrade bool, isFork bool, isDebugLogEnabled bool) (docker *Ma
 
 // ExecTxCmd Runs ExecTxCmdWithSuccessString searching for `code: 0`
 func (m *Manager) ExecTxCmd(t *testing.T, chainId string, containerName string, command []string) (bytes.Buffer, bytes.Buffer, error) {
-	t.Helper()
 	return m.ExecTxCmdWithSuccessString(t, chainId, containerName, command, "code: 0")
 }
 
@@ -80,7 +79,6 @@ func (m *Manager) ExecTxCmd(t *testing.T, chainId string, containerName string,
 // namely adding flags `--chain-id={chain-id} -b=block --yes --keyring-backend=test "--log_format=json" --gas=400000`,
 // and searching for `successStr`
 func (m *Manager) ExecTxCmdWithSuccessString(t *testing.T, chainId string, containerName string, command []string, successStr string) (bytes.Buffer, bytes.Buffer, error) {
-	t.Helper()
 	allTxArgs := []string{fmt.Sprintf("--chain-id=%s", chainId)}
 	allTxArgs = append(allTxArgs, txArgs...)
 	// parse to see if command has gas flags. If not, add default gas flags.
@@ -99,7 +97,6 @@ func (m *Manager) ExecTxCmdWithSuccessString(t *testing.T, chainId string, conta
 
 // ExecHermesCmd executes command on the hermes relaer container.
 func (m *Manager) ExecHermesCmd(t *testing.T, command []string, success string) (bytes.Buffer, bytes.Buffer, error) {
-	t.Helper()
 	return m.ExecCmd(t, hermesContainerName, command, success)
 }
 
@@ -109,7 +106,6 @@ func (m *Manager) ExecHermesCmd(t *testing.T, command []string, success string)
 // returns container std out, container std err, and error if any.
 // An error is returned if the command fails to execute or if the success string is not found in the output.
 func (m *Manager) ExecCmd(t *testing.T, containerName string, command []string, success string) (bytes.Buffer, bytes.Buffer, error) {
-	t.Helper()
 	if _, ok := m.resources[containerName]; !ok {
 		return bytes.Buffer{}, bytes.Buffer{}, fmt.Errorf("no resource %s found", containerName)
 	}
diff --git a/tests/e2e/e2e_setup_test.go b/tests/e2e/e2e_setup_test.go
index 7c4432aa7..016a0b8bd 100644
--- a/tests/e2e/e2e_setup_test.go
+++ b/tests/e2e/e2e_setup_test.go
@@ -35,6 +35,7 @@ type IntegrationTestSuite struct {
 	skipUpgrade   bool
 	skipIBC       bool
 	skipStateSync bool
+	forkHeight    int
 }
 
 func TestIntegrationTestSuite(t *testing.T) {
diff --git a/tests/e2e/e2e_test.go b/tests/e2e/e2e_test.go
index 133c2088e..d746e39d6 100644
--- a/tests/e2e/e2e_test.go
+++ b/tests/e2e/e2e_test.go
@@ -74,7 +74,7 @@ func (s *IntegrationTestSuite) TestProtoRev() {
 	s.Require().Len(hotRoutes, 0)
 
 	// The module should have no trades by default.
-	_, err = chainANode.QueryProtoRevNumberOfTrades()
+	numTrades, err := chainANode.QueryProtoRevNumberOfTrades()
 	s.T().Logf("checking that the protorev module has no trades on init: %s", err)
 	s.Require().Error(err)
 
@@ -140,7 +140,7 @@ func (s *IntegrationTestSuite) TestProtoRev() {
 	s.Require().Equal(supplyBefore, supplyAfter)
 
 	// Check that the number of trades executed by the protorev module is 1.
-	numTrades, err := chainANode.QueryProtoRevNumberOfTrades()
+	numTrades, err = chainANode.QueryProtoRevNumberOfTrades()
 	s.T().Logf("checking that the protorev module has executed 1 trade")
 	s.Require().NoError(err)
 	s.Require().NotNil(numTrades)
@@ -660,8 +660,10 @@ func (s *IntegrationTestSuite) TestConcentratedLiquidity() {
 
 	// Withdraw Position
 
-	// Withdraw Position parameters
-	var defaultLiquidityRemoval string = "1000"
+	var (
+		// Withdraw Position parameters
+		defaultLiquidityRemoval string = "1000"
+	)
 
 	chainA.WaitForNumHeights(2)
 
@@ -728,7 +730,7 @@ func (s *IntegrationTestSuite) TestConcentratedLiquidity() {
 	}
 
 	// if querying proposal takes longer than timeoutPeriod, stop the goroutine and error
-	timeoutPeriod := 2 * time.Minute
+	timeoutPeriod := time.Duration(2 * time.Minute)
 	select {
 	case <-time.After(timeoutPeriod):
 		err := fmt.Errorf("go routine took longer than %s", timeoutPeriod)
@@ -975,7 +977,7 @@ func (s *IntegrationTestSuite) TestIBCTokenTransferRateLimiting() {
 
 	// Removing the rate limit so it doesn't affect other tests
 	node.WasmExecute(contract, `{"remove_path": {"channel_id": "channel-0", "denom": "uosmo"}}`, initialization.ValidatorWalletName)
-	// reset the param to the original contract if it existed
+	//reset the param to the original contract if it existed
 	if param != "" {
 		err = chainA.SubmitParamChangeProposal(
 			ibcratelimittypes.ModuleName,
@@ -989,6 +991,7 @@ func (s *IntegrationTestSuite) TestIBCTokenTransferRateLimiting() {
 		}, time.Second*30, time.Millisecond*500)
 
 	}
+
 }
 
 func (s *IntegrationTestSuite) TestLargeWasmUpload() {
@@ -1158,6 +1161,7 @@ func (s *IntegrationTestSuite) TestAddToExistingLock() {
 // because twap keep time = epoch time / 4 and we use a timer
 // to wait for at least the twap keep time.
 func (s *IntegrationTestSuite) TestArithmeticTWAP() {
+
 	s.T().Skip("TODO: investigate further: https://github.com/osmosis-labs/osmosis/issues/4342")
 
 	const (
@@ -1434,7 +1438,7 @@ func (s *IntegrationTestSuite) TestExpeditedProposals() {
 	}
 	// if querying proposal takes longer than timeoutPeriod, stop the goroutine and error
 	var elapsed time.Duration
-	timeoutPeriod := 2 * time.Minute
+	timeoutPeriod := time.Duration(2 * time.Minute)
 	select {
 	case elapsed = <-totalTimeChan:
 	case <-time.After(timeoutPeriod):
@@ -1469,6 +1473,8 @@ func (s *IntegrationTestSuite) TestGeometricTWAP() {
 		denomB = "stake" // 2_000_000 stake
 
 		minAmountOut = "1"
+
+		epochIdentifier = "day"
 	)
 
 	chainA := s.configurer.GetChainConfig(0)
@@ -1553,8 +1559,10 @@ func (s *IntegrationTestSuite) TestAConcentratedLiquidity_CanonicalPool_And_Para
 		s.T().Skip("Skipping v16 canonical pool creation test because upgrade is not enabled")
 	}
 
-	// Taken from: https://app.osmosis.zone/pool/674
-	expectedFee := sdk.MustNewDecFromStr("0.002")
+	var (
+		// Taken from: https://app.osmosis.zone/pool/674
+		expectedFee = sdk.MustNewDecFromStr("0.002")
+	)
 
 	chainA := s.configurer.GetChainConfig(0)
 	chainANode, err := chainA.GetDefaultNode()
diff --git a/tests/e2e/helpers_e2e_test.go b/tests/e2e/helpers_e2e_test.go
index 78b37131c..2ab08c8b1 100644
--- a/tests/e2e/helpers_e2e_test.go
+++ b/tests/e2e/helpers_e2e_test.go
@@ -8,7 +8,9 @@ import (
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
 )
 
-var defaultFeePerTx = sdk.NewInt(1000)
+var (
+	defaultFeePerTx = sdk.NewInt(1000)
+)
 
 // calculateFeeGrowthGlobal calculates fee growth global per unit of virtual liquidity based on swap parameters:
 // amountIn - amount being swapped
@@ -82,6 +84,6 @@ func (s *IntegrationTestSuite) updatedPool(node *chain.NodeConfig, poolId uint64
 // Assert returned positions:
 func (s *IntegrationTestSuite) validateCLPosition(position model.Position, poolId uint64, lowerTick, upperTick int64) {
 	s.Require().Equal(position.PoolId, poolId)
-	s.Require().Equal(position.LowerTick, lowerTick)
-	s.Require().Equal(position.UpperTick, upperTick)
+	s.Require().Equal(position.LowerTick, int64(lowerTick))
+	s.Require().Equal(position.UpperTick, int64(upperTick))
 }
diff --git a/tests/e2e/initialization/config.go b/tests/e2e/initialization/config.go
index 522c936b4..34ccadc42 100644
--- a/tests/e2e/initialization/config.go
+++ b/tests/e2e/initialization/config.go
@@ -477,7 +477,7 @@ func updateTWAPGenesis(appGenState map[string]json.RawMessage) func(twapGenState
 					Asset0Denom:                 denomPair.Denom0,
 					Asset1Denom:                 denomPair.Denom0,
 					Height:                      1,
-					Time:                        time.Date(2023, 0o2, 1, 0, 0, 0, 0, time.UTC), // some time in the past.
+					Time:                        time.Date(2023, 02, 1, 0, 0, 0, 0, time.UTC), // some time in the past.
 					P0LastSpotPrice:             sp0,
 					P1LastSpotPrice:             sp1,
 					P0ArithmeticTwapAccumulator: sdk.ZeroDec(),
diff --git a/tests/ibc-hooks/ibc_middleware_test.go b/tests/ibc-hooks/ibc_middleware_test.go
index c40c24d63..69affe29b 100644
--- a/tests/ibc-hooks/ibc_middleware_test.go
+++ b/tests/ibc-hooks/ibc_middleware_test.go
@@ -3,12 +3,11 @@ package ibc_hooks_test
 import (
 	"encoding/json"
 	"fmt"
+	"github.com/tidwall/gjson"
 	"strings"
 	"testing"
 	"time"
 
-	"github.com/tidwall/gjson"
-
 	"github.com/CosmWasm/wasmd/x/wasm/types"
 
 	ibchookskeeper "github.com/osmosis-labs/osmosis/x/ibc-hooks/keeper"
@@ -49,6 +48,9 @@ type HooksTestSuite struct {
 	pathAB *ibctesting.Path
 	pathAC *ibctesting.Path
 	pathBC *ibctesting.Path
+	pathBA *ibctesting.Path
+	pathCA *ibctesting.Path
+	pathCB *ibctesting.Path
 	// This is used to test cw20s. It will only get assigned in the cw20 test
 	pathCW20 *ibctesting.Path
 }
@@ -606,6 +608,7 @@ func (suite *HooksTestSuite) TestAcks() {
 		&suite.Suite, addr,
 		[]byte(fmt.Sprintf(`{"get_count": {"addr": "%s"}}`, addr)))
 	suite.Require().Equal(`{"count":2}`, state)
+
 }
 
 func (suite *HooksTestSuite) TestTimeouts() {
@@ -638,6 +641,7 @@ func (suite *HooksTestSuite) TestTimeouts() {
 		&suite.Suite, addr,
 		[]byte(fmt.Sprintf(`{"get_count": {"addr": "%s"}}`, addr)))
 	suite.Require().Equal(`{"count":10}`, state)
+
 }
 
 func (suite *HooksTestSuite) TestSendWithoutMemo() {
@@ -1196,6 +1200,7 @@ func (suite *HooksTestSuite) TestCrosschainSwapsViaIBCBadAck() {
 	// Calling recovery again should fail
 	_, err = contractKeeper.Execute(suite.chainA.GetContext(), crosschainAddr, recoverAddr2, []byte(recoverMsg), sdk.NewCoins())
 	suite.Require().Error(err)
+
 }
 
 // CrosschainSwapsViaIBCBadSwap tests that if the crosschain-swap fails, the tokens are returned to the sender
@@ -1358,6 +1363,7 @@ func (suite *HooksTestSuite) SetupIBCRouteOnChain(swaprouterAddr, owner sdk.AccA
 	suite.Require().NoError(err)
 	err = suite.pathAB.EndpointB.UpdateClient()
 	suite.Require().NoError(err)
+
 }
 
 func (suite *HooksTestSuite) SetupIBCSimpleRouteOnChain(swaprouterAddr, owner sdk.AccAddress, poolId uint64, chainName Chain, denom1, denom2 string) {
@@ -1384,6 +1390,7 @@ func (suite *HooksTestSuite) SetupIBCSimpleRouteOnChain(swaprouterAddr, owner sd
 	suite.Require().NoError(err)
 	err = suite.pathAB.EndpointB.UpdateClient()
 	suite.Require().NoError(err)
+
 }
 
 // TestCrosschainForwardWithMemo tests the that the next_memo field is correctly forwarded to the other chain on the IBC transfer.
@@ -1411,7 +1418,7 @@ func (suite *HooksTestSuite) TestCrosschainForwardWithMemo() {
 	fmt.Println("receiver now has: ", balanceToken0IBCBefore)
 	suite.Require().Equal(int64(0), balanceToken0IBCBefore.Amount.Int64())
 
-	// suite.Require().Equal(int64(0), balanceToken1.Amount.Int64())
+	//suite.Require().Equal(int64(0), balanceToken1.Amount.Int64())
 
 	// Generate swap instructions for the contract
 	//
@@ -1781,7 +1788,9 @@ func (suite *HooksTestSuite) TestMultiHopXCS() {
 
 			receivedTokenAfter := receiverChain.GetOsmosisApp().BankKeeper.GetBalance(receiverChain.GetContext(), tc.receiver.address, tc.receivedToken)
 			suite.Require().True(receivedTokenAfter.Amount.GT(receivedTokenBalance.Amount))
+
 		})
+
 	}
 }
 
@@ -1844,7 +1853,7 @@ func (suite *HooksTestSuite) ExecuteOutpostSwap(initializer, receiverAddr sdk.Ac
 
 	// But the receiver now has some token1IBC
 	balanceToken1After := osmosisAppB.BankKeeper.GetBalance(suite.chainB.GetContext(), receiverAddr, token1IBC)
-	// fmt.Println("receiver now has: ", balanceToken1After)
+	//fmt.Println("receiver now has: ", balanceToken1After)
 	suite.Require().Greater(balanceToken1After.Amount.Int64(), int64(0))
 }
 
diff --git a/tests/ibc-hooks/xcs_cw20_test.go b/tests/ibc-hooks/xcs_cw20_test.go
index 0627ea6c7..fb441c845 100644
--- a/tests/ibc-hooks/xcs_cw20_test.go
+++ b/tests/ibc-hooks/xcs_cw20_test.go
@@ -4,7 +4,6 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-
 	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	transfertypes "github.com/cosmos/ibc-go/v4/modules/apps/transfer/types"
@@ -176,4 +175,5 @@ func (suite *HooksTestSuite) TestCW20ICS20() {
 	// Check that the receiver has more cw20 tokens than before
 	newCw20Balance := suite.getCW20Balance(chainB, cw20Addr, receiver2)
 	suite.Require().Greater(newCw20Balance.Int64(), cw20Balance.Int64())
+
 }
diff --git a/wasmbinding/test/custom_query_test.go b/wasmbinding/test/custom_query_test.go
index 16e0f6a39..0d01ddbc8 100644
--- a/wasmbinding/test/custom_query_test.go
+++ b/wasmbinding/test/custom_query_test.go
@@ -17,6 +17,16 @@ import (
 
 	"github.com/osmosis-labs/osmosis/v15/app"
 	"github.com/osmosis-labs/osmosis/v15/wasmbinding/bindings"
+	"github.com/osmosis-labs/osmosis/v15/x/gamm/pool-models/balancer"
+)
+
+// we must pay this many uosmo for every pool we create
+var poolFee int64 = 1000000000
+
+var defaultFunds = sdk.NewCoins(
+	sdk.NewInt64Coin("uatom", 333000000),
+	sdk.NewInt64Coin("uosmo", 555000000+2*poolFee),
+	sdk.NewInt64Coin("ustar", 999000000),
 )
 
 func SetupCustomApp(t *testing.T, addr sdk.AccAddress) (*app.OsmosisApp, sdk.Context) {
@@ -85,6 +95,13 @@ func queryCustom(t *testing.T, ctx sdk.Context, osmosis *app.OsmosisApp, contrac
 	require.NoError(t, err)
 }
 
+func assertValidShares(t *testing.T, shares wasmvmtypes.Coin, poolID uint64) {
+	// sanity check: check the denom and ensure at least 18 decimal places
+	denom := fmt.Sprintf("gamm/pool/%d", poolID)
+	require.Equal(t, denom, shares.Denom)
+	require.Greater(t, len(shares.Amount), 18)
+}
+
 func storeReflectCode(t *testing.T, ctx sdk.Context, osmosis *app.OsmosisApp, addr sdk.AccAddress) {
 	govKeeper := osmosis.GovKeeper
 	wasmCode, err := os.ReadFile("../testdata/osmo_reflect.wasm")
@@ -126,3 +143,23 @@ func fundAccount(t *testing.T, ctx sdk.Context, osmosis *app.OsmosisApp, addr sd
 	)
 	require.NoError(t, err)
 }
+
+func preparePool(t *testing.T, ctx sdk.Context, osmosis *app.OsmosisApp, addr sdk.AccAddress, funds []sdk.Coin) uint64 {
+	var assets []balancer.PoolAsset
+	for _, coin := range funds {
+		assets = append(assets, balancer.PoolAsset{
+			Weight: sdk.NewInt(100),
+			Token:  coin,
+		})
+	}
+
+	poolParams := balancer.PoolParams{
+		SwapFee: sdk.NewDec(0),
+		ExitFee: sdk.NewDec(0),
+	}
+
+	msg := balancer.NewMsgCreateBalancerPool(addr, poolParams, assets, "")
+	poolId, err := osmosis.PoolManagerKeeper.CreatePool(ctx, &msg)
+	require.NoError(t, err)
+	return poolId
+}
diff --git a/x/concentrated-liquidity/fees_test.go b/x/concentrated-liquidity/fees_test.go
index af930889d..a231238c3 100644
--- a/x/concentrated-liquidity/fees_test.go
+++ b/x/concentrated-liquidity/fees_test.go
@@ -210,6 +210,7 @@ func (s *KeeperTestSuite) TestInitOrUpdateFeeAccumulatorPosition() {
 	for _, tc := range tests {
 		tc := tc
 		s.Run(tc.name, func() {
+
 			// System under test
 			err := clKeeper.InitOrUpdateFeeAccumulatorPosition(s.Ctx, tc.positionFields.poolId, tc.positionFields.lowerTick, tc.positionFields.upperTick, tc.positionFields.positionId, tc.positionFields.liquidity)
 			if tc.expectedPass {
@@ -260,6 +261,7 @@ func (s *KeeperTestSuite) TestGetFeeGrowthOutside() {
 		globalFeeGrowth           sdk.DecCoin
 
 		expectedFeeGrowthOutside sdk.DecCoins
+		invalidTick              bool
 		expectedError            bool
 	}
 
@@ -1186,7 +1188,7 @@ func (s *KeeperTestSuite) TestPrepareClaimableFees() {
 			s.initializeTick(ctx, tc.currentTick, tc.lowerTick, tc.initialLiquidity, tc.lowerTickFeeGrowthOutside, emptyUptimeTrackers, false)
 			s.initializeTick(ctx, tc.currentTick, tc.upperTick, tc.initialLiquidity, tc.upperTickFeeGrowthOutside, emptyUptimeTrackers, true)
 			validPool.SetCurrentTick(sdk.NewInt(tc.currentTick))
-			_ = clKeeper.SetPool(ctx, validPool)
+			clKeeper.SetPool(ctx, validPool)
 
 			err = clKeeper.ChargeFee(ctx, validPoolId, tc.globalFeeGrowth[0])
 			s.Require().NoError(err)
diff --git a/x/concentrated-liquidity/incentives_test.go b/x/concentrated-liquidity/incentives_test.go
index 58a03ba8f..9c97b99c1 100644
--- a/x/concentrated-liquidity/incentives_test.go
+++ b/x/concentrated-liquidity/incentives_test.go
@@ -28,6 +28,8 @@ var (
 	testAddressThree = sdk.MustAccAddressFromBech32("osmo1qwexv7c6sm95lwhzn9027vyu2ccneaqad4w8ka")
 	testAddressFour  = sdk.MustAccAddressFromBech32("osmo14hcxlnwlqtq75ttaxf674vk6mafspg8xwgnn53")
 
+	testAccumOne = "testAccumOne"
+
 	// Note: lexicographic order is denomFour, denomOne, denomThree, denomTwo
 	testDenomOne   = "denomOne"
 	testDenomTwo   = "denomTwo"
@@ -110,7 +112,9 @@ var (
 		MinUptime: testUptimeFour,
 	}
 
-	testQualifyingDepositsOne = sdk.NewInt(50)
+	testQualifyingDepositsOne   = sdk.NewInt(50)
+	testQualifyingDepositsTwo   = sdk.NewInt(100)
+	testQualifyingDepositsThree = sdk.NewInt(399)
 
 	defaultBalancerAssets = []balancer.PoolAsset{
 		{Weight: sdk.NewInt(1), Token: sdk.NewCoin("foo", sdk.NewInt(100))},
@@ -119,6 +123,8 @@ var (
 	defaultConcentratedAssets = sdk.NewCoins(sdk.NewCoin("foo", sdk.NewInt(100)), sdk.NewCoin("bar", sdk.NewInt(100)))
 	defaultBalancerPoolParams = balancer.PoolParams{SwapFee: sdk.NewDec(0), ExitFee: sdk.NewDec(0)}
 	invalidPoolId             = uint64(10)
+
+	defaultAuthorizedUptimes = []time.Duration{time.Nanosecond}
 )
 
 type ExpectedUptimes struct {
@@ -208,6 +214,14 @@ func chargeIncentive(incentiveRecord types.IncentiveRecord, timeElapsed time.Dur
 	return incentiveRecord
 }
 
+// emittedIncentives returns the amount of incentives emitted by incentiveRecord over timeElapsed.
+// It uses the same logic as chargeIncentive for calculating this amount.
+func emittedIncentives(incentiveRecord types.IncentiveRecord, timeElapsed time.Duration) sdk.Dec {
+	secToNanoSec := int64(1000000000)
+	incentivesEmitted := incentiveRecord.IncentiveRecordBody.EmissionRate.Mul(sdk.NewDec(int64(timeElapsed)).Quo(sdk.NewDec(secToNanoSec)))
+	return incentivesEmitted
+}
+
 // Helper for adding a predetermined amount to each global uptime accum in clPool
 func addToUptimeAccums(ctx sdk.Context, poolId uint64, clKeeper *cl.Keeper, addValues []sdk.DecCoins) error {
 	poolUptimeAccumulators, err := clKeeper.GetUptimeAccumulators(ctx, poolId)
@@ -237,6 +251,18 @@ func addDecCoinsArray(decCoinsArrayA []sdk.DecCoins, decCoinsArrayB []sdk.DecCoi
 	return finalDecCoinArray, nil
 }
 
+func createIncentiveRecord(incentiveDenom string, remainingAmt, emissionRate sdk.Dec, startTime time.Time, minUpTime time.Duration) types.IncentiveRecord {
+	return types.IncentiveRecord{
+		IncentiveDenom: incentiveDenom,
+		IncentiveRecordBody: types.IncentiveRecordBody{
+			RemainingAmount: remainingAmt,
+			EmissionRate:    emissionRate,
+			StartTime:       startTime,
+		},
+		MinUptime: minUpTime,
+	}
+}
+
 func withDenom(record types.IncentiveRecord, denom string) types.IncentiveRecord {
 	record.IncentiveDenom = denom
 
@@ -346,17 +372,17 @@ func (s *KeeperTestSuite) TestGetUptimeAccumulatorName() {
 		"pool id 1, uptime id 0": {
 			poolId:            defaultPoolId,
 			uptimeIndex:       uint64(0),
-			expectedAccumName: types.KeyUptimeAccumulator(1, 0),
+			expectedAccumName: string(types.KeyUptimeAccumulator(1, 0)),
 		},
 		"pool id 1, uptime id 999": {
 			poolId:            defaultPoolId,
 			uptimeIndex:       uint64(999),
-			expectedAccumName: types.KeyUptimeAccumulator(1, 999),
+			expectedAccumName: string(types.KeyUptimeAccumulator(1, 999)),
 		},
 		"pool id 999, uptime id 1": {
 			poolId:            uint64(999),
 			uptimeIndex:       uint64(1),
-			expectedAccumName: types.KeyUptimeAccumulator(999, 1),
+			expectedAccumName: string(types.KeyUptimeAccumulator(999, 1)),
 		},
 	}
 
@@ -732,11 +758,16 @@ func (s *KeeperTestSuite) TestUpdateUptimeAccumulatorsToNow() {
 	longestLockableDuration := lockableDurations[len(lockableDurations)-1]
 	type updateAccumToNow struct {
 		poolId                      uint64
+		accumUptime                 time.Duration
+		qualifyingLiquidity         sdk.Dec
 		timeElapsed                 time.Duration
 		poolIncentiveRecords        []types.IncentiveRecord
 		canonicalBalancerPoolAssets []balancer.PoolAsset
 
+		isInvalidPoolId          bool
 		isInvalidBalancerPool    bool
+		expectedResult           sdk.DecCoins
+		expectedUptimeDeltas     []sdk.DecCoins
 		expectedIncentiveRecords []types.IncentiveRecord
 		expectedError            error
 	}
@@ -1148,7 +1179,7 @@ func (s *KeeperTestSuite) TestGetInitialUptimeGrowthOutsidesForTick() {
 				uptimeAccum.AddToAccumulator(expectedUptimes.hundredTokensMultiDenom[uptimeId])
 			}
 
-			_, err = clKeeper.GetUptimeAccumulators(s.Ctx, tc.poolId)
+			poolUptimeAccumulators, err = clKeeper.GetUptimeAccumulators(s.Ctx, tc.poolId)
 			s.Require().NoError(err)
 
 			val, err := clKeeper.GetInitialUptimeGrowthOutsidesForTick(s.Ctx, tc.poolId, tc.tick)
@@ -1174,6 +1205,7 @@ func (s *KeeperTestSuite) TestGetUptimeGrowthInsideRange() {
 		globalUptimeGrowth           []sdk.DecCoins
 
 		expectedUptimeGrowthInside []sdk.DecCoins
+		invalidTick                bool
 		expectedError              bool
 	}
 
@@ -1501,6 +1533,7 @@ func (s *KeeperTestSuite) TestGetUptimeGrowthOutsideRange() {
 		globalUptimeGrowth           []sdk.DecCoins
 
 		expectedUptimeGrowthOutside []sdk.DecCoins
+		invalidTick                 bool
 		expectedError               bool
 	}
 
@@ -2873,13 +2906,13 @@ func (s *KeeperTestSuite) TestQueryAndCollectIncentives() {
 			// Set up invalid pool ID for error-catching case(s)
 			sutPoolId := validPoolId
 			if tc.isInvalidPoolIdGiven {
-				sutPoolId = sutPoolId + 1 //nolint:staticcheck,ineffassign
+				sutPoolId = sutPoolId + 1
 			}
 
 			// System under test
 			incentivesClaimedQuery, incentivesForfeitedQuery, err := clKeeper.GetClaimableIncentives(ctx, DefaultPositionId)
 
-			_ = s.App.BankKeeper.GetAllBalances(ctx, validPool.GetAddress())
+			poolBalanceAfterCollect := s.App.BankKeeper.GetAllBalances(ctx, validPool.GetAddress())
 			incentivesBalanceAfterCollect := s.App.BankKeeper.GetAllBalances(ctx, validPool.GetIncentivesAddress())
 			ownerBalancerAfterCollect := s.App.BankKeeper.GetAllBalances(ctx, ownerWithValidPosition)
 
@@ -2900,7 +2933,7 @@ func (s *KeeperTestSuite) TestQueryAndCollectIncentives() {
 			s.Require().Equal(incentivesClaimedQuery, actualIncentivesClaimed)
 			s.Require().Equal(incentivesForfeitedQuery, actualIncetivesForfeited)
 
-			poolBalanceAfterCollect := s.App.BankKeeper.GetAllBalances(ctx, validPool.GetAddress())
+			poolBalanceAfterCollect = s.App.BankKeeper.GetAllBalances(ctx, validPool.GetAddress())
 			incentivesBalanceAfterCollect = s.App.BankKeeper.GetAllBalances(ctx, validPool.GetIncentivesAddress())
 			ownerBalancerAfterCollect = s.App.BankKeeper.GetAllBalances(ctx, ownerWithValidPosition)
 
@@ -3065,7 +3098,7 @@ func (s *KeeperTestSuite) TestCreateIncentive() {
 
 			expectedError: types.PoolNotFoundError{PoolId: 2},
 		},
-		"zero incentive amount": {
+		"invalid incentive coin": {
 			poolId: defaultPoolId,
 			sender: sdk.MustAccAddressFromBech32(incentiveRecordOne.IncentiveCreatorAddr),
 			senderBalance: sdk.NewCoins(
@@ -3077,21 +3110,7 @@ func (s *KeeperTestSuite) TestCreateIncentive() {
 			recordToSet:       withAmount(incentiveRecordOne, sdk.ZeroDec()),
 			authorizedUptimes: types.SupportedUptimes,
 
-			expectedError: types.NonPositiveIncentiveAmountError{PoolId: 1, IncentiveAmount: sdk.ZeroDec()},
-		},
-		"negative incentive amount": {
-			poolId: defaultPoolId,
-			sender: sdk.MustAccAddressFromBech32(incentiveRecordOne.IncentiveCreatorAddr),
-			senderBalance: sdk.NewCoins(
-				sdk.NewCoin(
-					incentiveRecordOne.IncentiveDenom,
-					sdk.ZeroInt(),
-				),
-			),
-			recordToSet:       withAmount(incentiveRecordOne, sdk.NewDec(-1)),
-			authorizedUptimes: types.SupportedUptimes,
-
-			expectedError: types.NonPositiveIncentiveAmountError{PoolId: 1, IncentiveAmount: sdk.NewDec(-1)},
+			expectedError: types.InvalidIncentiveCoinError{PoolId: 1, IncentiveCoin: sdk.NewCoin(incentiveRecordOne.IncentiveDenom, sdk.ZeroInt())},
 		},
 		"start time too early": {
 			poolId: defaultPoolId,
@@ -3205,8 +3224,10 @@ func (s *KeeperTestSuite) TestCreateIncentive() {
 
 			existingGasConsumed := s.Ctx.GasMeter().GasConsumed()
 
+			incentiveCoin := sdk.NewCoin(tc.recordToSet.IncentiveDenom, tc.recordToSet.IncentiveRecordBody.RemainingAmount.Ceil().RoundInt())
+
 			// system under test
-			incentiveRecord, err := clKeeper.CreateIncentive(s.Ctx, tc.poolId, tc.sender, tc.recordToSet.IncentiveDenom, tc.recordToSet.IncentiveRecordBody.RemainingAmount.Ceil().RoundInt(), tc.recordToSet.IncentiveRecordBody.EmissionRate, tc.recordToSet.IncentiveRecordBody.StartTime, tc.recordToSet.MinUptime)
+			incentiveRecord, err := clKeeper.CreateIncentive(s.Ctx, tc.poolId, tc.sender, incentiveCoin, tc.recordToSet.IncentiveRecordBody.EmissionRate, tc.recordToSet.IncentiveRecordBody.StartTime, tc.recordToSet.MinUptime)
 
 			// Assertions
 			if tc.expectedError != nil {
diff --git a/x/concentrated-liquidity/keeper_test.go b/x/concentrated-liquidity/keeper_test.go
index a3eeba36a..ae9749bb1 100644
--- a/x/concentrated-liquidity/keeper_test.go
+++ b/x/concentrated-liquidity/keeper_test.go
@@ -291,8 +291,7 @@ func (s *KeeperTestSuite) validateListenerCallCount(
 	expectedPoolCreatedListenerCallCount,
 	expectedInitialPositionCreationListenerCallCount,
 	expectedLastPositionWithdrawalListenerCallCount,
-	expectedSwapListenerCallCount int,
-) {
+	expectedSwapListenerCallCount int) {
 	// Validate that listeners were called the desired number of times
 	listeners := s.App.ConcentratedLiquidityKeeper.GetListenersUnsafe()
 	s.Require().Len(listeners, 1)
diff --git a/x/concentrated-liquidity/lp_test.go b/x/concentrated-liquidity/lp_test.go
index f963a8d27..442e06dae 100644
--- a/x/concentrated-liquidity/lp_test.go
+++ b/x/concentrated-liquidity/lp_test.go
@@ -16,6 +16,7 @@ import (
 
 type lpTest struct {
 	poolId                            uint64
+	owner                             sdk.AccAddress
 	currentTick                       sdk.Int
 	lowerTick                         int64
 	upperTick                         int64
@@ -538,7 +539,7 @@ func (s *KeeperTestSuite) TestWithdrawPosition() {
 
 			expectedPoolBalanceDelta := expectedFeesClaimed.Add(sdk.NewCoin(ETH, config.amount0Expected.Abs())).Add(sdk.NewCoin(USDC, config.amount1Expected.Abs()))
 
-			var withdrawAccount sdk.AccAddress
+			withdrawAccount := sdk.AccAddress{}
 			if tc.withdrawWithNonOwner {
 				withdrawAccount = nonOwner
 			} else {
@@ -1370,11 +1371,13 @@ func (s *KeeperTestSuite) TestUpdatePosition() {
 }
 
 func (s *KeeperTestSuite) TestInitializeInitialPositionForPool() {
-	sqrt := func(x int64) sdk.Dec {
-		sqrt, err := sdk.NewDec(x).ApproxSqrt()
-		s.Require().NoError(err)
-		return sqrt
-	}
+	var (
+		sqrt = func(x int64) sdk.Dec {
+			sqrt, err := sdk.NewDec(x).ApproxSqrt()
+			s.Require().NoError(err)
+			return sqrt
+		}
+	)
 
 	type sendTest struct {
 		amount0Desired        sdk.Int
@@ -1461,6 +1464,7 @@ func (s *KeeperTestSuite) TestInitializeInitialPositionForPool() {
 }
 
 func (s *KeeperTestSuite) TestInverseRelation_CreatePosition_WithdrawPosition() {
+
 	tests := map[string]lpTest{}
 
 	// add test cases for different positions
diff --git a/x/concentrated-liquidity/math/math_test.go b/x/concentrated-liquidity/math/math_test.go
index 6b21d9f82..1713b69f6 100644
--- a/x/concentrated-liquidity/math/math_test.go
+++ b/x/concentrated-liquidity/math/math_test.go
@@ -431,6 +431,7 @@ func (suite *ConcentratedMathTestSuite) TestGetNextSqrtPriceFromAmount0InRoundin
 	for name, tc := range tests {
 		tc := tc
 		suite.Run(name, func() {
+
 			sqrtPriceNext := math.GetNextSqrtPriceFromAmount0InRoundingUp(tc.sqrtPriceCurrent, tc.liquidity, tc.amountZeroRemaininIn)
 
 			suite.Require().Equal(tc.expectedSqrtPriceNext.String(), sqrtPriceNext.String())
@@ -467,6 +468,7 @@ func (suite *ConcentratedMathTestSuite) TestGetNextSqrtPriceFromAmount0OutRoundi
 	for name, tc := range tests {
 		tc := tc
 		suite.Run(name, func() {
+
 			sqrtPriceNext := math.GetNextSqrtPriceFromAmount0OutRoundingUp(tc.sqrtPriceCurrent, tc.liquidity, tc.amountZeroRemainingOut)
 
 			suite.Require().Equal(tc.expectedSqrtPriceNext.String(), sqrtPriceNext.String())
@@ -503,6 +505,7 @@ func (suite *ConcentratedMathTestSuite) TestGetNextSqrtPriceFromAmount1InRoundin
 	for name, tc := range tests {
 		tc := tc
 		suite.Run(name, func() {
+
 			sqrtPriceNext := math.GetNextSqrtPriceFromAmount1InRoundingDown(tc.sqrtPriceCurrent, tc.liquidity, tc.amountOneRemainingIn)
 
 			suite.Require().Equal(tc.expectedSqrtPriceNext.String(), sqrtPriceNext.String())
@@ -539,6 +542,7 @@ func (suite *ConcentratedMathTestSuite) TestGetNextSqrtPriceFromAmount1OutRoundi
 	for name, tc := range tests {
 		tc := tc
 		suite.Run(name, func() {
+
 			sqrtPriceNext := math.GetNextSqrtPriceFromAmount1OutRoundingDown(tc.sqrtPriceCurrent, tc.liquidity, tc.amountOneRemainingOut)
 
 			suite.Require().Equal(tc.expectedSqrtPriceNext.String(), sqrtPriceNext.String())
diff --git a/x/concentrated-liquidity/math/tick_test.go b/x/concentrated-liquidity/math/tick_test.go
index d3f960dda..0a41f01f2 100644
--- a/x/concentrated-liquidity/math/tick_test.go
+++ b/x/concentrated-liquidity/math/tick_test.go
@@ -330,6 +330,7 @@ func (suite *ConcentratedMathTestSuite) TestPriceToTick() {
 			tickExpected: sdk.NewInt(types.MaxTick - 100).String(),
 		},
 		"max sqrt price, max tick neg six -> max spot price": {
+
 			price:        types.MaxSqrtPrice.Power(2),
 			tickExpected: sdk.NewInt(types.MaxTick).String(),
 		},
@@ -443,6 +444,7 @@ func (suite *ConcentratedMathTestSuite) TestPriceToTick_RoundDown() {
 		tc := tc
 
 		suite.Run(name, func() {
+
 			tick, err := math.PriceToTickRoundDown(tc.price, tc.tickSpacing)
 
 			suite.Require().NoError(err)
diff --git a/x/concentrated-liquidity/pool_test.go b/x/concentrated-liquidity/pool_test.go
index a1818b619..22a1ad403 100644
--- a/x/concentrated-liquidity/pool_test.go
+++ b/x/concentrated-liquidity/pool_test.go
@@ -389,6 +389,7 @@ func (s *KeeperTestSuite) TestSetPool() {
 			retrievedPool, err = s.App.ConcentratedLiquidityKeeper.GetPoolById(s.Ctx, test.pool.GetId())
 			s.Require().NoError(err)
 			s.Require().Equal(test.pool, retrievedPool)
+
 		})
 	}
 }
diff --git a/x/concentrated-liquidity/position_test.go b/x/concentrated-liquidity/position_test.go
index 88d35f67a..ad5cc92a2 100644
--- a/x/concentrated-liquidity/position_test.go
+++ b/x/concentrated-liquidity/position_test.go
@@ -14,7 +14,9 @@ import (
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
 )
 
-var DefaultIncentiveRecords = []types.IncentiveRecord{incentiveRecordOne, incentiveRecordTwo, incentiveRecordThree, incentiveRecordFour}
+var (
+	DefaultIncentiveRecords = []types.IncentiveRecord{incentiveRecordOne, incentiveRecordTwo, incentiveRecordThree, incentiveRecordFour}
+)
 
 func (s *KeeperTestSuite) TestInitOrUpdatePosition() {
 	const (
@@ -31,6 +33,7 @@ func (s *KeeperTestSuite) TestInitOrUpdatePosition() {
 		joinTime       time.Time
 		positionId     uint64
 		liquidityDelta sdk.Dec
+		liquidityIn    sdk.Dec
 	}
 
 	tests := []struct {
@@ -204,7 +207,7 @@ func (s *KeeperTestSuite) TestInitOrUpdatePosition() {
 			s.Require().NoError(err)
 
 			// Setup for checks
-			actualUptimeAccumDelta, expectedUptimeAccumValueGrowth, expectedIncentiveRecords, _ := emptyAccumValues, emptyAccumValues, test.incentiveRecords, sdk.DecCoins{}
+			actualUptimeAccumDelta, expectedUptimeAccumValueGrowth, expectedIncentiveRecords, expectedGrowthCurAccum := emptyAccumValues, emptyAccumValues, test.incentiveRecords, sdk.DecCoins{}
 
 			timeElapsedSec := sdk.NewDec(int64(test.timeElapsedSinceInit)).Quo(sdk.NewDec(10e8))
 			positionName := string(types.KeyPositionId(test.param.positionId))
@@ -234,7 +237,7 @@ func (s *KeeperTestSuite) TestInitOrUpdatePosition() {
 					// Track how much the current uptime accum has grown by
 					actualUptimeAccumDelta[uptimeIndex] = newUptimeAccumValues[uptimeIndex].Sub(initUptimeAccumValues[uptimeIndex])
 					if timeElapsedSec.GT(sdk.ZeroDec()) {
-						expectedGrowthCurAccum, _, err := cl.CalcAccruedIncentivesForAccum(s.Ctx, uptime, test.param.liquidityDelta, timeElapsedSec, expectedIncentiveRecords)
+						expectedGrowthCurAccum, expectedIncentiveRecords, err = cl.CalcAccruedIncentivesForAccum(s.Ctx, uptime, test.param.liquidityDelta, timeElapsedSec, expectedIncentiveRecords)
 						s.Require().NoError(err)
 						expectedUptimeAccumValueGrowth[uptimeIndex] = expectedGrowthCurAccum
 					}
@@ -257,6 +260,7 @@ func (s *KeeperTestSuite) TestInitOrUpdatePosition() {
 }
 
 func (s *KeeperTestSuite) TestGetPosition() {
+
 	tests := []struct {
 		name                      string
 		positionId                uint64
@@ -932,7 +936,7 @@ func (s *KeeperTestSuite) TestValidateAndFungifyChargedPositions() {
 				s.Require().Equal(sdk.Coins(nil), forfeitedRewards)
 
 				// Sanity check that cannot claim again.
-				claimedRewards, _, err = s.App.ConcentratedLiquidityKeeper.ClaimAllIncentivesForPosition(s.Ctx, newPositionId)
+				claimedRewards, forfeitedRewards, err = s.App.ConcentratedLiquidityKeeper.ClaimAllIncentivesForPosition(s.Ctx, newPositionId)
 				s.Require().NoError(err)
 
 				s.Require().Equal(sdk.Coins(nil), claimedRewards)
@@ -1456,6 +1460,7 @@ func (s *KeeperTestSuite) TestMintSharesLockAndUpdate() {
 			s.Require().NoError(err)
 			s.Require().Equal(underlyingLiquidityTokenized[0].Amount.String(), concentratedLock.Coins[0].Amount.String())
 			s.Require().Equal(test.remainingLockDuration, concentratedLock.Duration)
+
 		},
 		)
 	}
diff --git a/x/concentrated-liquidity/store_test.go b/x/concentrated-liquidity/store_test.go
index 266f3d82a..0eb5ff574 100644
--- a/x/concentrated-liquidity/store_test.go
+++ b/x/concentrated-liquidity/store_test.go
@@ -32,6 +32,11 @@ var (
 )
 
 func (s *KeeperTestSuite) TestParseFullTickFromBytes() {
+	const (
+		emptyKeySeparator   = ""
+		invalidKeySeparator = "-"
+	)
+
 	var (
 		cdc = s.App.AppCodec()
 
@@ -120,6 +125,7 @@ func (s *KeeperTestSuite) TestParseFullTickFromBytes() {
 	for name, tc := range tests {
 		tc := tc
 		s.Run(name, func() {
+
 			fullTick, err := cl.ParseFullTickFromBytes(tc.key, tc.val)
 			if tc.expectedErr != nil {
 				s.Require().Error(err)
diff --git a/x/concentrated-liquidity/swaps_test.go b/x/concentrated-liquidity/swaps_test.go
index 7a2da4695..6bff49b70 100644
--- a/x/concentrated-liquidity/swaps_test.go
+++ b/x/concentrated-liquidity/swaps_test.go
@@ -1443,6 +1443,7 @@ var (
 )
 
 func (s *KeeperTestSuite) TestCalcAndSwapOutAmtGivenIn() {
+
 	tests := make(map[string]SwapTest, len(swapOutGivenInCases)+len(swapOutGivenInFeeCases)+len(swapOutGivenInErrorCases))
 	for name, test := range swapOutGivenInCases {
 		tests[name] = test
@@ -1597,6 +1598,7 @@ func (s *KeeperTestSuite) TestCalcAndSwapOutAmtGivenIn() {
 }
 
 func (s *KeeperTestSuite) TestSwapOutAmtGivenIn_TickUpdates() {
+
 	tests := make(map[string]SwapTest)
 	for name, test := range swapOutGivenInCases {
 		tests[name] = test
@@ -1675,6 +1677,7 @@ func (s *KeeperTestSuite) TestSwapOutAmtGivenIn_TickUpdates() {
 }
 
 func (s *KeeperTestSuite) TestCalcAndSwapInAmtGivenOut() {
+
 	tests := make(map[string]SwapTest, len(swapInGivenOutTestCases)+len(swapInGivenOutFeeTestCases)+len(swapInGivenOutErrorTestCases))
 	for name, test := range swapInGivenOutTestCases {
 		tests[name] = test
@@ -1844,6 +1847,7 @@ func (s *KeeperTestSuite) TestCalcAndSwapInAmtGivenOut() {
 }
 
 func (s *KeeperTestSuite) TestSwapInAmtGivenOut_TickUpdates() {
+
 	tests := make(map[string]SwapTest)
 	for name, test := range swapInGivenOutTestCases {
 		tests[name] = test
@@ -2281,6 +2285,7 @@ func (s *KeeperTestSuite) TestSwapExactAmountOut() {
 // TestCalcOutAmtGivenInWriteCtx tests that writeCtx successfully performs state changes as expected.
 // We expect writeCtx to only change fee accum state, since pool state change is not handled via writeCtx function.
 func (s *KeeperTestSuite) TestCalcOutAmtGivenInWriteCtx() {
+
 	// we only use fee cases here since write Ctx only takes effect in the fee accumulator
 	tests := make(map[string]SwapTest, len(swapOutGivenInFeeCases))
 
@@ -2365,6 +2370,7 @@ func (s *KeeperTestSuite) TestCalcOutAmtGivenInWriteCtx() {
 // TestCalcInAmtGivenOutWriteCtx tests that writeCtx succesfully perfroms state changes as expected.
 // We expect writeCtx to only change fee accum state, since pool state change is not handled via writeCtx function.
 func (s *KeeperTestSuite) TestCalcInAmtGivenOutWriteCtx() {
+
 	// we only use fee cases here since write Ctx only takes effect in the fee accumulator
 	tests := make(map[string]SwapTest, len(swapInGivenOutFeeTestCases))
 
@@ -2445,8 +2451,8 @@ func (s *KeeperTestSuite) TestCalcInAmtGivenOutWriteCtx() {
 		})
 	}
 }
-
 func (s *KeeperTestSuite) TestInverseRelationshipSwapOutAmtGivenIn() {
+
 	tests := swapOutGivenInCases
 
 	for name, test := range tests {
diff --git a/x/concentrated-liquidity/swapstrategy/fees_test.go b/x/concentrated-liquidity/swapstrategy/fees_test.go
index b6e476b95..21d8faf29 100644
--- a/x/concentrated-liquidity/swapstrategy/fees_test.go
+++ b/x/concentrated-liquidity/swapstrategy/fees_test.go
@@ -7,7 +7,9 @@ import (
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/swapstrategy"
 )
 
-var onePercentFee = sdk.NewDecWithPrec(1, 2)
+var (
+	onePercentFee = sdk.NewDecWithPrec(1, 2)
+)
 
 func (suite *StrategyTestSuite) TestComputeFeeChargePerSwapStepOutGivenIn() {
 	tests := map[string]struct {
diff --git a/x/concentrated-liquidity/swapstrategy/one_for_zero_test.go b/x/concentrated-liquidity/swapstrategy/one_for_zero_test.go
index ced6d67eb..5bfcfc429 100644
--- a/x/concentrated-liquidity/swapstrategy/one_for_zero_test.go
+++ b/x/concentrated-liquidity/swapstrategy/one_for_zero_test.go
@@ -41,6 +41,7 @@ func (suite *StrategyTestSuite) TestGetSqrtTargetPrice_OneForZero() {
 			actualSqrtTargetPrice := strategy.GetSqrtTargetPrice(tc.nextTickSqrtPrice)
 
 			suite.Require().Equal(tc.expectedResult, actualSqrtTargetPrice)
+
 		})
 	}
 }
diff --git a/x/concentrated-liquidity/swapstrategy/swap_strategy_test.go b/x/concentrated-liquidity/swapstrategy/swap_strategy_test.go
index 2c2172275..ff93369e5 100644
--- a/x/concentrated-liquidity/swapstrategy/swap_strategy_test.go
+++ b/x/concentrated-liquidity/swapstrategy/swap_strategy_test.go
@@ -57,6 +57,7 @@ func (suite *StrategyTestSuite) TestNextInitializedTick() {
 
 	suite.Run("lte=true", func() {
 		suite.Run("returns tick to right if at initialized tick", func() {
+
 			swapStrategy := swapstrategy.New(false, sdk.ZeroDec(), clStoreKey, sdk.ZeroDec(), defaultTickSpacing)
 
 			n, initd := swapStrategy.NextInitializedTick(ctx, 1, 78)
diff --git a/x/concentrated-liquidity/swapstrategy/zero_for_one_test.go b/x/concentrated-liquidity/swapstrategy/zero_for_one_test.go
index 0e49e3477..095226105 100644
--- a/x/concentrated-liquidity/swapstrategy/zero_for_one_test.go
+++ b/x/concentrated-liquidity/swapstrategy/zero_for_one_test.go
@@ -48,6 +48,7 @@ func (suite *StrategyTestSuite) TestGetSqrtTargetPrice_ZeroForOne() {
 			actualSqrtTargetPrice := sut.GetSqrtTargetPrice(tc.nextTickSqrtPrice)
 
 			suite.Require().Equal(tc.expectedResult, actualSqrtTargetPrice)
+
 		})
 	}
 }
diff --git a/x/concentrated-liquidity/types/params_test.go b/x/concentrated-liquidity/types/params_test.go
index 5eb3aadfe..b0d16cda3 100644
--- a/x/concentrated-liquidity/types/params_test.go
+++ b/x/concentrated-liquidity/types/params_test.go
@@ -45,6 +45,7 @@ func TestValidateTicks(t *testing.T) {
 	for name, tc := range tests {
 		tc := tc
 		t.Run(name, func(t *testing.T) {
+
 			err := types.ValidateTicks(tc.i)
 
 			if tc.expectError {
diff --git a/x/downtime-detector/client/cli/query_test.go b/x/downtime-detector/client/cli/query_test.go
index 77b626804..68955d802 100644
--- a/x/downtime-detector/client/cli/query_test.go
+++ b/x/downtime-detector/client/cli/query_test.go
@@ -18,37 +18,32 @@ func TestRecoveredSinceQueryCmd(t *testing.T) {
 			Cmd: "30s 10m",
 			ExpectedQuery: &queryproto.RecoveredSinceDowntimeOfLengthRequest{
 				Downtime: types.Downtime_DURATION_30S,
-				Recovery: time.Minute * 10,
-			},
+				Recovery: time.Minute * 10},
 		},
 		"invalid duration": {
 			Cmd: "31s 10m",
 			ExpectedQuery: &queryproto.RecoveredSinceDowntimeOfLengthRequest{
 				Downtime: types.Downtime_DURATION_30S,
-				Recovery: time.Minute * 10,
-			},
+				Recovery: time.Minute * 10},
 			ExpectedErr: true,
 		},
 		"90m": {
 			Cmd: "90m 10m",
 			ExpectedQuery: &queryproto.RecoveredSinceDowntimeOfLengthRequest{
 				Downtime: types.Downtime_DURATION_1_5H,
-				Recovery: time.Minute * 10,
-			},
+				Recovery: time.Minute * 10},
 		},
 		"1.5h": {
 			Cmd: "1.5h 10m",
 			ExpectedQuery: &queryproto.RecoveredSinceDowntimeOfLengthRequest{
 				Downtime: types.Downtime_DURATION_1_5H,
-				Recovery: time.Minute * 10,
-			},
+				Recovery: time.Minute * 10},
 		},
 		"1h30m": {
 			Cmd: "1h30m 10m",
 			ExpectedQuery: &queryproto.RecoveredSinceDowntimeOfLengthRequest{
 				Downtime: types.Downtime_DURATION_1_5H,
-				Recovery: time.Minute * 10,
-			},
+				Recovery: time.Minute * 10},
 		},
 	}
 	osmocli.RunQueryTestCases(t, desc, tcs)
diff --git a/x/downtime-detector/keeper_test.go b/x/downtime-detector/keeper_test.go
index b993097c3..8982b9b8d 100644
--- a/x/downtime-detector/keeper_test.go
+++ b/x/downtime-detector/keeper_test.go
@@ -10,11 +10,9 @@ import (
 	"github.com/osmosis-labs/osmosis/v15/x/downtime-detector/types"
 )
 
-var (
-	baseTime = time.Unix(1257894000, 0).UTC()
-	sec      = time.Second
-	min      = time.Minute
-)
+var baseTime = time.Unix(1257894000, 0).UTC()
+var sec = time.Second
+var min = time.Minute
 
 type blocktimes []time.Duration
 
@@ -35,12 +33,10 @@ func (suite *KeeperTestSuite) runBlocktimes(times blocktimes) {
 	}
 }
 
-var (
-	abruptRecovery5minDowntime10min   blocktimes = []time.Duration{sec, 10 * min, 5 * min}
-	smootherRecovery5minDowntime10min blocktimes = []time.Duration{sec, 10 * min, min, min, min, min, min}
-	fifteenMinEndtime                            = abruptRecovery5minDowntime10min.EndTime()
-	tenMinEndtime                                = abruptRecovery5minDowntime10min.EndTime().Add(-5 * min)
-)
+var abruptRecovery5minDowntime10min blocktimes = []time.Duration{sec, 10 * min, 5 * min}
+var smootherRecovery5minDowntime10min blocktimes = []time.Duration{sec, 10 * min, min, min, min, min, min}
+var fifteenMinEndtime = abruptRecovery5minDowntime10min.EndTime()
+var tenMinEndtime = abruptRecovery5minDowntime10min.EndTime().Add(-5 * min)
 
 func (suite *KeeperTestSuite) TestBeginBlock() {
 	tests := map[string]struct {
diff --git a/x/epochs/keeper/keeper_test.go b/x/epochs/keeper/keeper_test.go
index cc9f97ba2..7029cb3f9 100644
--- a/x/epochs/keeper/keeper_test.go
+++ b/x/epochs/keeper/keeper_test.go
@@ -48,9 +48,10 @@ func Setup() (sdk.Context, *epochskeeper.Keeper) {
 	epochsKeeper.InitGenesis(ctx, *types.DefaultGenesis())
 	SetEpochStartTime(ctx, epochsKeeper)
 	return ctx, epochsKeeper
-}
 
+}
 func SetEpochStartTime(ctx sdk.Context, epochsKeeper *epochskeeper.Keeper) {
+
 	for _, epoch := range epochsKeeper.AllEpochInfos(ctx) {
 		epoch.StartTime = ctx.BlockTime()
 		epochsKeeper.DeleteEpochInfo(ctx, epoch.Identifier)
diff --git a/x/gamm/client/cli/cli_test.go b/x/gamm/client/cli/cli_test.go
index 0a2fdfda5..0eecf4f4d 100644
--- a/x/gamm/client/cli/cli_test.go
+++ b/x/gamm/client/cli/cli_test.go
@@ -14,6 +14,7 @@ import (
 	poolmanagertypes "github.com/osmosis-labs/osmosis/v15/x/poolmanager/types"
 
 	"github.com/cosmos/cosmos-sdk/testutil"
+	"github.com/cosmos/cosmos-sdk/testutil/network"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/query"
 )
@@ -22,6 +23,9 @@ var testAddresses = osmoutils.CreateRandomAccounts(3)
 
 type IntegrationTestSuite struct {
 	suite.Suite
+
+	cfg     network.Config
+	network *network.Network
 }
 
 func TestNewCreatePoolCmd(t *testing.T) {
@@ -311,7 +315,7 @@ func TestNewMigrateSharesToFullRangeConcentratedPosition(t *testing.T) {
 			ExpectedMsg: &balancer.MsgMigrateSharesToFullRangeConcentratedPosition{
 				Sender:          testAddresses[0].String(),
 				SharesToMigrate: sdk.NewCoin("stake", sdk.NewInt(1000)),
-				TokenOutMins:    sdk.NewCoins(sdk.NewInt64Coin("stake", 100), sdk.NewInt64Coin("uosmo", 1000)),
+				TokenOutMins:  sdk.NewCoins(sdk.NewInt64Coin("stake", 100), sdk.NewInt64Coin("uosmo", 1000)),
 			},
 		},
 	}
diff --git a/x/gamm/client/cli/tx_test.go b/x/gamm/client/cli/tx_test.go
index 293496408..48f493ec1 100644
--- a/x/gamm/client/cli/tx_test.go
+++ b/x/gamm/client/cli/tx_test.go
@@ -61,6 +61,7 @@ func TestParseCoinsNoSort(t *testing.T) {
 
 	for name, tc := range tests {
 		t.Run(name, func(t *testing.T) {
+
 			coins, err := cli.ParseCoinsNoSort(tc.coinsStr)
 
 			require.NoError(t, err)
diff --git a/x/gamm/keeper/genesis_test.go b/x/gamm/keeper/genesis_test.go
index 11dee6197..20ea53c97 100644
--- a/x/gamm/keeper/genesis_test.go
+++ b/x/gamm/keeper/genesis_test.go
@@ -17,11 +17,13 @@ import (
 	"github.com/osmosis-labs/osmosis/v15/x/gamm/types"
 )
 
-var DefaultMigrationRecords = types.MigrationRecords{BalancerToConcentratedPoolLinks: []types.BalancerToConcentratedPoolLink{
-	{BalancerPoolId: 1, ClPoolId: 4},
-	{BalancerPoolId: 2, ClPoolId: 5},
-	{BalancerPoolId: 3, ClPoolId: 6},
-}}
+var (
+	DefaultMigrationRecords = types.MigrationRecords{BalancerToConcentratedPoolLinks: []types.BalancerToConcentratedPoolLink{
+		{BalancerPoolId: 1, ClPoolId: 4},
+		{BalancerPoolId: 2, ClPoolId: 5},
+		{BalancerPoolId: 3, ClPoolId: 6},
+	}}
+)
 
 func TestGammInitGenesis(t *testing.T) {
 	app := osmoapp.Setup(false)
diff --git a/x/gamm/keeper/pool_service_test.go b/x/gamm/keeper/pool_service_test.go
index 6972d3072..17f6a6c98 100644
--- a/x/gamm/keeper/pool_service_test.go
+++ b/x/gamm/keeper/pool_service_test.go
@@ -21,7 +21,10 @@ var (
 		SwapFee: defaultSwapFee,
 		ExitFee: defaultZeroExitFee,
 	}
-
+	defaultStableSwapPoolParams = stableswap.PoolParams{
+		SwapFee: defaultSwapFee,
+		ExitFee: defaultZeroExitFee,
+	}
 	defaultScalingFactor  = []uint64{1, 1}
 	defaultFutureGovernor = ""
 
diff --git a/x/gamm/keeper/pool_test.go b/x/gamm/keeper/pool_test.go
index 42eae907e..722a48650 100644
--- a/x/gamm/keeper/pool_test.go
+++ b/x/gamm/keeper/pool_test.go
@@ -16,11 +16,20 @@ import (
 )
 
 var (
+	defaultPoolAssetsStableSwap = sdk.Coins{
+		sdk.NewCoin("atom", sdk.NewInt(100)),
+		sdk.NewCoin("osmo", sdk.NewInt(100)),
+	}
 	defaultPoolParamsStableSwap = stableswap.PoolParams{
 		SwapFee: sdk.NewDecWithPrec(1, 2),
 		ExitFee: sdk.ZeroDec(),
 	}
-	defaultPoolId = uint64(1)
+	defaultPoolId                        = uint64(1)
+	defaultAcctFundsStableSwap sdk.Coins = sdk.NewCoins(
+		sdk.NewCoin("uosmo", sdk.NewInt(10000000000)),
+		sdk.NewCoin("atom", sdk.NewInt(100)),
+		sdk.NewCoin("osmo", sdk.NewInt(100)),
+	)
 )
 
 // import (
@@ -369,6 +378,7 @@ func (suite *KeeperTestSuite) TestConvertToCFMMPool() {
 // change the underlying bytes. This shows that migrations are
 // not necessary.
 func (suite *KeeperTestSuite) TestMarshalUnmarshalPool() {
+
 	suite.SetupTest()
 	k := suite.App.GAMMKeeper
 
@@ -515,4 +525,5 @@ func (suite *KeeperTestSuite) TestSetStableSwapScalingFactors() {
 			}
 		})
 	}
+
 }
diff --git a/x/gamm/pool-models/balancer/marshal_test.go b/x/gamm/pool-models/balancer/marshal_test.go
index 714f3cb77..2e72e8d42 100644
--- a/x/gamm/pool-models/balancer/marshal_test.go
+++ b/x/gamm/pool-models/balancer/marshal_test.go
@@ -13,6 +13,17 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+var ymlAssetTest = []balancer.PoolAsset{
+	{
+		Weight: sdk.NewInt(200),
+		Token:  sdk.NewCoin("test2", sdk.NewInt(50000)),
+	},
+	{
+		Weight: sdk.NewInt(100),
+		Token:  sdk.NewCoin("test1", sdk.NewInt(10000)),
+	},
+}
+
 func TestPoolJson(t *testing.T) {
 	var poolId uint64 = 10
 
diff --git a/x/gamm/pool-models/balancer/pool_suite_test.go b/x/gamm/pool-models/balancer/pool_suite_test.go
index 0bc9051d7..13f0ad57c 100644
--- a/x/gamm/pool-models/balancer/pool_suite_test.go
+++ b/x/gamm/pool-models/balancer/pool_suite_test.go
@@ -1007,7 +1007,7 @@ func (suite *KeeperTestSuite) TestRandomizedJoinPoolExitPoolInvariants() {
 		denomIn  = "denomIn"
 	)
 
-	now := time.Now().Unix()
+	now := int64(time.Now().Unix())
 	rng := rand.NewSource(now)
 	suite.T().Logf("Using random source of %d\n", now)
 
diff --git a/x/gamm/pool-models/balancer/pool_test.go b/x/gamm/pool-models/balancer/pool_test.go
index 4de46cdad..6aa90b864 100644
--- a/x/gamm/pool-models/balancer/pool_test.go
+++ b/x/gamm/pool-models/balancer/pool_test.go
@@ -19,7 +19,7 @@ import (
 
 var (
 	defaultSwapFee            = sdk.MustNewDecFromStr("0.025")
-	defaultZeroExitFee        = sdk.ZeroDec()
+	defaultZeroExitFee            = sdk.ZeroDec()
 	defaultPoolId             = uint64(10)
 	defaultBalancerPoolParams = balancer.PoolParams{
 		SwapFee: defaultSwapFee,
@@ -570,8 +570,7 @@ func (suite *BalancerTestSuite) TestBalancerCalculateAmountOutAndIn_InverseRelat
 				suite.Require().NotNil(pool)
 
 				errTolerance := osmomath.ErrTolerance{
-					AdditiveTolerance: sdk.OneDec(), MultiplicativeTolerance: sdk.Dec{},
-				}
+					AdditiveTolerance: sdk.OneDec(), MultiplicativeTolerance: sdk.Dec{}}
 				sut := func() {
 					test_helpers.TestCalculateAmountOutAndIn_InverseRelationship(suite.T(), ctx, pool, poolAssetIn.Token.Denom, poolAssetOut.Token.Denom, tc.initialCalcOut, swapFeeDec, errTolerance)
 				}
@@ -585,6 +584,7 @@ func (suite *BalancerTestSuite) TestBalancerCalculateAmountOutAndIn_InverseRelat
 func TestCalcSingleAssetInAndOut_InverseRelationship(t *testing.T) {
 	type testcase struct {
 		initialPoolOut   int64
+		initialPoolIn    int64
 		initialWeightOut int64
 		tokenOut         int64
 		initialWeightIn  int64
diff --git a/x/gamm/pool-models/balancer/util_test.go b/x/gamm/pool-models/balancer/util_test.go
index ce73023f1..97a7b5680 100644
--- a/x/gamm/pool-models/balancer/util_test.go
+++ b/x/gamm/pool-models/balancer/util_test.go
@@ -5,8 +5,12 @@ import (
 	"testing"
 	"time"
 
+	"github.com/cosmos/cosmos-sdk/store/rootmulti"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/require"
+	"github.com/tendermint/tendermint/libs/log"
+	tmtypes "github.com/tendermint/tendermint/proto/tendermint/types"
+	dbm "github.com/tendermint/tm-db"
 
 	"github.com/osmosis-labs/osmosis/osmomath"
 	"github.com/osmosis-labs/osmosis/v15/x/gamm/pool-models/balancer"
@@ -25,6 +29,15 @@ func createTestPool(t *testing.T, swapFee, exitFee sdk.Dec, poolAssets ...balanc
 	return &pool
 }
 
+func createTestContext(t *testing.T) sdk.Context {
+	db := dbm.NewMemDB()
+	logger := log.NewNopLogger()
+
+	ms := rootmulti.NewStore(db, logger)
+
+	return sdk.NewContext(ms, tmtypes.Header{}, false, logger)
+}
+
 func assertExpectedSharesErrRatio(t *testing.T, expectedShares, actualShares sdk.Int) {
 	allowedErrRatioDec, err := sdk.NewDecFromStr(allowedErrRatio)
 	require.NoError(t, err)
diff --git a/x/gamm/pool-models/stableswap/msgs_test.go b/x/gamm/pool-models/stableswap/msgs_test.go
index 869242e1a..ea20a8891 100644
--- a/x/gamm/pool-models/stableswap/msgs_test.go
+++ b/x/gamm/pool-models/stableswap/msgs_test.go
@@ -338,6 +338,7 @@ func (suite *TestSuite) TestMsgCreateStableswapPool() {
 
 	for name, tc := range tests {
 		suite.Run(name, func() {
+
 			pool, err := tc.msg.CreatePool(suite.Ctx, 1)
 
 			if tc.expectError {
diff --git a/x/gamm/pool-models/stableswap/pool_test.go b/x/gamm/pool-models/stableswap/pool_test.go
index 3b489523d..5cab54fa3 100644
--- a/x/gamm/pool-models/stableswap/pool_test.go
+++ b/x/gamm/pool-models/stableswap/pool_test.go
@@ -1365,6 +1365,7 @@ func TestStableswapSpotPrice(t *testing.T) {
 }
 
 func TestValidateScalingFactors(t *testing.T) {
+
 	tests := map[string]struct {
 		scalingFactors []uint64
 		numAssets      int
diff --git a/x/ibc-rate-limit/ibc_middleware_test.go b/x/ibc-rate-limit/ibc_middleware_test.go
index 489b63782..541e0895c 100644
--- a/x/ibc-rate-limit/ibc_middleware_test.go
+++ b/x/ibc-rate-limit/ibc_middleware_test.go
@@ -147,9 +147,9 @@ func (suite *MiddlewareTestSuite) TestInvalidReceiver() {
 		0,
 	)
 	_, ack, _ := suite.FullSendBToA(msg)
-	suite.Require().Contains(ack, "error",
+	suite.Require().Contains(string(ack), "error",
 		"acknowledgment is not an error")
-	suite.Require().Contains(ack, fmt.Sprintf("ABCI code: %d", types.ErrBadMessage.ABCICode()),
+	suite.Require().Contains(string(ack), fmt.Sprintf("ABCI code: %d", types.ErrBadMessage.ABCICode()),
 		"acknowledgment error is not of the right type")
 }
 
@@ -218,12 +218,12 @@ func (suite *MiddlewareTestSuite) AssertReceive(success bool, msg sdk.Msg) (stri
 	_, ack, err := suite.FullSendBToA(msg)
 	if success {
 		suite.Require().NoError(err)
-		suite.Require().NotContains(ack, "error",
+		suite.Require().NotContains(string(ack), "error",
 			"acknowledgment is an error")
 	} else {
-		suite.Require().Contains(ack, "error",
+		suite.Require().Contains(string(ack), "error",
 			"acknowledgment is not an error")
-		suite.Require().Contains(ack, fmt.Sprintf("ABCI code: %d", types.ErrRateLimitExceeded.ABCICode()),
+		suite.Require().Contains(string(ack), fmt.Sprintf("ABCI code: %d", types.ErrRateLimitExceeded.ABCICode()),
 			"acknowledgment error is not of the right type")
 	}
 	return ack, err
diff --git a/x/incentives/client/cli/cli_test.go b/x/incentives/client/cli/cli_test.go
index c12016e3e..841e99411 100644
--- a/x/incentives/client/cli/cli_test.go
+++ b/x/incentives/client/cli/cli_test.go
@@ -5,10 +5,12 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/types/query"
 
+	"github.com/osmosis-labs/osmosis/osmoutils"
 	"github.com/osmosis-labs/osmosis/osmoutils/osmocli"
 	"github.com/osmosis-labs/osmosis/v15/x/incentives/types"
 )
 
+var testAddresses = osmoutils.CreateRandomAccounts(3)
 
 func TestGetCmdGauges(t *testing.T) {
 	desc, _ := GetCmdGauges()
@@ -50,8 +52,7 @@ func TestGetCmdActiveGauges(t *testing.T) {
 			Cmd: "--offset=2",
 			ExpectedQuery: &types.ActiveGaugesRequest{
 				Pagination: &query.PageRequest{Key: []uint8{}, Offset: 2, Limit: 100},
-			},
-		},
+			}},
 	}
 	osmocli.RunQueryTestCases(t, desc, tcs)
 }
@@ -64,8 +65,7 @@ func TestGetCmdActiveGaugesPerDenom(t *testing.T) {
 			ExpectedQuery: &types.ActiveGaugesPerDenomRequest{
 				Denom:      "uosmo",
 				Pagination: &query.PageRequest{Key: []uint8{}, Offset: 2, Limit: 100},
-			},
-		},
+			}},
 	}
 	osmocli.RunQueryTestCases(t, desc, tcs)
 }
@@ -77,8 +77,7 @@ func TestGetCmdUpcomingGauges(t *testing.T) {
 			Cmd: "--offset=2",
 			ExpectedQuery: &types.UpcomingGaugesRequest{
 				Pagination: &query.PageRequest{Key: []uint8{}, Offset: 2, Limit: 100},
-			},
-		},
+			}},
 	}
 	osmocli.RunQueryTestCases(t, desc, tcs)
 }
@@ -91,8 +90,7 @@ func TestGetCmdUpcomingGaugesPerDenom(t *testing.T) {
 			ExpectedQuery: &types.UpcomingGaugesPerDenomRequest{
 				Denom:      "uosmo",
 				Pagination: &query.PageRequest{Key: []uint8{}, Offset: 2, Limit: 100},
-			},
-		},
+			}},
 	}
 	osmocli.RunQueryTestCases(t, desc, tcs)
 }
diff --git a/x/incentives/keeper/msg_server_test.go b/x/incentives/keeper/msg_server_test.go
index 9ecbbf880..4e4ce9cbb 100644
--- a/x/incentives/keeper/msg_server_test.go
+++ b/x/incentives/keeper/msg_server_test.go
@@ -17,10 +17,8 @@ import (
 
 var _ = suite.TestingSuite(nil)
 
-var (
-	seventyTokens = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(70000000)))
-	tenTokens     = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10000000)))
-)
+var seventyTokens = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(70000000)))
+var tenTokens = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10000000)))
 
 func (suite *KeeperTestSuite) TestCreateGauge_Fee() {
 	tests := []struct {
diff --git a/x/incentives/types/msgs_test.go b/x/incentives/types/msgs_test.go
index 9cf790a0c..55d137942 100644
--- a/x/incentives/types/msgs_test.go
+++ b/x/incentives/types/msgs_test.go
@@ -224,6 +224,11 @@ func TestAuthzMsg(t *testing.T) {
 	coin := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1))
 	someDate := time.Date(1, 1, 1, 1, 1, 1, 1, time.UTC)
 
+	const (
+		mockGranter string = "cosmos1abc"
+		mockGrantee string = "cosmos1xyz"
+	)
+
 	testCases := []struct {
 		name          string
 		incentivesMsg sdk.Msg
diff --git a/x/lockup/keeper/grpc_query_test.go b/x/lockup/keeper/grpc_query_test.go
index cd84867b1..308a1448d 100644
--- a/x/lockup/keeper/grpc_query_test.go
+++ b/x/lockup/keeper/grpc_query_test.go
@@ -343,7 +343,7 @@ func (suite *KeeperTestSuite) TestLockedByID() {
 	addr1 := sdk.AccAddress([]byte("addr1---------------"))
 
 	// lock by not available id check
-	_, err := suite.querier.LockedByID(sdk.WrapSDKContext(suite.Ctx), &types.LockedRequest{LockId: 0})
+	res, err := suite.querier.LockedByID(sdk.WrapSDKContext(suite.Ctx), &types.LockedRequest{LockId: 0})
 	suite.Require().Error(err)
 
 	// lock coins
@@ -351,7 +351,7 @@ func (suite *KeeperTestSuite) TestLockedByID() {
 	suite.LockTokens(addr1, coins, time.Second)
 
 	// lock by available available id check
-	res, err := suite.querier.LockedByID(sdk.WrapSDKContext(suite.Ctx), &types.LockedRequest{LockId: 1})
+	res, err = suite.querier.LockedByID(sdk.WrapSDKContext(suite.Ctx), &types.LockedRequest{LockId: 1})
 	suite.Require().NoError(err)
 	suite.Require().Equal(res.Lock.ID, uint64(1))
 	suite.Require().Equal(res.Lock.Owner, addr1.String())
@@ -389,11 +389,11 @@ func (suite *KeeperTestSuite) TestAccountLockedLongerDuration() {
 	addr1 := sdk.AccAddress([]byte("addr1---------------"))
 
 	// empty address locks longer than duration check
-	_, err := suite.querier.AccountLockedLongerDuration(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationRequest{Owner: "", Duration: time.Second})
+	res, err := suite.querier.AccountLockedLongerDuration(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationRequest{Owner: "", Duration: time.Second})
 	suite.Require().Error(err)
 
 	// initial check
-	res, err := suite.querier.AccountLockedLongerDuration(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationRequest{Owner: addr1.String(), Duration: time.Second})
+	res, err = suite.querier.AccountLockedLongerDuration(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationRequest{Owner: addr1.String(), Duration: time.Second})
 	suite.Require().NoError(err)
 	suite.Require().Len(res.Locks, 0)
 
@@ -423,11 +423,11 @@ func (suite *KeeperTestSuite) TestAccountLockedLongerDurationNotUnlockingOnly()
 	addr1 := sdk.AccAddress([]byte("addr1---------------"))
 
 	// empty address locks longer than duration check
-	_, err := suite.querier.AccountLockedLongerDurationNotUnlockingOnly(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationNotUnlockingOnlyRequest{Owner: "", Duration: time.Second})
+	res, err := suite.querier.AccountLockedLongerDurationNotUnlockingOnly(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationNotUnlockingOnlyRequest{Owner: "", Duration: time.Second})
 	suite.Require().Error(err)
 
 	// initial check
-	res, err := suite.querier.AccountLockedLongerDurationNotUnlockingOnly(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationNotUnlockingOnlyRequest{Owner: addr1.String(), Duration: time.Second})
+	res, err = suite.querier.AccountLockedLongerDurationNotUnlockingOnly(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationNotUnlockingOnlyRequest{Owner: addr1.String(), Duration: time.Second})
 	suite.Require().NoError(err)
 	suite.Require().Len(res.Locks, 0)
 
@@ -453,11 +453,11 @@ func (suite *KeeperTestSuite) TestAccountLockedLongerDurationDenom() {
 	addr1 := sdk.AccAddress([]byte("addr1---------------"))
 
 	// empty address locks longer than duration by denom check
-	_, err := suite.querier.AccountLockedLongerDurationDenom(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationDenomRequest{Owner: "", Duration: time.Second, Denom: "stake"})
+	res, err := suite.querier.AccountLockedLongerDurationDenom(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationDenomRequest{Owner: "", Duration: time.Second, Denom: "stake"})
 	suite.Require().Error(err)
 
 	// initial check
-	res, err := suite.querier.AccountLockedLongerDurationDenom(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationDenomRequest{Owner: addr1.String(), Duration: time.Second, Denom: "stake"})
+	res, err = suite.querier.AccountLockedLongerDurationDenom(sdk.WrapSDKContext(suite.Ctx), &types.AccountLockedLongerDurationDenomRequest{Owner: addr1.String(), Duration: time.Second, Denom: "stake"})
 	suite.Require().NoError(err)
 	suite.Require().Len(res.Locks, 0)
 
diff --git a/x/lockup/keeper/lock_test.go b/x/lockup/keeper/lock_test.go
index 764d41051..7d923e573 100644
--- a/x/lockup/keeper/lock_test.go
+++ b/x/lockup/keeper/lock_test.go
@@ -235,7 +235,7 @@ func (suite *KeeperTestSuite) TestUnlock() {
 		ctx := suite.Ctx
 
 		addr1 := sdk.AccAddress([]byte("addr1---------------"))
-		_ = types.NewPeriodLock(1, addr1, time.Second, time.Time{}, tc.fundAcc)
+		lock := types.NewPeriodLock(1, addr1, time.Second, time.Time{}, tc.fundAcc)
 
 		// lock with balance
 		suite.FundAcc(addr1, tc.fundAcc)
@@ -319,6 +319,7 @@ func (suite *KeeperTestSuite) TestUnlock() {
 }
 
 func (suite *KeeperTestSuite) TestUnlockMaturedLockInternalLogic() {
+
 	testCases := []struct {
 		name                       string
 		coinsLocked, coinsBurned   sdk.Coins
@@ -416,6 +417,7 @@ func (suite *KeeperTestSuite) TestUnlockMaturedLockInternalLogic() {
 					suite.Require().Equal(sdk.ZeroInt().String(), assetsSupplyAtLockEnd.AmountOf(coin.Denom).String())
 				}
 			}
+
 		})
 	}
 }
diff --git a/x/lockup/types/msgs_test.go b/x/lockup/types/msgs_test.go
index 88801ca19..dba8d314b 100644
--- a/x/lockup/types/msgs_test.go
+++ b/x/lockup/types/msgs_test.go
@@ -268,6 +268,11 @@ func TestAuthzMsg(t *testing.T) {
 	addr1 := sdk.AccAddress(pk1.Address()).String()
 	coin := sdk.NewCoin("denom", sdk.NewInt(1))
 
+	const (
+		mockGranter string = "cosmos1abc"
+		mockGrantee string = "cosmos1xyz"
+	)
+
 	testCases := []struct {
 		name string
 		msg  sdk.Msg
diff --git a/x/pool-incentives/keeper/keeper_test.go b/x/pool-incentives/keeper/keeper_test.go
index cedbd9feb..be029d5c1 100644
--- a/x/pool-incentives/keeper/keeper_test.go
+++ b/x/pool-incentives/keeper/keeper_test.go
@@ -112,7 +112,7 @@ func (suite *KeeperTestSuite) TestCreateLockablePoolGauges() {
 			name:                   "Create Gauge with valid PoolId",
 			poolId:                 uint64(1),
 			expectedGaugeDurations: durations,
-			expectedGaugeIds:       []uint64{4, 5, 6}, // note: it's not 1,2,3 because we create 3 gauges during setup of suite.PrepareBalancerPool()
+			expectedGaugeIds:       []uint64{4, 5, 6}, //note: it's not 1,2,3 because we create 3 gauges during setup of suite.PrepareBalancerPool()
 			expectedErr:            false,
 		},
 		{
@@ -303,6 +303,7 @@ func (suite *KeeperTestSuite) TestGetLongestLockableDuration() {
 
 	for _, tc := range testCases {
 		suite.Run(tc.name, func() {
+
 			suite.App.PoolIncentivesKeeper.SetLockableDurations(suite.Ctx, tc.lockableDurations)
 
 			result, err := suite.App.PoolIncentivesKeeper.GetLongestLockableDuration(suite.Ctx)
diff --git a/x/poolmanager/client/cli/cli_test.go b/x/poolmanager/client/cli/cli_test.go
index 75f75f0e3..c4e93a3f0 100644
--- a/x/poolmanager/client/cli/cli_test.go
+++ b/x/poolmanager/client/cli/cli_test.go
@@ -63,6 +63,7 @@ func (s *IntegrationTestSuite) TearDownSuite() {
 }
 
 func TestIntegrationTestSuite(t *testing.T) {
+
 	// TODO: re-enable this once poolmanager is fully merged.
 	t.SkipNow()
 
diff --git a/x/poolmanager/client/cli/query_test.go b/x/poolmanager/client/cli/query_test.go
index fa595f95e..c1fe49608 100644
--- a/x/poolmanager/client/cli/query_test.go
+++ b/x/poolmanager/client/cli/query_test.go
@@ -2,9 +2,8 @@ package cli_test
 
 import (
 	gocontext "context"
-	"testing"
-
 	"github.com/osmosis-labs/osmosis/v15/x/poolmanager/types"
+	"testing"
 
 	"github.com/stretchr/testify/suite"
 
diff --git a/x/poolmanager/client/cli/tx_test.go b/x/poolmanager/client/cli/tx_test.go
index 9a4997574..bbc8684ad 100644
--- a/x/poolmanager/client/cli/tx_test.go
+++ b/x/poolmanager/client/cli/tx_test.go
@@ -61,6 +61,7 @@ func TestParseCoinsNoSort(t *testing.T) {
 
 	for name, tc := range tests {
 		t.Run(name, func(t *testing.T) {
+
 			coins, err := cli.ParseCoinsNoSort(tc.coinsStr)
 
 			require.NoError(t, err)
diff --git a/x/poolmanager/client/testutil/test_helpers.go b/x/poolmanager/client/testutil/test_helpers.go
index b583cd926..16978f552 100644
--- a/x/poolmanager/client/testutil/test_helpers.go
+++ b/x/poolmanager/client/testutil/test_helpers.go
@@ -36,7 +36,6 @@ func MsgCreatePool(
 	futureGovernor string,
 	extraArgs ...string,
 ) (testutil.BufferWriter, error) {
-	t.Helper()
 	args := []string{}
 
 	jsonFile := testutil.WriteToNewTempFile(t,
diff --git a/x/poolmanager/create_pool_test.go b/x/poolmanager/create_pool_test.go
index 1208e9ec4..8f33ad3b1 100644
--- a/x/poolmanager/create_pool_test.go
+++ b/x/poolmanager/create_pool_test.go
@@ -116,6 +116,7 @@ func (suite *KeeperTestSuite) TestPoolCreationFee() {
 
 // TestCreatePool tests that all possible pools are created correctly.
 func (suite *KeeperTestSuite) TestCreatePool() {
+
 	var (
 		validBalancerPoolMsg = balancer.NewMsgCreateBalancerPool(suite.TestAccs[0], balancer.NewPoolParams(sdk.ZeroDec(), sdk.ZeroDec(), nil), []balancer.PoolAsset{
 			{
diff --git a/x/poolmanager/export_test.go b/x/poolmanager/export_test.go
index d659850f6..9b0faad18 100644
--- a/x/poolmanager/export_test.go
+++ b/x/poolmanager/export_test.go
@@ -6,15 +6,16 @@ import (
 	"github.com/osmosis-labs/osmosis/v15/x/poolmanager/types"
 )
 
-var IntMaxValue = intMaxValue
+var (
+	IntMaxValue = intMaxValue
+)
 
 func (k Keeper) GetNextPoolIdAndIncrement(ctx sdk.Context) uint64 {
 	return k.getNextPoolIdAndIncrement(ctx)
 }
 
 func (k Keeper) GetOsmoRoutedMultihopTotalSwapFee(ctx sdk.Context, route types.MultihopRoute) (
-	totalPathSwapFee sdk.Dec, sumOfSwapFees sdk.Dec, err error,
-) {
+	totalPathSwapFee sdk.Dec, sumOfSwapFees sdk.Dec, err error) {
 	return k.getOsmoRoutedMultihopTotalSwapFee(ctx, route)
 }
 
diff --git a/x/poolmanager/types/msgs_test.go b/x/poolmanager/types/msgs_test.go
index 184df735b..11fddc0e7 100644
--- a/x/poolmanager/types/msgs_test.go
+++ b/x/poolmanager/types/msgs_test.go
@@ -443,6 +443,7 @@ func TestMsgSplitRouteSwapExactAmountIn(t *testing.T) {
 	for name, tc := range tests {
 		tc := tc
 		t.Run(name, func(t *testing.T) {
+
 			err := tc.msg.ValidateBasic()
 
 			if tc.expectError {
@@ -557,6 +558,7 @@ func TestMsgSplitRouteSwapExactAmountOut(t *testing.T) {
 	for name, tc := range tests {
 		tc := tc
 		t.Run(name, func(t *testing.T) {
+
 			err := tc.msg.ValidateBasic()
 
 			if tc.expectError {
diff --git a/x/poolmanager/types/routes_test.go b/x/poolmanager/types/routes_test.go
index 35fcb2093..66961215e 100644
--- a/x/poolmanager/types/routes_test.go
+++ b/x/poolmanager/types/routes_test.go
@@ -15,15 +15,27 @@ const (
 )
 
 var (
+	defaultPoolInitAmount     = sdk.NewInt(10_000_000_000)
 	twentyFiveBaseUnitsAmount = sdk.NewInt(25_000_000)
 
+	fooCoin   = sdk.NewCoin(foo, defaultPoolInitAmount)
+	barCoin   = sdk.NewCoin(bar, defaultPoolInitAmount)
+	bazCoin   = sdk.NewCoin(baz, defaultPoolInitAmount)
+	uosmoCoin = sdk.NewCoin(uosmo, defaultPoolInitAmount)
+
 	// Note: These are iniialized in such a way as it makes
 	// it easier to reason about the test cases.
+	fooBarCoins    = sdk.NewCoins(fooCoin, barCoin)
 	fooBarPoolId   = uint64(1)
+	fooBazCoins    = sdk.NewCoins(fooCoin, bazCoin)
 	fooBazPoolId   = fooBarPoolId + 1
+	fooUosmoCoins  = sdk.NewCoins(fooCoin, uosmoCoin)
 	fooUosmoPoolId = fooBazPoolId + 1
+	barBazCoins    = sdk.NewCoins(barCoin, bazCoin)
 	barBazPoolId   = fooUosmoPoolId + 1
+	barUosmoCoins  = sdk.NewCoins(barCoin, uosmoCoin)
 	barUosmoPoolId = barBazPoolId + 1
+	bazUosmoCoins  = sdk.NewCoins(bazCoin, uosmoCoin)
 	bazUosmoPoolId = barUosmoPoolId + 1
 
 	// Amount in default routes
diff --git a/x/protorev/keeper/developer_fees_test.go b/x/protorev/keeper/developer_fees_test.go
index adaaff1e7..8f2af6cd2 100644
--- a/x/protorev/keeper/developer_fees_test.go
+++ b/x/protorev/keeper/developer_fees_test.go
@@ -131,6 +131,7 @@ func (suite *KeeperTestSuite) TestUpdateDeveloperFees() {
 			profit:      sdk.NewInt(200),
 			alterState: func() {
 				suite.App.ProtoRevKeeper.SetDaysSinceModuleGenesis(suite.Ctx, 731)
+
 			},
 			expected: sdk.NewCoin(types.OsmosisDenomination, sdk.NewInt(10)),
 		},
@@ -140,6 +141,7 @@ func (suite *KeeperTestSuite) TestUpdateDeveloperFees() {
 			profit:      sdk.NewInt(200),
 			alterState: func() {
 				suite.App.ProtoRevKeeper.SetDaysSinceModuleGenesis(suite.Ctx, 365*10+1)
+
 			},
 			expected: sdk.NewCoin(types.OsmosisDenomination, sdk.NewInt(10)),
 		},
diff --git a/x/protorev/keeper/epoch_hook_test.go b/x/protorev/keeper/epoch_hook_test.go
index e7075d3ef..5c3cba341 100644
--- a/x/protorev/keeper/epoch_hook_test.go
+++ b/x/protorev/keeper/epoch_hook_test.go
@@ -3,6 +3,7 @@ package keeper_test
 import (
 	"fmt"
 	"strings"
+
 	"testing"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
diff --git a/x/protorev/keeper/grpc_query_test.go b/x/protorev/keeper/grpc_query_test.go
index 9c8b398df..5dad19b40 100644
--- a/x/protorev/keeper/grpc_query_test.go
+++ b/x/protorev/keeper/grpc_query_test.go
@@ -279,6 +279,7 @@ func (suite *KeeperTestSuite) TestGetProtoRevDeveloperAccount() {
 	res, err = suite.queryClient.GetProtoRevDeveloperAccount(sdk.WrapSDKContext(suite.Ctx), req)
 	suite.Require().NoError(err)
 	suite.Require().Equal(developerAccount.String(), res.DeveloperAccount)
+
 }
 
 // TestGetProtoRevPoolWeights tests the query to retrieve the pool weights
diff --git a/x/protorev/keeper/msg_server_test.go b/x/protorev/keeper/msg_server_test.go
index 19263d927..9d36a56f5 100644
--- a/x/protorev/keeper/msg_server_test.go
+++ b/x/protorev/keeper/msg_server_test.go
@@ -222,6 +222,7 @@ func (suite *KeeperTestSuite) TestMsgSetHotRoutes() {
 			} else {
 				suite.Require().Error(err)
 			}
+
 		})
 	}
 }
diff --git a/x/protorev/keeper/posthandler_test.go b/x/protorev/keeper/posthandler_test.go
index e87643e9e..dc654197e 100644
--- a/x/protorev/keeper/posthandler_test.go
+++ b/x/protorev/keeper/posthandler_test.go
@@ -554,6 +554,7 @@ func (suite *KeeperTestSuite) TestAnteHandle() {
 			} else if strings.Contains(tc.name, "Block Pool Points Limit") {
 				suite.App.ProtoRevKeeper.SetMaxPointsPerBlock(suite.Ctx, 100)
 			}
+
 		})
 	}
 }
@@ -914,6 +915,7 @@ func (suite *KeeperTestSuite) TestExtractSwappedPools() {
 
 	for _, tc := range tests {
 		suite.Run(tc.name, func() {
+
 			suite.Ctx = suite.Ctx.WithIsCheckTx(tc.params.isCheckTx)
 			suite.Ctx = suite.Ctx.WithGasMeter(sdk.NewInfiniteGasMeter())
 			suite.Ctx = suite.Ctx.WithMinGasPrices(tc.params.minGasPrices)
diff --git a/x/protorev/keeper/rebalance_test.go b/x/protorev/keeper/rebalance_test.go
index 47de1af64..6aaa42c1b 100644
--- a/x/protorev/keeper/rebalance_test.go
+++ b/x/protorev/keeper/rebalance_test.go
@@ -23,8 +23,7 @@ var routeTwoAssetSameWeight = poolmanagertypes.SwapAmountInRoutes{
 	poolmanagertypes.SwapAmountInRoute{
 		PoolId:        24,
 		TokenOutDenom: "uosmo",
-	},
-}
+	}}
 
 // Mainnet Arb Route - Multi Asset, Same Weights (Block: 6906570)
 // expectedAmtIn:  sdk.NewInt(4800000),
@@ -41,8 +40,7 @@ var routeMultiAssetSameWeight = poolmanagertypes.SwapAmountInRoutes{
 	poolmanagertypes.SwapAmountInRoute{
 		PoolId:        27,
 		TokenOutDenom: "uosmo",
-	},
-}
+	}}
 
 // Arb Route - Multi Asset, Same Weights - Pool 22 instead of 26 (Block: 6906570)
 // expectedAmtIn:  sdk.NewInt(519700000),
@@ -59,8 +57,7 @@ var routeMostProfitable = poolmanagertypes.SwapAmountInRoutes{
 	poolmanagertypes.SwapAmountInRoute{
 		PoolId:        27,
 		TokenOutDenom: "uosmo",
-	},
-}
+	}}
 
 // Mainnet Arb Route - Multi Asset, Different Weights (Block: 6908256)
 // expectedAmtIn:  sdk.NewInt(4100000),
@@ -77,8 +74,7 @@ var routeDiffDenom = poolmanagertypes.SwapAmountInRoutes{
 	poolmanagertypes.SwapAmountInRoute{
 		PoolId:        33,
 		TokenOutDenom: "Atom",
-	},
-}
+	}}
 
 // No Arbitrage Opportunity
 // expectedAmtIn:  sdk.NewInt(0),
@@ -95,8 +91,7 @@ var routeNoArb = poolmanagertypes.SwapAmountInRoutes{
 	poolmanagertypes.SwapAmountInRoute{
 		PoolId:        8,
 		TokenOutDenom: "uosmo",
-	},
-}
+	}}
 
 // StableSwap Test Route
 // expectedAmtIn:  sdk.NewInt(137600000),
@@ -113,8 +108,7 @@ var routeStableSwap = poolmanagertypes.SwapAmountInRoutes{
 	poolmanagertypes.SwapAmountInRoute{
 		PoolId:        30,
 		TokenOutDenom: "uosmo",
-	},
-}
+	}}
 
 // Four Pool Test Route (Mainnet Block: 1855422)
 // expectedAmtIn:  sdk.NewInt(1_147_000_000)
@@ -177,6 +171,7 @@ var panicRoute = poolmanagertypes.SwapAmountInRoutes{
 }
 
 func (suite *KeeperTestSuite) TestFindMaxProfitRoute() {
+
 	type param struct {
 		route           poolmanagertypes.SwapAmountInRoutes
 		expectedAmtIn   sdk.Int
@@ -324,6 +319,7 @@ func (suite *KeeperTestSuite) TestFindMaxProfitRoute() {
 }
 
 func (suite *KeeperTestSuite) TestExecuteTrade() {
+
 	type param struct {
 		route          poolmanagertypes.SwapAmountInRoutes
 		inputCoin      sdk.Coin
@@ -448,8 +444,7 @@ func (suite *KeeperTestSuite) TestIterateRoutes() {
 		params     paramm
 		expectPass bool
 	}{
-		{
-			name: "Single Route Test",
+		{name: "Single Route Test",
 			params: paramm{
 				routes:                     []poolmanagertypes.SwapAmountInRoutes{routeTwoAssetSameWeight},
 				expectedMaxProfitAmount:    sdk.NewInt(24848),
@@ -459,8 +454,7 @@ func (suite *KeeperTestSuite) TestIterateRoutes() {
 			},
 			expectPass: true,
 		},
-		{
-			name: "Two routes with same arb denom test - more profitable route second",
+		{name: "Two routes with same arb denom test - more profitable route second",
 			params: paramm{
 				routes:                     []poolmanagertypes.SwapAmountInRoutes{routeMultiAssetSameWeight, routeTwoAssetSameWeight},
 				expectedMaxProfitAmount:    sdk.NewInt(24848),
@@ -470,8 +464,7 @@ func (suite *KeeperTestSuite) TestIterateRoutes() {
 			},
 			expectPass: true,
 		},
-		{
-			name: "Three routes with same arb denom test - most profitable route first",
+		{name: "Three routes with same arb denom test - most profitable route first",
 			params: paramm{
 				routes:                     []poolmanagertypes.SwapAmountInRoutes{routeMostProfitable, routeMultiAssetSameWeight, routeTwoAssetSameWeight},
 				expectedMaxProfitAmount:    sdk.NewInt(67511675),
@@ -481,8 +474,7 @@ func (suite *KeeperTestSuite) TestIterateRoutes() {
 			},
 			expectPass: true,
 		},
-		{
-			name: "Two routes, different arb denoms test - more profitable route second",
+		{name: "Two routes, different arb denoms test - more profitable route second",
 			params: paramm{
 				routes:                     []poolmanagertypes.SwapAmountInRoutes{routeNoArb, routeDiffDenom},
 				expectedMaxProfitAmount:    sdk.NewInt(4880),
@@ -492,8 +484,7 @@ func (suite *KeeperTestSuite) TestIterateRoutes() {
 			},
 			expectPass: true,
 		},
-		{
-			name: "Four-pool route test",
+		{name: "Four-pool route test",
 			params: paramm{
 				routes:                     []poolmanagertypes.SwapAmountInRoutes{fourPoolRoute},
 				expectedMaxProfitAmount:    sdk.NewInt(13_202_729),
@@ -503,8 +494,7 @@ func (suite *KeeperTestSuite) TestIterateRoutes() {
 			},
 			expectPass: true,
 		},
-		{
-			name: "Two-pool route test",
+		{name: "Two-pool route test",
 			params: paramm{
 				routes:                     []poolmanagertypes.SwapAmountInRoutes{twoPoolRoute},
 				expectedMaxProfitAmount:    sdk.NewInt(198_653_535),
@@ -553,8 +543,7 @@ func (suite *KeeperTestSuite) TestConvertProfits() {
 		param      param
 		expectPass bool
 	}{
-		{
-			name: "Convert atom to uosmo",
+		{name: "Convert atom to uosmo",
 			param: param{
 				inputCoin:           sdk.NewCoin("Atom", sdk.NewInt(100)),
 				profit:              sdk.NewInt(10),
@@ -562,8 +551,7 @@ func (suite *KeeperTestSuite) TestConvertProfits() {
 			},
 			expectPass: true,
 		},
-		{
-			name: "Convert juno to uosmo (random denom)",
+		{name: "Convert juno to uosmo (random denom)",
 			param: param{
 				inputCoin:           sdk.NewCoin("juno", sdk.NewInt(100)),
 				profit:              sdk.NewInt(10),
@@ -571,8 +559,7 @@ func (suite *KeeperTestSuite) TestConvertProfits() {
 			},
 			expectPass: true,
 		},
-		{
-			name: "Convert denom without pool to uosmo",
+		{name: "Convert denom without pool to uosmo",
 			param: param{
 				inputCoin:           sdk.NewCoin("random", sdk.NewInt(100)),
 				profit:              sdk.NewInt(10),
diff --git a/x/protorev/keeper/routes_test.go b/x/protorev/keeper/routes_test.go
index edaca6993..53df0bf75 100644
--- a/x/protorev/keeper/routes_test.go
+++ b/x/protorev/keeper/routes_test.go
@@ -361,6 +361,7 @@ func (suite *KeeperTestSuite) TestCalculateRoutePoolPoints() {
 			} else {
 				suite.Require().Error(err)
 			}
+
 		})
 	}
 }
diff --git a/x/superfluid/keeper/concentrated_liquidity_test.go b/x/superfluid/keeper/concentrated_liquidity_test.go
index 9fc7f8b54..7b459bcf6 100644
--- a/x/superfluid/keeper/concentrated_liquidity_test.go
+++ b/x/superfluid/keeper/concentrated_liquidity_test.go
@@ -221,6 +221,7 @@ func (suite *KeeperTestSuite) TestAddToConcentratedLiquiditySuperfluidPosition()
 			delegationAmt, found := stakingKeeper.GetDelegation(ctx, newIntermediaryAcc, valAddr)
 			suite.Require().True(found)
 			suite.Require().Equal(expectedDelegationAmt, delegationAmt.Shares.TruncateInt())
+
 		})
 	}
 }
@@ -246,7 +247,7 @@ func (suite *KeeperTestSuite) SetupSuperfluidConcentratedPosition(ctx sdk.Contex
 	}
 
 	// Set up a single validator.
-	valAddr = suite.SetupValidator(stakingtypes.Bonded)
+	valAddr = suite.SetupValidator(stakingtypes.BondStatus(stakingtypes.Bonded))
 
 	// Create a cl pool.
 	clPool := suite.PrepareCustomConcentratedPool(poolCreateAcc, defaultPoolAssets[0].Token.Denom, defaultPoolAssets[1].Token.Denom, 1, sdk.ZeroDec())
diff --git a/x/superfluid/keeper/gov/gov_test.go b/x/superfluid/keeper/gov/gov_test.go
index 8a7927bd1..16537db71 100644
--- a/x/superfluid/keeper/gov/gov_test.go
+++ b/x/superfluid/keeper/gov/gov_test.go
@@ -4,8 +4,8 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 
-	"github.com/osmosis-labs/osmosis/v15/app/apptesting"
 	cltypes "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
+	"github.com/osmosis-labs/osmosis/v15/app/apptesting"
 	"github.com/osmosis-labs/osmosis/v15/x/gamm/pool-models/balancer"
 	minttypes "github.com/osmosis-labs/osmosis/v15/x/mint/types"
 	"github.com/osmosis-labs/osmosis/v15/x/superfluid/keeper/gov"
@@ -189,7 +189,9 @@ func (suite *KeeperTestSuite) TestHandleUnpoolWhiteListChange() {
 		testDescription = "test description"
 	)
 
-	basePoolIds := []uint64{1, 2, 3}
+	var (
+		basePoolIds = []uint64{1, 2, 3}
+	)
 
 	tests := map[string]struct {
 		preCreatedPoolCount int
diff --git a/x/superfluid/keeper/grpc_query_test.go b/x/superfluid/keeper/grpc_query_test.go
index 23ddd9bd1..144d164cd 100644
--- a/x/superfluid/keeper/grpc_query_test.go
+++ b/x/superfluid/keeper/grpc_query_test.go
@@ -66,7 +66,6 @@ func (suite *KeeperTestSuite) TestTotalDelegationByValidatorForAsset() {
 		}
 	}
 }
-
 func (suite *KeeperTestSuite) TestGRPCSuperfluidAsset() {
 	suite.SetupTest()
 
diff --git a/x/superfluid/keeper/keeper_test.go b/x/superfluid/keeper/keeper_test.go
index de91f0c33..dafb1ba1e 100644
--- a/x/superfluid/keeper/keeper_test.go
+++ b/x/superfluid/keeper/keeper_test.go
@@ -20,7 +20,9 @@ import (
 	epochtypes "github.com/osmosis-labs/osmosis/x/epochs/types"
 )
 
-var DefaultGammAsset = "gamm/pool/1"
+var (
+	DefaultGammAsset = "gamm/pool/1"
+)
 
 type KeeperTestSuite struct {
 	apptesting.KeeperTestHelper
diff --git a/x/superfluid/keeper/migrate_test.go b/x/superfluid/keeper/migrate_test.go
index 035b2a4f8..153d7adf9 100644
--- a/x/superfluid/keeper/migrate_test.go
+++ b/x/superfluid/keeper/migrate_test.go
@@ -27,13 +27,16 @@ import (
 func (suite *KeeperTestSuite) TestRouteLockedBalancerToConcentratedMigration() {
 	defaultJoinTime := suite.Ctx.BlockTime()
 	type sendTest struct {
-		superfluidDelegated      bool
-		superfluidUndelegating   bool
-		unlocking                bool
-		overwriteLockId          bool
-		percentOfSharesToMigrate sdk.Dec
-		minExitCoins             sdk.Coins
-		expectedError            error
+		superfluidDelegated            bool
+		superfluidUndelegating         bool
+		unlocking                      bool
+		overwriteLockId                bool
+		multiAssetLock                 bool
+		clLiquidityLock                bool
+		noInitialConcentratedSpotPrice bool
+		percentOfSharesToMigrate       sdk.Dec
+		minExitCoins                   sdk.Coins
+		expectedError                  error
 	}
 	testCases := map[string]sendTest{
 		"lock that is not superfluid delegated, not unlocking": {
@@ -462,6 +465,7 @@ func (suite *KeeperTestSuite) TestMigrateNonSuperfluidLockBalancerToConcentrated
 	type sendTest struct {
 		unlocking                 bool
 		overwritePreMigrationLock bool
+		overwriteSender           bool
 		overwriteShares           bool
 		overwritePool             bool
 		percentOfSharesToMigrate  sdk.Dec
@@ -571,6 +575,8 @@ func (suite *KeeperTestSuite) TestMigrateNonSuperfluidLockBalancerToConcentrated
 func (suite *KeeperTestSuite) TestValidateSharesToMigrateUnlockAndExitBalancerPool() {
 	defaultJoinTime := suite.Ctx.BlockTime()
 	type sendTest struct {
+		unlocking                 bool
+		overwriteValidatorAddress bool
 		overwritePreMigrationLock bool
 		overwriteShares           bool
 		overwritePool             bool
@@ -730,7 +736,7 @@ func (suite *KeeperTestSuite) SetupMigrationTest(ctx sdk.Context, superfluidDele
 	}
 
 	// Set up a single validator.
-	valAddr = suite.SetupValidator(stakingtypes.Bonded)
+	valAddr = suite.SetupValidator(stakingtypes.BondStatus(stakingtypes.Bonded))
 
 	// Create a balancer pool of "stake" and "foo".
 	msg := balancer.NewMsgCreateBalancerPool(poolCreateAcc, balancer.PoolParams{
diff --git a/x/superfluid/keeper/msg_server_test.go b/x/superfluid/keeper/msg_server_test.go
index 2cf3795da..bb7baeaa7 100644
--- a/x/superfluid/keeper/msg_server_test.go
+++ b/x/superfluid/keeper/msg_server_test.go
@@ -146,6 +146,7 @@ func (suite *KeeperTestSuite) TestMsgCreateFullRangePositionAndSuperfluidDelegat
 		expectedLockId     uint64
 		expectedPositionId uint64
 	}{
+
 		{
 			name:               "happy case",
 			param:              param{},
diff --git a/x/superfluid/keeper/unpool_test.go b/x/superfluid/keeper/unpool_test.go
index 19433dab9..601848da8 100644
--- a/x/superfluid/keeper/unpool_test.go
+++ b/x/superfluid/keeper/unpool_test.go
@@ -14,6 +14,12 @@ import (
 )
 
 var (
+	defaultSwapFee    = sdk.MustNewDecFromStr("0.025")
+	defaultExitFee    = sdk.ZeroDec()
+	defaultPoolParams = balancer.PoolParams{
+		SwapFee: defaultSwapFee,
+		ExitFee: defaultExitFee,
+	}
 	defaultFutureGovernor = ""
 
 	// pool assets
@@ -102,7 +108,7 @@ func (suite *KeeperTestSuite) TestUnpool() {
 			}
 
 			// set up validator
-			valAddr := suite.SetupValidator(stakingtypes.Bonded)
+			valAddr := suite.SetupValidator(stakingtypes.BondStatus(stakingtypes.Bonded))
 
 			// create pool of "stake" and "foo"
 			msg := balancer.NewMsgCreateBalancerPool(poolCreateAcc, balancer.PoolParams{
diff --git a/x/superfluid/types/msg_test.go b/x/superfluid/types/msg_test.go
index 5c87f35f8..0c7f1db72 100644
--- a/x/superfluid/types/msg_test.go
+++ b/x/superfluid/types/msg_test.go
@@ -17,6 +17,11 @@ func TestAuthzMsg(t *testing.T) {
 	addr1 := sdk.AccAddress(pk1.Address()).String()
 	coin := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1))
 
+	const (
+		mockGranter string = "cosmos1abc"
+		mockGrantee string = "cosmos1xyz"
+	)
+
 	testCases := []struct {
 		name string
 		msg  sdk.Msg
diff --git a/x/tokenfactory/keeper/admins_test.go b/x/tokenfactory/keeper/admins_test.go
index 46f1e4297..f638c4765 100644
--- a/x/tokenfactory/keeper/admins_test.go
+++ b/x/tokenfactory/keeper/admins_test.go
@@ -45,6 +45,7 @@ func (suite *KeeperTestSuite) TestAdminMsgs() {
 
 	// Test burning from own account
 	_, err = suite.msgServer.Burn(sdk.WrapSDKContext(suite.Ctx), types.NewMsgBurn(suite.TestAccs[0].String(), sdk.NewInt64Coin(suite.defaultDenom, 5)))
+	addr0bal -= 5
 	suite.Require().NoError(err)
 	suite.Require().True(bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[1], suite.defaultDenom).Amount.Int64() == addr1bal)
 
diff --git a/x/tokenfactory/keeper/before_send_test.go b/x/tokenfactory/keeper/before_send_test.go
index ca018cba2..66a5c7e51 100644
--- a/x/tokenfactory/keeper/before_send_test.go
+++ b/x/tokenfactory/keeper/before_send_test.go
@@ -2,7 +2,7 @@ package keeper_test
 
 import (
 	"fmt"
-	"os"
+	"io/ioutil"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
@@ -90,7 +90,7 @@ func (suite *KeeperTestSuite) TestBeforeSendHook() {
 			suite.SetupTest()
 
 			// upload and instantiate wasm code
-			wasmCode, err := os.ReadFile(tc.wasmFile)
+			wasmCode, err := ioutil.ReadFile(tc.wasmFile)
 			suite.Require().NoError(err, "test: %v", tc.desc)
 			codeID, _, err := suite.contractKeeper.Create(suite.Ctx, suite.TestAccs[0], wasmCode, nil)
 			suite.Require().NoError(err, "test: %v", tc.desc)
diff --git a/x/tokenfactory/types/msgs_test.go b/x/tokenfactory/types/msgs_test.go
index d5f1497ac..43ccec6e1 100644
--- a/x/tokenfactory/types/msgs_test.go
+++ b/x/tokenfactory/types/msgs_test.go
@@ -20,6 +20,11 @@ func TestAuthzMsg(t *testing.T) {
 	addr1 := sdk.AccAddress(pk1.Address()).String()
 	coin := sdk.NewCoin("denom", sdk.NewInt(1))
 
+	const (
+		mockGranter string = "cosmos1abc"
+		mockGrantee string = "cosmos1xyz"
+	)
+
 	testCases := []struct {
 		name string
 		msg  sdk.Msg
diff --git a/x/twap/api_test.go b/x/twap/api_test.go
index 14118312a..e93bade2b 100644
--- a/x/twap/api_test.go
+++ b/x/twap/api_test.go
@@ -20,7 +20,7 @@ var (
 	// base asset as the lexicographically smaller denom and the quote as the larger. When
 	// set to false, this order is switched. These constants are provided to understand the
 	// base/quote asset for every test at a glance rather than a raw boolean value.
-	baseQuoteAB, baseQuoteCA              = true, true
+	baseQuoteAB, baseQuoteCA, baseQuoteBC = true, true, true
 	baseQuoteBA, baseQuoteAC, baseQuoteCB = false, false, false
 
 	ThreePlusOneThird sdk.Dec = sdk.MustNewDecFromStr("3.333333333333333333")
@@ -850,6 +850,14 @@ func (s *TestSuite) TestGeometricTwapToNow_BalancerPool_Randomized() {
 	r := rand.New(rand.NewSource(seed))
 	retries := 200
 
+	type randTestCase struct {
+		elapsedTimeMs int
+		weightA       sdk.Int
+		tokenASupply  sdk.Int
+		weightB       sdk.Int
+		tokenBSupply  sdk.Int
+	}
+
 	maxUint64 := ^uint(0)
 
 	for i := 0; i < retries; i++ {
diff --git a/x/twap/client/query_proto_wrap_test.go b/x/twap/client/query_proto_wrap_test.go
index f19b9ec57..5ca6a48e9 100644
--- a/x/twap/client/query_proto_wrap_test.go
+++ b/x/twap/client/query_proto_wrap_test.go
@@ -9,12 +9,15 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/osmosis-labs/osmosis/v15/app/apptesting"
+	"github.com/osmosis-labs/osmosis/v15/x/gamm/types"
 	"github.com/osmosis-labs/osmosis/v15/x/twap/client"
 	"github.com/osmosis-labs/osmosis/v15/x/twap/client/queryproto"
 )
 
 type QueryTestSuite struct {
 	apptesting.KeeperTestHelper
+
+	queryClient types.QueryClient
 }
 
 func TestKeeperTestSuite(t *testing.T) {
diff --git a/x/twap/listeners_test.go b/x/twap/listeners_test.go
index 28f5bd1b3..b922b1763 100644
--- a/x/twap/listeners_test.go
+++ b/x/twap/listeners_test.go
@@ -13,7 +13,14 @@ import (
 	poolmanagertypes "github.com/osmosis-labs/osmosis/v15/x/poolmanager/types"
 )
 
-var defaultPoolId uint64 = 1
+var (
+	defaultPoolId       uint64 = 1
+	noErrorTime                = time.Time{}
+	withZeroLastErrTime        = func(record types.TwapRecord) types.TwapRecord {
+		record.LastErrorTime = time.Time{}
+		return record
+	}
+)
 
 // TestAfterPoolCreatedHook tests if internal tracking logic has been triggered correctly,
 // and the correct state entries have been created upon pool creation.
diff --git a/x/twap/logic_test.go b/x/twap/logic_test.go
index 0f1db4cb2..a9db3c9eb 100644
--- a/x/twap/logic_test.go
+++ b/x/twap/logic_test.go
@@ -641,6 +641,7 @@ func (s *TestSuite) TestPruneRecords() {
 // older records or set to current block time in case error occurred.
 func (s *TestSuite) TestUpdateRecords() {
 	type spOverride struct {
+		poolId      uint64
 		baseDenom   string
 		quoteDenom  string
 		overrideSp  sdk.Dec
diff --git a/x/twap/strategy_test.go b/x/twap/strategy_test.go
index 55c106c0e..f15b37f5b 100644
--- a/x/twap/strategy_test.go
+++ b/x/twap/strategy_test.go
@@ -298,6 +298,7 @@ func (s *TestSuite) TestComputeGeometricStrategyTwap() {
 		tc := tc
 		s.Run(name, func() {
 			osmoassert.ConditionalPanic(s.T(), tc.expPanic, func() {
+
 				geometricStrategy := &twap.GeometricTwapStrategy{TwapKeeper: *s.App.TwapKeeper}
 				actualTwap := geometricStrategy.ComputeTwap(tc.startRecord, tc.endRecord, tc.quoteAsset)
 
diff --git a/x/txfees/keeper/keeper_test.go b/x/txfees/keeper/keeper_test.go
index 762c8440d..8df6eb461 100644
--- a/x/txfees/keeper/keeper_test.go
+++ b/x/txfees/keeper/keeper_test.go
@@ -34,7 +34,7 @@ func (suite *KeeperTestSuite) SetupTest(isCheckTx bool) {
 		WithInterfaceRegistry(encodingConfig.InterfaceRegistry).
 		WithTxConfig(encodingConfig.TxConfig).
 		WithLegacyAmino(encodingConfig.Amino).
-		WithCodec(encodingConfig.Marshaler)
+		WithJSONCodec(encodingConfig.Marshaler)
 
 	// Mint some assets to the accounts.
 	for _, acc := range suite.TestAccs {
diff --git a/x/valset-pref/msg_server_test.go b/x/valset-pref/msg_server_test.go
index fc76a8469..fae31b98b 100644
--- a/x/valset-pref/msg_server_test.go
+++ b/x/valset-pref/msg_server_test.go
@@ -220,7 +220,7 @@ func (suite *KeeperTestSuite) TestDelegateToValidatorSet() {
 		{
 			name:             "Delegate very small amount to existing valSet",
 			delegator:        sdk.AccAddress([]byte("addr4---------------")),
-			amountToDelegate: sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(0o10_013)), // small case
+			amountToDelegate: sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(010_013)), // small case
 			expectedShares:   []sdk.Dec{sdk.NewDec(821), sdk.NewDec(1355), sdk.NewDec(492), sdk.NewDec(1439)},
 			setValSet:        true,
 			expectPass:       true,
diff --git a/x/valset-pref/types/msgs_test.go b/x/valset-pref/types/msgs_test.go
index 4ce0eec9d..6b9d3c6d2 100644
--- a/x/valset-pref/types/msgs_test.go
+++ b/x/valset-pref/types/msgs_test.go
@@ -153,4 +153,5 @@ func TestMsgSetValidatorSetPreference(t *testing.T) {
 			}
 		})
 	}
+
 }
diff --git a/x/valset-pref/validator_set_test.go b/x/valset-pref/validator_set_test.go
index eecdc7e21..01bcb7803 100644
--- a/x/valset-pref/validator_set_test.go
+++ b/x/valset-pref/validator_set_test.go
@@ -7,6 +7,7 @@ import (
 )
 
 func (suite *KeeperTestSuite) TestValidateLockForForceUnlock() {
+
 	locks := suite.SetupLocks(sdk.AccAddress([]byte("addr1---------------")))
 
 	tests := []struct {
@@ -210,6 +211,7 @@ func (suite *KeeperTestSuite) TestIsValidatorSetEqual() {
 			suite.Require().Equal(test.expectEqual, isEqual)
 		})
 	}
+
 }
 
 func (suite *KeeperTestSuite) TestIsPreferenceValid() {