chore(lint): fix all linter issues; add return check; re-enable in CI

.github/workflows/lint.yml

@@ -17,21 +17,21 @@ jobs:
       -
         name: Check out repository code
         uses: actions/checkout@v3
+      -
+        uses: technote-space/get-diff-action@v6.1.2
+        with:
+            PATTERNS: |
+             **/**.go
+             go.mod
+             go.sum
+             .github/**
+             Makefile
       -
         name: 🐿 Setup Golang
         uses: actions/setup-go@v4
         with:
           go-version: ${{env.GO_VERSION}}
-      -
-        uses: technote-space/get-diff-action@v6.1.2
-        if: env.GIT_DIFF
-        with:
-          PATTERNS: |
-            **/**.go
-            go.mod
-            go.sum
-            .github/**
-            Makefile
+
       -
         name: Run golangci-lint
         if: env.GIT_DIFF

.golangci.yml

@@ -9,7 +9,6 @@ linters:
   enable:
     - asciicheck
     - bidichk
-    - depguard
     - durationcheck
     - errcheck
     - errname
@@ -41,6 +40,16 @@ linters:
     - unused
     - whitespace
     - unparam
+    - revive
+
+linters-settings:
+  revive:
+    rules:
+      - name: function-result-limit
+        severity: warning
+        disabled: false
+        # limits the number of returns to 4
+        arguments: [4]
 
 issues:
   exclude-rules:

app/upgrades/v17/upgrades.go

@@ -26,6 +26,14 @@ import (
 	poolmanagertypes "github.com/osmosis-labs/osmosis/v19/x/poolmanager/types"
 )
 
+// clPoolCreationInfo encapsulates the returns from CL pool
+// creation function.
+type clPoolCreationInfo struct {
+	id            uint64
+	denom         string
+	migrationLink gammmigration.BalancerToConcentratedPoolLink
+}
+
 const (
 	mainnetChainID = "osmosis-1"
 	e2eChainA      = "osmo-test-a"
@@ -82,26 +90,26 @@ func CreateUpgradeHandler(
 		fullRangeCoinsUsed := sdk.Coins{}
 
 		for _, assetPair := range assetPairs {
-			clPoolDenom, clPoolId, poolLink, coinsUsed, err := createCLPoolWithCommunityPoolPosition(ctx, keepers, assetPair, communityPoolAddress)
+			clPoolCreationInfo, coinsUsed, err := createCLPoolWithCommunityPoolPosition(ctx, keepers, assetPair, communityPoolAddress)
 			if errors.Is(err, notEnoughLiquidityForSwapErr) {
 				continue
 			} else if err != nil {
 				return nil, err
 			}
 
 			// Track pool link created and coins used for the community pool.
-			poolLinks = append(poolLinks, poolLink)
+			poolLinks = append(poolLinks, clPoolCreationInfo.migrationLink)
 			fullRangeCoinsUsed = fullRangeCoinsUsed.Add(coinsUsed...)
 
 			if assetPair.Superfluid {
-				ctx.Logger().Info(fmt.Sprintf("gammPoolId %d is superfluid enabled, enabling %s as a superfluid asset", assetPair.LinkedClassicPool, clPoolDenom))
-				err := authorizeSuperfluid(ctx, keepers, clPoolDenom)
+				ctx.Logger().Info(fmt.Sprintf("gammPoolId %d is superfluid enabled, enabling %s as a superfluid asset", assetPair.LinkedClassicPool, clPoolCreationInfo.denom))
+				err := authorizeSuperfluid(ctx, keepers, clPoolCreationInfo.denom)
 				if err != nil {
 					return nil, err
 				}
 			}
 
-			err = manuallySetTWAPRecords(ctx, keepers, clPoolId)
+			err = manuallySetTWAPRecords(ctx, keepers, clPoolCreationInfo.id)
 			if err != nil {
 				return nil, err
 			}
@@ -138,7 +146,7 @@ func CreateUpgradeHandler(
 }
 
 // createCLPoolWithCommunityPoolPosition creates a CL pool for a given balancer pool and adds a full range position with the community pool.
-func createCLPoolWithCommunityPoolPosition(ctx sdk.Context, keepers *keepers.AppKeepers, assetPair AssetPair, communityPoolAddress sdk.AccAddress) (clPoolDenom string, clPoolId uint64, poolLink gammmigration.BalancerToConcentratedPoolLink, coinsUsed sdk.Coins, err error) {
+func createCLPoolWithCommunityPoolPosition(ctx sdk.Context, keepers *keepers.AppKeepers, assetPair AssetPair, communityPoolAddress sdk.AccAddress) (clPoolCreationInfo, sdk.Coins, error) {
 	// Determine if base or quote asset is OSMO and save the non-OSMO asset.
 	osmoIn := sdk.NewCoin(OSMO, sdk.NewInt(100000))
 	nonOsmoAsset := ""
@@ -152,24 +160,24 @@ func createCLPoolWithCommunityPoolPosition(ctx sdk.Context, keepers *keepers.App
 	// If not, skip the pool.
 	linkedClassicPool, err := keepers.PoolManagerKeeper.GetPool(ctx, assetPair.LinkedClassicPool)
 	if err != nil {
-		return "", 0, gammmigration.BalancerToConcentratedPoolLink{}, nil, err
+		return clPoolCreationInfo{}, sdk.Coins{}, err
 	}
 	_, err = keepers.GAMMKeeper.CalcOutAmtGivenIn(ctx, linkedClassicPool, osmoIn, nonOsmoAsset, assetPair.SpreadFactor)
 	if err != nil {
-		return "", 0, gammmigration.BalancerToConcentratedPoolLink{}, nil, err
+		return clPoolCreationInfo{}, sdk.Coins{}, err
 	}
 
 	// Create a concentrated liquidity pool for asset pair.
 	ctx.Logger().Info(fmt.Sprintf("Creating CL pool from poolID (%d), baseAsset (%s), quoteAsset (%s) spreadFactor (%s), tickSpacing (%d)", assetPair.LinkedClassicPool, assetPair.BaseAsset, assetPair.QuoteAsset, assetPair.SpreadFactor, TickSpacing))
 	clPool, err := keepers.GAMMKeeper.CreateConcentratedPoolFromCFMM(ctx, assetPair.LinkedClassicPool, assetPair.BaseAsset, assetPair.SpreadFactor, TickSpacing)
 	if err != nil {
-		return "", 0, gammmigration.BalancerToConcentratedPoolLink{}, nil, err
+		return clPoolCreationInfo{}, sdk.Coins{}, err
 	}
-	clPoolId = clPool.GetId()
-	clPoolDenom = cltypes.GetConcentratedLockupDenomFromPoolId(clPoolId)
+	clPoolId := clPool.GetId()
+	clPoolDenom := cltypes.GetConcentratedLockupDenomFromPoolId(clPoolId)
 
 	// Create pool link object.
-	poolLink = gammmigration.BalancerToConcentratedPoolLink{
+	poolLink := gammmigration.BalancerToConcentratedPoolLink{
 		BalancerPoolId: assetPair.LinkedClassicPool,
 		ClPoolId:       clPoolId,
 	}
@@ -182,7 +190,7 @@ func createCLPoolWithCommunityPoolPosition(ctx sdk.Context, keepers *keepers.App
 	// Swap 0.1 OSMO for nonOsmoAsset from the community pool.
 	respectiveNonOsmoAssetInt, err := keepers.GAMMKeeper.SwapExactAmountIn(ctx, communityPoolAddress, linkedClassicPool, osmoIn, nonOsmoAsset, sdk.ZeroInt(), linkedClassicPool.GetSpreadFactor(ctx))
 	if err != nil {
-		return "", 0, gammmigration.BalancerToConcentratedPoolLink{}, nil, err
+		return clPoolCreationInfo{}, sdk.Coins{}, err
 	}
 	ctx.Logger().Info(fmt.Sprintf("Swapped %s for %s%s from the community pool", osmoIn.String(), respectiveNonOsmoAssetInt.String(), nonOsmoAsset))
 
@@ -192,7 +200,7 @@ func createCLPoolWithCommunityPoolPosition(ctx sdk.Context, keepers *keepers.App
 	fullRangeCoins := sdk.NewCoins(respectiveNonOsmoAsset, osmoIn)
 	_, err = keepers.ConcentratedLiquidityKeeper.CreateFullRangePosition(ctx, clPoolId, communityPoolAddress, fullRangeCoins)
 	if err != nil {
-		return "", 0, gammmigration.BalancerToConcentratedPoolLink{}, nil, err
+		return clPoolCreationInfo{}, sdk.Coins{}, err
 	}
 
 	// Get community pool balance after swap and position creation
@@ -203,9 +211,13 @@ func createCLPoolWithCommunityPoolPosition(ctx sdk.Context, keepers *keepers.App
 	// While we can be fairly certain the diff between these two is 0.2 OSMO, if for whatever reason
 	// some baseAsset dust remains in the community pool and we don't account for it, when updating the
 	// fee pool balance later, we will be off by that amount and will cause a panic.
-	coinsUsed = commPoolBalancePre.Sub(commPoolBalancePost)
+	coinsUsed := commPoolBalancePre.Sub(commPoolBalancePost)
 
-	return clPoolDenom, clPoolId, poolLink, coinsUsed, nil
+	return clPoolCreationInfo{
+		id:            clPoolId,
+		denom:         clPoolDenom,
+		migrationLink: poolLink,
+	}, coinsUsed, nil
 }
 
 // authorizeSuperfluid authorizes superfluid for the provided CL pool.

tests/e2e/configurer/chain/queries.go

@@ -32,6 +32,14 @@ import (
 	epochstypes "github.com/osmosis-labs/osmosis/x/epochs/types"
 )
 
+// PropTallyResult is the result of a proposal tally.
+type PropTallyResult struct {
+	Yes        sdk.Int
+	No         sdk.Int
+	Abstain    sdk.Int
+	NoWithVeto sdk.Int
+}
+
 // QueryProtoRevNumberOfTrades gets the number of trades the protorev module has executed.
 func (n *NodeConfig) QueryProtoRevNumberOfTrades() (sdk.Int, error) {
 	path := "/osmosis/protorev/number_of_trades"
@@ -443,21 +451,31 @@ func (n *NodeConfig) QueryWasmSmartArray(contract string, msg string) (resultArr
 	return resultArray, nil
 }
 
-func (n *NodeConfig) QueryPropTally(proposalNumber int) (sdk.Int, sdk.Int, sdk.Int, sdk.Int, error) {
+func (n *NodeConfig) QueryPropTally(proposalNumber int) (PropTallyResult, error) {
 	path := fmt.Sprintf("cosmos/gov/v1beta1/proposals/%d/tally", proposalNumber)
 	bz, err := n.QueryGRPCGateway(path)
 	require.NoError(n.t, err)
 
 	var balancesResp govtypes.QueryTallyResultResponse
 	if err := util.Cdc.UnmarshalJSON(bz, &balancesResp); err != nil {
-		return sdk.ZeroInt(), sdk.ZeroInt(), sdk.ZeroInt(), sdk.ZeroInt(), err
+		return PropTallyResult{
+			Yes:        sdk.ZeroInt(),
+			No:         sdk.ZeroInt(),
+			Abstain:    sdk.ZeroInt(),
+			NoWithVeto: sdk.ZeroInt(),
+		}, err
 	}
 	noTotal := balancesResp.Tally.No
 	yesTotal := balancesResp.Tally.Yes
 	noWithVetoTotal := balancesResp.Tally.NoWithVeto
 	abstainTotal := balancesResp.Tally.Abstain
 
-	return noTotal, yesTotal, noWithVetoTotal, abstainTotal, nil
+	return PropTallyResult{
+		Yes:        yesTotal,
+		No:         noTotal,
+		Abstain:    abstainTotal,
+		NoWithVeto: noWithVetoTotal,
+	}, nil
 }
 
 func (n *NodeConfig) QueryPropStatus(proposalNumber int) (string, error) {

tests/e2e/e2e_test.go

@@ -1038,11 +1038,11 @@ func (s *IntegrationTestSuite) SuperfluidVoting() {
 
 	s.Eventually(
 		func() bool {
-			noTotal, yesTotal, noWithVetoTotal, abstainTotal, err := chainABNode.QueryPropTally(propNumber)
+			propTally, err := chainABNode.QueryPropTally(propNumber)
 			if err != nil {
 				return false
 			}
-			if abstainTotal.Int64()+noTotal.Int64()+noWithVetoTotal.Int64()+yesTotal.Int64() <= 0 {
+			if propTally.Abstain.Int64()+propTally.No.Int64()+propTally.NoWithVeto.Int64()+propTally.Yes.Int64() <= 0 {
 				return false
 			}
 			return true
@@ -1051,8 +1051,9 @@ func (s *IntegrationTestSuite) SuperfluidVoting() {
 		10*time.Millisecond,
 		"Osmosis node failed to retrieve prop tally",
 	)
-	noTotal, _, _, _, _ := chainABNode.QueryPropTally(propNumber)
-	noTotalFinal, err := strconv.Atoi(noTotal.String())
+	propTally, err := chainABNode.QueryPropTally(propNumber)
+	s.Require().NoError(err)
+	noTotalFinal, err := strconv.Atoi(propTally.No.String())
 	s.NoError(err)
 
 	s.Eventually(

x/concentrated-liquidity/export_test.go

@@ -72,7 +72,7 @@ func (k Keeper) ComputeOutAmtGivenIn(
 	spreadFactor sdk.Dec,
 	priceLimit sdk.Dec,
 
-) (calcTokenIn, calcTokenOut sdk.Coin, poolUpdates PoolUpdates, totalSpreadRewards sdk.Dec, err error) {
+) (swapResult SwapResult, poolUpdates PoolUpdates, err error) {
 	return k.computeOutAmtGivenIn(ctx, poolId, tokenInMin, tokenOutDenom, spreadFactor, priceLimit)
 }
 
@@ -95,7 +95,7 @@ func (k Keeper) ComputeInAmtGivenOut(
 	priceLimit sdk.Dec,
 	poolId uint64,
 
-) (calcTokenIn, calcTokenOut sdk.Coin, poolUpdates PoolUpdates, totalSpreadRewards sdk.Dec, err error) {
+) (swapResult SwapResult, poolUpdates PoolUpdates, err error) {
 	return k.computeInAmtGivenOut(ctx, desiredTokenOut, tokenInDenom, spreadFactor, priceLimit, poolId)
 }
 

x/concentrated-liquidity/math/precompute.go

@@ -9,7 +9,6 @@ import (
 
 var (
 	sdkOneDec      = sdk.OneDec()
-	sdkNineDec     = sdk.NewDec(9)
 	sdkTenDec      = sdk.NewDec(10)
 	powersOfTen    []sdk.Dec
 	negPowersOfTen []sdk.Dec