Repository: osmosis-labs/osmosis
Pull request #3760 (2022-12-16 16:35:57)

[CI] Fix state compatibility check CI (backport #3750)
This is an automatic backport of pull request #3750 done by [Mergify](https://mergify.com).


---


<details>
<summary>Mergify commands and options</summary>

<br />

More conditions and actions can be found in the [documentation](https://docs.mergify.com/).

You can also trigger Mergify actions by commenting on this pull request:

- `@Mergifyio refresh` will re-evaluate the rules
- `@Mergifyio rebase` will rebase this PR on its base branch
- `@Mergifyio update` will merge the base branch into this PR
- `@Mergifyio backport <destination>` will backport this PR on `<destination>` branch

Additionally, on Mergify [dashboard](https://dashboard.mergify.com/) you can:

- look at your merge queues
- generate the Mergify configuration with the config editor.

Finally, you can contact us on https://mergify.com
</details>


Patch:
diff --git a/.github/workflows/state-compatibility-check.yml b/.github/workflows/check-state-compatibility.yml
similarity index 97%
rename from .github/workflows/state-compatibility-check.yml
rename to .github/workflows/check-state-compatibility.yml
index 4205fdff0..2f67c8828 100644
--- a/.github/workflows/state-compatibility-check.yml
+++ b/.github/workflows/check-state-compatibility.yml
@@ -82,6 +82,7 @@ jobs:
   check_state_compatibility:
     # DO NOT CHANGE THIS: please read the note above
     if: ${{ github.event.pull_request.head.repo.full_name == 'osmosis-labs/osmosis' && needs.compare_versions.outputs.should_i_run == 'true' }}
+    needs: compare_versions
     runs-on: self-hosted
     steps:
       - 
@@ -93,7 +94,7 @@ jobs:
         name: 🐿 Setup Golang
         uses: actions/setup-go@v3
         with:
-          go-version: '^${{ env.GOLANG_VERSION }}'
+          go-version-file: go.mod
       -
         name: 🔨 Build the osmosisd binary
         run: |
@@ -151,7 +152,7 @@ jobs:
 
             SNAPSHOT_INFO_URL=${{ env.SNAPSHOT_BUCKET }}/v$REPO_MAJOR_VERSION/snapshots.json
             SNAPSHOT_INFO=$(curl -s --retry 5 --retry-delay 5 --connect-timeout 30 -H "Accept: application/json" $SNAPSHOT_INFO_URL)
-            SNAPSHOT_BLOCK_HEIGHT=$(echo $SNAPSHOT_INFO | dasel --plain -r json  '(file=osmosis-1-pre-epoch).height')
+            SNAPSHOT_BLOCK_HEIGHT=$(echo $SNAPSHOT_INFO | jq -r '.[] | select(.type == "pre-epoch").height')
             LAST_EPOCH_BLOCK_HEIGHT=$(($SNAPSHOT_BLOCK_HEIGHT + 100))
           fi
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6283461b9..258a630e7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -67,6 +67,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * Correctly apply DragonBerry IBC patch
 
+### API breaks
+
+* [#3763](https://github.com/osmosis-labs/osmosis/pull/3763) Move binary search and error tolerance code from `osmoutils` into `osmomath`
+
 ### Bug fixes
 
 * [#3608](https://github.com/osmosis-labs/osmosis/pull/3608) Make it possible to state export from any directory.
@@ -77,6 +81,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * [#3634](https://github.com/osmosis-labs/osmosis/pull/3634) (Makefile) Ensure correct golang version in make build and make install. (Thank you @jhernandezb )
 * [#3712](https://github.com/osmosis-labs/osmosis/pull/3712) replace `osmomath.BigDec` `Power` with `PowerInteger` 
 
+
 ## v13.0.0
 
 This release includes stableswap, and expands the IBC safety & composability functionality of Osmosis. The primary features are:
diff --git a/osmoutils/binary_search.go b/osmomath/binary_search.go
similarity index 84%
rename from osmoutils/binary_search.go
rename to osmomath/binary_search.go
index 27ea4b459..53888ce77 100644
--- a/osmoutils/binary_search.go
+++ b/osmomath/binary_search.go
@@ -1,11 +1,9 @@
-package osmoutils
+package osmomath
 
 import (
 	"errors"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-
-	"github.com/osmosis-labs/osmosis/v13/osmomath"
 )
 
 // ErrTolerance is used to define a compare function, which checks if two
@@ -25,7 +23,7 @@ import (
 type ErrTolerance struct {
 	AdditiveTolerance       sdk.Int
 	MultiplicativeTolerance sdk.Dec
-	RoundingDir             osmomath.RoundingDirection
+	RoundingDir             RoundingDirection
 }
 
 // Compare returns if actual is within errTolerance of expected.
@@ -46,11 +44,11 @@ func (e ErrTolerance) Compare(expected sdk.Int, actual sdk.Int) int {
 	// so if were supposed to round down, it must be that `expected >= actual`.
 	// likewise if were supposed to round up, it must be that `expected <= actual`.
 	// If neither of the above, then rounding direction does not enforce a constraint.
-	if e.RoundingDir == osmomath.RoundDown {
+	if e.RoundingDir == RoundDown {
 		if expected.LT(actual) {
 			return -1
 		}
-	} else if e.RoundingDir == osmomath.RoundUp {
+	} else if e.RoundingDir == RoundUp {
 		if expected.GT(actual) {
 			return 1
 		}
@@ -84,16 +82,16 @@ func (e ErrTolerance) Compare(expected sdk.Int, actual sdk.Int) int {
 // returns 0 if it is
 // returns 1 if not, and expected > actual.
 // returns -1 if not, and expected < actual
-func (e ErrTolerance) CompareBigDec(expected osmomath.BigDec, actual osmomath.BigDec) int {
+func (e ErrTolerance) CompareBigDec(expected BigDec, actual BigDec) int {
 	// Ensure that even if expected is within tolerance of actual, we don't count it as equal if its in the wrong direction.
 	// so if were supposed to round down, it must be that `expected >= actual`.
 	// likewise if were supposed to round up, it must be that `expected <= actual`.
 	// If neither of the above, then rounding direction does not enforce a constraint.
-	if e.RoundingDir == osmomath.RoundDown {
+	if e.RoundingDir == RoundDown {
 		if expected.LT(actual) {
 			return -1
 		}
-	} else if e.RoundingDir == osmomath.RoundUp {
+	} else if e.RoundingDir == RoundUp {
 		if expected.GT(actual) {
 			return 1
 		}
@@ -117,15 +115,15 @@ func (e ErrTolerance) CompareBigDec(expected osmomath.BigDec, actual osmomath.Bi
 			}
 		}
 
-		if diff.GT(osmomath.BigDecFromSDKDec(e.AdditiveTolerance.ToDec())) {
+		if diff.GT(BigDecFromSDKDec(e.AdditiveTolerance.ToDec())) {
 			return comparisonSign
 		}
 	}
 	// Check multiplicative tolerance equations
 	if !e.MultiplicativeTolerance.IsNil() && !e.MultiplicativeTolerance.IsZero() {
-		errTerm := diff.Quo(osmomath.MinDec(expected.Abs(), actual.Abs()))
+		errTerm := diff.Quo(MinDec(expected.Abs(), actual.Abs()))
 		// fmt.Printf("err term %v\n", errTerm)
-		if errTerm.GT(osmomath.BigDecFromSDKDec(e.MultiplicativeTolerance)) {
+		if errTerm.GT(BigDecFromSDKDec(e.MultiplicativeTolerance)) {
 			return comparisonSign
 		}
 	}
@@ -184,18 +182,18 @@ type SdkDec[D any] interface {
 //
 // It binary searches on the input range, until it finds an input y s.t. f(y) meets the err tolerance constraints for how close it is to x.
 // If we perform more than maxIterations (or equivalently lowerbound = upperbound), we return an error.
-func BinarySearchBigDec(f func(input osmomath.BigDec) (osmomath.BigDec, error),
-	lowerbound osmomath.BigDec,
-	upperbound osmomath.BigDec,
-	targetOutput osmomath.BigDec,
+func BinarySearchBigDec(f func(input BigDec) (BigDec, error),
+	lowerbound BigDec,
+	upperbound BigDec,
+	targetOutput BigDec,
 	errTolerance ErrTolerance,
 	maxIterations int,
-) (osmomath.BigDec, error) {
+) (BigDec, error) {
 	// Setup base case of loop
-	curEstimate := lowerbound.Add(upperbound).Quo(osmomath.NewBigDec(2))
+	curEstimate := lowerbound.Add(upperbound).Quo(NewBigDec(2))
 	curOutput, err := f(curEstimate)
 	if err != nil {
-		return osmomath.BigDec{}, err
+		return BigDec{}, err
 	}
 	curIteration := 0
 	for ; curIteration < maxIterations; curIteration += 1 {
@@ -208,12 +206,12 @@ func BinarySearchBigDec(f func(input osmomath.BigDec) (osmomath.BigDec, error),
 		} else {
 			return curEstimate, nil
 		}
-		curEstimate = lowerbound.Add(upperbound).Quo(osmomath.NewBigDec(2))
+		curEstimate = lowerbound.Add(upperbound).Quo(NewBigDec(2))
 		curOutput, err = f(curEstimate)
 		if err != nil {
-			return osmomath.BigDec{}, err
+			return BigDec{}, err
 		}
 	}
 
-	return osmomath.BigDec{}, errors.New("hit maximum iterations, did not converge fast enough")
+	return BigDec{}, errors.New("hit maximum iterations, did not converge fast enough")
 }
diff --git a/osmomath/math.go b/osmomath/math.go
index 0e07cac82..18a45f171 100644
--- a/osmomath/math.go
+++ b/osmomath/math.go
@@ -10,10 +10,6 @@ import (
 // TODO: Analyze choice here.
 var powPrecision, _ = sdk.NewDecFromStr("0.00000001")
 
-// Singletons.
-// nolint: deadcode, unused
-var zero sdk.Dec = sdk.ZeroDec()
-
 var (
 	one_half sdk.Dec = sdk.MustNewDecFromStr("0.5")
 	one      sdk.Dec = sdk.OneDec()
diff --git a/x/gamm/pool-models/internal/cfmm_common/lp.go b/x/gamm/pool-models/internal/cfmm_common/lp.go
index e14d24604..667788404 100644
--- a/x/gamm/pool-models/internal/cfmm_common/lp.go
+++ b/x/gamm/pool-models/internal/cfmm_common/lp.go
@@ -7,7 +7,6 @@ import (
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
 	"github.com/osmosis-labs/osmosis/v13/osmomath"
-	"github.com/osmosis-labs/osmosis/v13/osmoutils"
 	"github.com/osmosis-labs/osmosis/v13/x/gamm/types"
 )
 
@@ -155,9 +154,9 @@ func BinarySearchSingleAssetJoin(
 	}
 
 	// We accept an additive tolerance of 1 LP share error and round down
-	errTolerance := osmoutils.ErrTolerance{AdditiveTolerance: sdk.OneInt(), MultiplicativeTolerance: sdk.Dec{}, RoundingDir: osmomath.RoundDown}
+	errTolerance := osmomath.ErrTolerance{AdditiveTolerance: sdk.OneInt(), MultiplicativeTolerance: sdk.Dec{}, RoundingDir: osmomath.RoundDown}
 
-	numLPShares, err = osmoutils.BinarySearch(
+	numLPShares, err = osmomath.BinarySearch(
 		estimateCoinOutGivenShares,
 		LPShareLowerBound, LPShareUpperBound, tokenIn.Amount, errTolerance, maxIterations)
 	if err != nil {
diff --git a/x/gamm/pool-models/stableswap/amm.go b/x/gamm/pool-models/stableswap/amm.go
index 9574db6fc..a953ba977 100644
--- a/x/gamm/pool-models/stableswap/amm.go
+++ b/x/gamm/pool-models/stableswap/amm.go
@@ -6,7 +6,6 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/osmosis-labs/osmosis/v13/osmomath"
-	"github.com/osmosis-labs/osmosis/v13/osmoutils"
 	"github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/internal/cfmm_common"
 	types "github.com/osmosis-labs/osmosis/v13/x/gamm/types"
 )
@@ -327,7 +326,7 @@ func solveCFMMBinarySearchMulti(xReserve, yReserve, wSumSquares, yIn osmomath.Bi
 	maxIterations := 256
 
 	// we use a geometric error tolerance that guarantees approximately 10^-12 precision on outputs
-	errTolerance := osmoutils.ErrTolerance{AdditiveTolerance: sdk.Int{}, MultiplicativeTolerance: sdk.NewDecWithPrec(1, 12)}
+	errTolerance := osmomath.ErrTolerance{AdditiveTolerance: sdk.Int{}, MultiplicativeTolerance: sdk.NewDecWithPrec(1, 12)}
 
 	// if yIn is positive, we want to under-estimate the amount of xOut.
 	// This means, we want x_out to be rounded down, as x_out = x_init - x_final, for x_init > x_final.
@@ -340,7 +339,7 @@ func solveCFMMBinarySearchMulti(xReserve, yReserve, wSumSquares, yIn osmomath.Bi
 	roundingDirection := osmomath.RoundUp
 	errTolerance.RoundingDir = roundingDirection
 
-	xEst, err := osmoutils.BinarySearchBigDec(iterKCalc, xLowEst, xHighEst, targetK, errTolerance, maxIterations)
+	xEst, err := osmomath.BinarySearchBigDec(iterKCalc, xLowEst, xHighEst, targetK, errTolerance, maxIterations)
 	if err != nil {
 		panic(err)
 	}
diff --git a/x/gamm/types/constants.go b/x/gamm/types/constants.go
index 5b6fd7962..e7f3694ef 100644
--- a/x/gamm/types/constants.go
+++ b/x/gamm/types/constants.go
@@ -33,6 +33,9 @@ var (
 	// SpotPriceSigFigs is the amount of significant figures used in return value of calculate SpotPrice
 	SpotPriceSigFigs = sdk.NewDec(10).Power(SigFigsExponent).TruncateInt()
 	// MaxSpotPrice is the maximum supported spot price. Anything greater than this will error.
+	// Internal note: Ctrl+F for MaxSpotPrice in code if ever changed.
+	// Other tests depend on being equal to MaxSpotPrice,
+	// but don't directly import it due to import issues.
 	MaxSpotPrice = sdk.NewDec(2).Power(128).Sub(sdk.OneDec())
 
 	// MultihopSwapFeeMultiplierForOsmoPools if a swap fees multiplier for trades consists of just two OSMO pools during a single transaction.
diff --git a/x/tokenfactory/client/cli/query.go b/x/tokenfactory/client/cli/query.go
index dd7f8b524..a03f784d9 100644
--- a/x/tokenfactory/client/cli/query.go
+++ b/x/tokenfactory/client/cli/query.go
@@ -17,28 +17,31 @@ import (
 func GetQueryCmd() *cobra.Command {
 	cmd := osmocli.QueryIndexCmd(types.ModuleName)
 
+	osmocli.AddQueryCmd(cmd, types.NewQueryClient, GetCmdDenomAuthorityMetadata)
+	osmocli.AddQueryCmd(cmd, types.NewQueryClient, GetCmdDenomAuthorityMetadata)
+
 	cmd.AddCommand(
 		osmocli.GetParams[*types.QueryParamsRequest](
 			types.ModuleName, types.NewQueryClient),
-		GetCmdDenomAuthorityMetadata(),
-		GetCmdDenomsFromCreator(),
 	)
 
 	return cmd
 }
 
-func GetCmdDenomAuthorityMetadata() *cobra.Command {
-	return osmocli.SimpleQueryCmd[*types.QueryDenomAuthorityMetadataRequest](
-		"denom-authority-metadata [denom] [flags]",
-		"Get the authority metadata for a specific denom", "",
-		types.ModuleName, types.NewQueryClient,
-	)
+func GetCmdDenomAuthorityMetadata() (*osmocli.QueryDescriptor, *types.QueryDenomAuthorityMetadataRequest) {
+	return &osmocli.QueryDescriptor{
+		Use:   "denom-authority-metadata [denom] [flags]",
+		Short: "Get the authority metadata for a specific denom",
+		Long: `{{.Short}}{{.ExampleHeader}}
+		{{.CommandPrefix}} uatom`,
+	}, &types.QueryDenomAuthorityMetadataRequest{}
 }
 
-func GetCmdDenomsFromCreator() *cobra.Command {
-	return osmocli.SimpleQueryCmd[*types.QueryDenomsFromCreatorRequest](
-		"denoms-from-creator [creator address] [flags]",
-		"Returns a list of all tokens created by a specific creator address", "",
-		types.ModuleName, types.NewQueryClient,
-	)
+func GetCmdDenomsFromCreator() (*osmocli.QueryDescriptor, *types.QueryDenomsFromCreatorRequest) {
+	return &osmocli.QueryDescriptor{
+		Use:   "denoms-from-creator [creator address] [flags]",
+		Short: "Returns a list of all tokens created by a specific creator address",
+		Long: `{{.Short}}{{.ExampleHeader}}
+		{{.CommandPrefix}} <address>`,
+	}, &types.QueryDenomsFromCreatorRequest{}
 }


Test patch:
diff --git a/osmoutils/binary_search_test.go b/osmomath/binary_search_test.go
similarity index 83%
rename from osmoutils/binary_search_test.go
rename to osmomath/binary_search_test.go
index 5ce7dc027..c46af6789 100644
--- a/osmoutils/binary_search_test.go
+++ b/osmomath/binary_search_test.go
@@ -1,4 +1,4 @@
-package osmoutils
+package osmomath
 
 import (
 	"fmt"
@@ -7,14 +7,12 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/require"
-
-	"github.com/osmosis-labs/osmosis/v13/osmomath"
 )
 
 var (
 	withinOne     = ErrTolerance{AdditiveTolerance: sdk.OneInt()}
 	withinFactor8 = ErrTolerance{MultiplicativeTolerance: sdk.NewDec(8)}
-	zero          = osmomath.ZeroDec()
+	zero          = ZeroDec()
 )
 
 func TestBinarySearch(t *testing.T) {
@@ -78,30 +76,34 @@ func TestBinarySearch(t *testing.T) {
 
 // straight line function that returns input. Simplest to binary search on,
 // binary search directly reveals one bit of the answer in each iteration with this function.
-func lineF(a osmomath.BigDec) (osmomath.BigDec, error) {
+func lineF(a BigDec) (BigDec, error) {
 	return a, nil
 }
-func cubicF(a osmomath.BigDec) (osmomath.BigDec, error) {
+func cubicF(a BigDec) (BigDec, error) {
 	return a.PowerInteger(3), nil
 }
 
-var negCubicFConstant = osmomath.NewBigDec(1 << 62).PowerInteger(3).Neg()
+var negCubicFConstant BigDec
+
+func init() {
+	negCubicFConstant = NewBigDec(1 << 62).PowerInteger(3).Neg()
+}
 
-func negCubicF(a osmomath.BigDec) (osmomath.BigDec, error) {
+func negCubicF(a BigDec) (BigDec, error) {
 	return a.PowerInteger(3).Add(negCubicFConstant), nil
 }
 
-type searchFn func(osmomath.BigDec) (osmomath.BigDec, error)
+type searchFn func(BigDec) (BigDec, error)
 
 type binarySearchTestCase struct {
 	f             searchFn
-	lowerbound    osmomath.BigDec
-	upperbound    osmomath.BigDec
-	targetOutput  osmomath.BigDec
+	lowerbound    BigDec
+	upperbound    BigDec
+	targetOutput  BigDec
 	errTolerance  ErrTolerance
 	maxIterations int
 
-	expectedSolvedInput osmomath.BigDec
+	expectedSolvedInput BigDec
 	expectErr           bool
 	// This binary searches inputs to a monotonic increasing function F
 	// We stop when the answer is within error bounds stated by errTolerance
@@ -117,7 +119,7 @@ type binarySearchTestCase struct {
 func TestBinarySearchLineIterationCounts(t *testing.T) {
 	tests := map[string]binarySearchTestCase{}
 
-	generateExactTestCases := func(lowerbound, upperbound osmomath.BigDec,
+	generateExactTestCases := func(lowerbound, upperbound BigDec,
 		errTolerance ErrTolerance, maxNumIters int) {
 		tcSetName := fmt.Sprintf("simple linear case: lower %s, upper %s", lowerbound.String(), upperbound.String())
 		// first pass get it working with no err tolerance or rounding direction
@@ -142,9 +144,9 @@ func TestBinarySearchLineIterationCounts(t *testing.T) {
 		}
 	}
 
-	generateExactTestCases(osmomath.ZeroDec(), osmomath.NewBigDec(1<<20), withinOne, 20)
+	generateExactTestCases(ZeroDec(), NewBigDec(1<<20), withinOne, 20)
 	// we can go further than 50, if we could specify non-integer additive err tolerance. TODO: Add this.
-	generateExactTestCases(osmomath.NewBigDec(1<<20), osmomath.NewBigDec(1<<50), withinOne, 50)
+	generateExactTestCases(NewBigDec(1<<20), NewBigDec(1<<50), withinOne, 50)
 	runBinarySearchTestCases(t, tests, exactlyEqual)
 }
 
@@ -161,10 +163,10 @@ func TestIterationDepthRandValue(t *testing.T) {
 		errTolerance ErrTolerance, maxNumIters int, errToleranceName string) {
 		targetF := fnMap[fnName]
 		targetX := int64(rand.Intn(int(upperbound-lowerbound-1))) + lowerbound + 1
-		target, _ := targetF(osmomath.NewBigDec(targetX))
+		target, _ := targetF(NewBigDec(targetX))
 		testCase := binarySearchTestCase{
 			f:          lineF,
-			lowerbound: osmomath.NewBigDec(lowerbound), upperbound: osmomath.NewBigDec(upperbound),
+			lowerbound: NewBigDec(lowerbound), upperbound: NewBigDec(upperbound),
 			targetOutput: target, expectedSolvedInput: target,
 			errTolerance:  errTolerance,
 			maxIterations: maxNumIters,
@@ -194,7 +196,7 @@ const (
 	equalWithinOne    equalityMode = iota
 )
 
-func withRoundingDir(e ErrTolerance, r osmomath.RoundingDirection) ErrTolerance {
+func withRoundingDir(e ErrTolerance, r RoundingDirection) ErrTolerance {
 	return ErrTolerance{
 		AdditiveTolerance:       e.AdditiveTolerance,
 		MultiplicativeTolerance: e.MultiplicativeTolerance,
@@ -213,11 +215,11 @@ func runBinarySearchTestCases(t *testing.T, tests map[string]binarySearchTestCas
 			} else {
 				require.NoError(t, err)
 				if equality == exactlyEqual {
-					require.True(osmomath.DecEq(t, tc.expectedSolvedInput, actualSolvedInput))
+					require.True(DecEq(t, tc.expectedSolvedInput, actualSolvedInput))
 				} else if equality == errToleranceEqual {
 					require.True(t, tc.errTolerance.CompareBigDec(tc.expectedSolvedInput, actualSolvedInput) == 0)
 				} else {
-					_, valid, msg, dec1, dec2 := osmomath.DecApproxEq(t, tc.expectedSolvedInput, actualSolvedInput, osmomath.OneDec())
+					_, valid, msg, dec1, dec2 := DecApproxEq(t, tc.expectedSolvedInput, actualSolvedInput, OneDec())
 					require.True(t, valid, msg+" \n d1 = %s, d2 = %s", dec1, dec2,
 						tc.expectedSolvedInput, actualSolvedInput)
 				}
@@ -230,8 +232,8 @@ func TestBinarySearchBigDec(t *testing.T) {
 	testErrToleranceAdditive := ErrTolerance{AdditiveTolerance: sdk.NewInt(1 << 30)}
 	errToleranceBoth := ErrTolerance{AdditiveTolerance: sdk.NewInt(1 << 30), MultiplicativeTolerance: sdk.NewDec(1 << 3)}
 
-	twoTo50 := osmomath.NewBigDec(1 << 50)
-	twoTo25PlusOne := osmomath.NewBigDec(1 + (1 << 25))
+	twoTo50 := NewBigDec(1 << 50)
+	twoTo25PlusOne := NewBigDec(1 + (1 << 25))
 	twoTo25PlusOneCubed := twoTo25PlusOne.PowerInteger(3)
 
 	tests := map[string]binarySearchTestCase{
@@ -245,8 +247,8 @@ func TestBinarySearchBigDec(t *testing.T) {
 		"cubic f, within 2^30, target 2^33 - 2^29": {
 			cubicF,
 			zero, twoTo50,
-			osmomath.NewBigDec((1 << 33) - (1 << 29)),
-			testErrToleranceAdditive, 51, osmomath.NewBigDec(1 << 11), false},
+			NewBigDec((1 << 33) - (1 << 29)),
+			testErrToleranceAdditive, 51, NewBigDec(1 << 11), false},
 		// basically same as above, but due to needing to roundup, we converge at a value > 2^11.
 		// We try (1<<11 + 1<<10)^3 which is way too large.
 		// notice by trial, that (1 << 11 + 1<<7)^3 - target > 2^30, but that
@@ -254,25 +256,25 @@ func TestBinarySearchBigDec(t *testing.T) {
 		"cubic f, within 2^30, roundup, target 2^33 + 2^29": {
 			cubicF,
 			zero, twoTo50,
-			osmomath.NewBigDec((1 << 33) + (1 << 29)),
-			withRoundingDir(testErrToleranceAdditive, osmomath.RoundUp),
-			51, osmomath.NewBigDec(1<<11 + 1<<6), false},
+			NewBigDec((1 << 33) + (1 << 29)),
+			withRoundingDir(testErrToleranceAdditive, RoundUp),
+			51, NewBigDec(1<<11 + 1<<6), false},
 		"cubic f, large multiplicative err tolerance, converges": {
 			cubicF,
 			zero, twoTo50,
-			osmomath.NewBigDec(1 << 30), withinFactor8, 51, osmomath.NewBigDec(1 << 11), false},
+			NewBigDec(1 << 30), withinFactor8, 51, NewBigDec(1 << 11), false},
 		"cubic f, both err tolerances, converges": {
 			cubicF,
 			zero, twoTo50,
-			osmomath.NewBigDec((1 << 33) - (1 << 29)),
-			errToleranceBoth, 51, osmomath.NewBigDec(1 << 11), false},
+			NewBigDec((1 << 33) - (1 << 29)),
+			errToleranceBoth, 51, NewBigDec(1 << 11), false},
 		"neg cubic f, no err tolerance, converges": {negCubicF, zero, twoTo50,
 			twoTo25PlusOneCubed.Add(negCubicFConstant), withinOne, 51, twoTo25PlusOne, false},
 		// "neg cubic f, large multiplicative err tolerance, converges": {
 		// 	negCubicF,
 		// 	zero, twoTo50,
-		// 	osmomath.NewBigDec(1 << 30).Add(negCubicFConstant),
-		// 	withinFactor8, 51, osmomath.NewBigDec(1 << 11), false},
+		// 	NewBigDec(1 << 30).Add(negCubicFConstant),
+		// 	withinFactor8, 51, NewBigDec(1 << 11), false},
 	}
 
 	runBinarySearchTestCases(t, tests, equalWithinOne)
@@ -281,35 +283,35 @@ func TestBinarySearchBigDec(t *testing.T) {
 func TestBinarySearchRoundingBehavior(t *testing.T) {
 	withinTwoTo30 := ErrTolerance{AdditiveTolerance: sdk.NewInt(1 << 30)}
 
-	twoTo50 := osmomath.NewBigDec(1 << 50)
-	// twoTo25PlusOne := osmomath.NewBigDec(1 + (1 << 25))
+	twoTo50 := NewBigDec(1 << 50)
+	// twoTo25PlusOne := NewBigDec(1 + (1 << 25))
 	// twoTo25PlusOneCubed := twoTo25PlusOne.Power(3)
 
 	tests := map[string]binarySearchTestCase{
 		"lineF, roundup within 2^30, target 2^32 + 2^30 + 1, expected=2^32 + 2^31": {f: lineF,
 			lowerbound: zero, upperbound: twoTo50,
-			targetOutput:        osmomath.NewBigDec((1 << 32) + (1 << 30) + 1),
-			errTolerance:        withRoundingDir(withinTwoTo30, osmomath.RoundUp),
+			targetOutput:        NewBigDec((1 << 32) + (1 << 30) + 1),
+			errTolerance:        withRoundingDir(withinTwoTo30, RoundUp),
 			maxIterations:       51,
-			expectedSolvedInput: osmomath.NewBigDec(1<<32 + 1<<31)},
+			expectedSolvedInput: NewBigDec(1<<32 + 1<<31)},
 		"lineF, roundup within 2^30, target 2^32 + 2^30 - 1, expected=2^32 + 2^30": {f: lineF,
 			lowerbound: zero, upperbound: twoTo50,
-			targetOutput:        osmomath.NewBigDec((1 << 32) + (1 << 30) - 1),
-			errTolerance:        withRoundingDir(withinTwoTo30, osmomath.RoundUp),
+			targetOutput:        NewBigDec((1 << 32) + (1 << 30) - 1),
+			errTolerance:        withRoundingDir(withinTwoTo30, RoundUp),
 			maxIterations:       51,
-			expectedSolvedInput: osmomath.NewBigDec(1<<32 + 1<<30)},
+			expectedSolvedInput: NewBigDec(1<<32 + 1<<30)},
 		"lineF, rounddown within 2^30, target 2^32 + 2^30 + 1, expected=2^32 + 2^31": {f: lineF,
 			lowerbound: zero, upperbound: twoTo50,
-			targetOutput:        osmomath.NewBigDec((1 << 32) + (1 << 30) + 1),
-			errTolerance:        withRoundingDir(withinTwoTo30, osmomath.RoundDown),
+			targetOutput:        NewBigDec((1 << 32) + (1 << 30) + 1),
+			errTolerance:        withRoundingDir(withinTwoTo30, RoundDown),
 			maxIterations:       51,
-			expectedSolvedInput: osmomath.NewBigDec(1<<32 + 1<<30)},
+			expectedSolvedInput: NewBigDec(1<<32 + 1<<30)},
 		"lineF, rounddown within 2^30, target 2^32 + 2^30 - 1, expected=2^32 + 2^30": {f: lineF,
 			lowerbound: zero, upperbound: twoTo50,
-			targetOutput:        osmomath.NewBigDec((1 << 32) + (1 << 30) - 1),
-			errTolerance:        withRoundingDir(withinTwoTo30, osmomath.RoundDown),
+			targetOutput:        NewBigDec((1 << 32) + (1 << 30) - 1),
+			errTolerance:        withRoundingDir(withinTwoTo30, RoundDown),
 			maxIterations:       51,
-			expectedSolvedInput: osmomath.NewBigDec(1 << 32)},
+			expectedSolvedInput: NewBigDec(1 << 32)},
 	}
 
 	runBinarySearchTestCases(t,
@@ -358,11 +360,11 @@ func TestErrTolerance_Compare(t *testing.T) {
 			if gotIntRev != -tt.expectedCompareResult {
 				t.Errorf("ErrTolerance.Compare() = %v, want %v", gotIntRev, -tt.expectedCompareResult)
 			}
-			gotBigDec := tt.tol.CompareBigDec(osmomath.NewBigDec(tt.intInput), osmomath.NewBigDec(tt.intReference))
+			gotBigDec := tt.tol.CompareBigDec(NewBigDec(tt.intInput), NewBigDec(tt.intReference))
 			if gotBigDec != tt.expectedCompareResult {
 				t.Errorf("ErrTolerance.CompareBigDec() = %v, want %v", gotBigDec, tt.expectedCompareResult)
 			}
-			gotBigDecRev := tt.tol.CompareBigDec(osmomath.NewBigDec(tt.intReference), osmomath.NewBigDec(tt.intInput))
+			gotBigDecRev := tt.tol.CompareBigDec(NewBigDec(tt.intReference), NewBigDec(tt.intInput))
 			if gotBigDecRev != -tt.expectedCompareResult {
 				t.Errorf("ErrTolerance.CompareBigDec() = %v, want %v", gotBigDecRev, -tt.expectedCompareResult)
 			}
diff --git a/osmomath/decimal_test.go b/osmomath/decimal_test.go
index c6983617c..a33e08647 100644
--- a/osmomath/decimal_test.go
+++ b/osmomath/decimal_test.go
@@ -12,7 +12,6 @@ import (
 	"github.com/stretchr/testify/suite"
 	"gopkg.in/yaml.v2"
 
-	"github.com/osmosis-labs/osmosis/v13/app/apptesting/osmoassert"
 	"github.com/osmosis-labs/osmosis/v13/osmomath"
 	gammtypes "github.com/osmosis-labs/osmosis/v13/x/gamm/types"
 )
@@ -734,12 +733,11 @@ func (s *decimalTestSuite) TestLog2() {
 
 	for name, tc := range tests {
 		s.Run(name, func() {
-			osmoassert.ConditionalPanic(s.T(), tc.expectedPanic, func() {
+			osmomath.ConditionalPanic(s.T(), tc.expectedPanic, func() {
 				// Create a copy to test that the original was not modified.
 				// That is, that LogbBase2() is non-mutative.
 				initialCopy := tc.initialValue.Clone()
 
-				// system under test.
 				res := tc.initialValue.LogBase2()
 				require.True(osmomath.DecApproxEq(s.T(), tc.expected, res, expectedErrTolerance))
 				require.Equal(s.T(), initialCopy, tc.initialValue)
@@ -818,12 +816,11 @@ func (s *decimalTestSuite) TestLn() {
 
 	for name, tc := range tests {
 		s.Run(name, func() {
-			osmoassert.ConditionalPanic(s.T(), tc.expectedPanic, func() {
+			osmomath.ConditionalPanic(s.T(), tc.expectedPanic, func() {
 				// Create a copy to test that the original was not modified.
 				// That is, that Ln() is non-mutative.
 				initialCopy := tc.initialValue.Clone()
 
-				// system under test.
 				res := tc.initialValue.Ln()
 				require.True(osmomath.DecApproxEq(s.T(), tc.expected, res, expectedErrTolerance))
 				require.Equal(s.T(), initialCopy, tc.initialValue)
@@ -894,12 +891,11 @@ func (s *decimalTestSuite) TestTickLog() {
 
 	for name, tc := range tests {
 		s.Run(name, func() {
-			osmoassert.ConditionalPanic(s.T(), tc.expectedPanic, func() {
+			osmomath.ConditionalPanic(s.T(), tc.expectedPanic, func() {
 				// Create a copy to test that the original was not modified.
 				// That is, that Ln() is non-mutative.
 				initialCopy := tc.initialValue.Clone()
 
-				// system under test.
 				res := tc.initialValue.TickLog()
 				fmt.Println(name, res.Sub(tc.expected).Abs())
 				require.True(osmomath.DecApproxEq(s.T(), tc.expected, res, tc.expectedErrTolerance))
@@ -1010,11 +1006,10 @@ func (s *decimalTestSuite) TestCustomBaseLog() {
 	}
 	for name, tc := range tests {
 		s.Run(name, func() {
-			osmoassert.ConditionalPanic(s.T(), tc.expectedPanic, func() {
+			osmomath.ConditionalPanic(s.T(), tc.expectedPanic, func() {
 				// Create a copy to test that the original was not modified.
 				// That is, that Ln() is non-mutative.
 				initialCopy := tc.initialValue.Clone()
-				// system under test.
 				res := tc.initialValue.CustomBaseLog(tc.base)
 				require.True(osmomath.DecApproxEq(s.T(), tc.expected, res, tc.expectedErrTolerance))
 				require.Equal(s.T(), initialCopy, tc.initialValue)
@@ -1213,7 +1208,6 @@ func (s *decimalTestSuite) TestMul_Mutation() {
 	for name, tc := range tests {
 		tc := tc
 		s.Run(name, func() {
-
 			startMut := tc.startValue.Clone()
 			startNonMut := tc.startValue.Clone()
 
diff --git a/osmomath/export_test.go b/osmomath/export_test.go
index 48ab3f233..bdb6c71f9 100644
--- a/osmomath/export_test.go
+++ b/osmomath/export_test.go
@@ -1,6 +1,30 @@
 package osmomath
 
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+)
+
 var (
 	EulersNumber = eulersNumber
 	TwoBigDec    = twoBigDec
 )
+
+// 2^128 - 1, needs to be the same as gammtypes.MaxSpotPrice
+// but we can't directly import that due to import cycles.
+// Hence we use the same var name, in hopes that if any change there happens,
+// this is caught via a CTRL+F
+var MaxSpotPrice = sdk.NewDec(2).Power(128).Sub(sdk.OneDec())
+
+// ConditionalPanic checks if expectPanic is true, asserts that sut (system under test)
+// panics. If expectPanic is false, asserts that sut does not panic.
+// returns true if sut panics and false it it does not
+func ConditionalPanic(t *testing.T, expectPanic bool, sut func()) {
+	if expectPanic {
+		require.Panics(t, sut)
+		return
+	}
+	require.NotPanics(t, sut)
+}
diff --git a/osmomath/log2_bench_test.go b/osmomath/log2_bench_test.go
index 23d267176..d9fb3626f 100644
--- a/osmomath/log2_bench_test.go
+++ b/osmomath/log2_bench_test.go
@@ -3,8 +3,6 @@ package osmomath
 import (
 	"math/rand"
 	"testing"
-
-	gammtypes "github.com/osmosis-labs/osmosis/v13/x/gamm/types"
 )
 
 func BenchmarkLog2(b *testing.B) {
@@ -15,7 +13,7 @@ func BenchmarkLog2(b *testing.B) {
 		NewBigDec(2048 * 2048 * 2048 * 2048 * 2048),
 		MustNewDecFromStr("999999999999999999999999999999999999999999999999999999.9122181273612911"),
 		MustNewDecFromStr("0.563289239121902491248219047129047129"),
-		BigDecFromSDKDec(gammtypes.MaxSpotPrice),                        // 2^128 - 1
+		BigDecFromSDKDec(MaxSpotPrice),                                  // 2^128 - 1
 		MustNewDecFromStr("336879543251729078828740861357450529340.45"), // (2^128 - 1) * 0.99
 	}
 
diff --git a/osmomath/math_test.go b/osmomath/math_test.go
index a50cc4574..07d21abec 100644
--- a/osmomath/math_test.go
+++ b/osmomath/math_test.go
@@ -6,8 +6,6 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
-	"github.com/osmosis-labs/osmosis/v13/app/apptesting/osmoassert"
-
 	"github.com/stretchr/testify/require"
 )
 
@@ -92,7 +90,7 @@ func TestPowApprox(t *testing.T) {
 
 	for i, tc := range testCases {
 		var actualResult sdk.Dec
-		osmoassert.ConditionalPanic(t, tc.base.Equal(sdk.ZeroDec()), func() {
+		ConditionalPanic(t, tc.base.Equal(sdk.ZeroDec()), func() {
 			fmt.Println(tc.base)
 			actualResult = PowApprox(tc.base, tc.exp, tc.powPrecision)
 			require.True(
@@ -156,7 +154,7 @@ func TestPow(t *testing.T) {
 
 	for i, tc := range testCases {
 		var actualResult sdk.Dec
-		osmoassert.ConditionalPanic(t, tc.base.Equal(sdk.ZeroDec()), func() {
+		ConditionalPanic(t, tc.base.Equal(sdk.ZeroDec()), func() {
 			actualResult = Pow(tc.base, tc.exp)
 			require.True(
 				t,
diff --git a/osmomath/rounding_direction_test.go b/osmomath/rounding_direction_test.go
index b91d42690..2aeb2474b 100644
--- a/osmomath/rounding_direction_test.go
+++ b/osmomath/rounding_direction_test.go
@@ -6,8 +6,6 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/require"
-
-	"github.com/osmosis-labs/osmosis/v13/app/apptesting/osmoassert"
 )
 
 func TestDivIntByU64ToBigDec(t *testing.T) {
@@ -45,7 +43,11 @@ func TestDivIntByU64ToBigDec(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			got, err := DivIntByU64ToBigDec(tt.i, tt.u, tt.round)
 			require.Equal(t, tt.want, got)
-			osmoassert.ConditionalError(t, tt.expErr, err)
+			if tt.expErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
 		})
 	}
 }
diff --git a/osmomath/sigfig_round_test.go b/osmomath/sigfig_round_test.go
index 24640cbaf..71cbb96ac 100644
--- a/osmomath/sigfig_round_test.go
+++ b/osmomath/sigfig_round_test.go
@@ -7,8 +7,6 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/stretchr/testify/require"
-
-	"github.com/osmosis-labs/osmosis/v13/app/apptesting/osmoassert"
 )
 
 func TestSigFigRound(t *testing.T) {
@@ -78,7 +76,7 @@ func TestSigFigRound(t *testing.T) {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			var actualResult sdk.Dec
-			osmoassert.ConditionalPanic(t, tc.tenToSigFig.Equal(sdk.ZeroInt()), func() {
+			ConditionalPanic(t, tc.tenToSigFig.Equal(sdk.ZeroInt()), func() {
 				actualResult = SigFigRound(tc.decimal, tc.tenToSigFig)
 				require.Equal(
 					t,
diff --git a/x/gamm/pool-models/balancer/pool_test.go b/x/gamm/pool-models/balancer/pool_test.go
index e51c19aca..36d9f074b 100644
--- a/x/gamm/pool-models/balancer/pool_test.go
+++ b/x/gamm/pool-models/balancer/pool_test.go
@@ -10,7 +10,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/osmosis-labs/osmosis/v13/app/apptesting/osmoassert"
-	"github.com/osmosis-labs/osmosis/v13/osmoutils"
+	"github.com/osmosis-labs/osmosis/v13/osmomath"
 	"github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/balancer"
 	"github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/internal/test_helpers"
 	"github.com/osmosis-labs/osmosis/v13/x/gamm/types"
@@ -574,7 +574,7 @@ func (suite *BalancerTestSuite) TestBalancerCalculateAmountOutAndIn_InverseRelat
 				pool := createTestPool(suite.T(), swapFeeDec, exitFeeDec, poolAssetOut, poolAssetIn)
 				suite.Require().NotNil(pool)
 
-				errTolerance := osmoutils.ErrTolerance{
+				errTolerance := osmomath.ErrTolerance{
 					AdditiveTolerance: sdk.OneInt(), MultiplicativeTolerance: sdk.Dec{}}
 				sut := func() {
 					test_helpers.TestCalculateAmountOutAndIn_InverseRelationship(suite.T(), ctx, pool, poolAssetIn.Token.Denom, poolAssetOut.Token.Denom, tc.initialCalcOut, swapFeeDec, errTolerance)
diff --git a/x/gamm/pool-models/balancer/util_test.go b/x/gamm/pool-models/balancer/util_test.go
index d4b1bb7f6..48c169588 100644
--- a/x/gamm/pool-models/balancer/util_test.go
+++ b/x/gamm/pool-models/balancer/util_test.go
@@ -12,7 +12,7 @@ import (
 	tmtypes "github.com/tendermint/tendermint/proto/tendermint/types"
 	dbm "github.com/tendermint/tm-db"
 
-	"github.com/osmosis-labs/osmosis/v13/osmoutils"
+	"github.com/osmosis-labs/osmosis/v13/osmomath"
 	"github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/balancer"
 	"github.com/osmosis-labs/osmosis/v13/x/gamm/types"
 )
@@ -43,7 +43,7 @@ func assertExpectedSharesErrRatio(t *testing.T, expectedShares, actualShares sdk
 	allowedErrRatioDec, err := sdk.NewDecFromStr(allowedErrRatio)
 	require.NoError(t, err)
 
-	errTolerance := osmoutils.ErrTolerance{
+	errTolerance := osmomath.ErrTolerance{
 		MultiplicativeTolerance: allowedErrRatioDec,
 	}
 
diff --git a/x/gamm/pool-models/internal/test_helpers/test_helpers.go b/x/gamm/pool-models/internal/test_helpers/test_helpers.go
index 3dec5f4c9..97fe9993c 100644
--- a/x/gamm/pool-models/internal/test_helpers/test_helpers.go
+++ b/x/gamm/pool-models/internal/test_helpers/test_helpers.go
@@ -13,7 +13,6 @@ import (
 	dbm "github.com/tendermint/tm-db"
 
 	"github.com/osmosis-labs/osmosis/v13/osmomath"
-	"github.com/osmosis-labs/osmosis/v13/osmoutils"
 	sdkrand "github.com/osmosis-labs/osmosis/v13/simulation/simtypes/random"
 	"github.com/osmosis-labs/osmosis/v13/x/gamm/types"
 )
@@ -41,7 +40,7 @@ func TestCalculateAmountOutAndIn_InverseRelationship(
 	assetOutDenom string,
 	initialCalcOut int64,
 	swapFee sdk.Dec,
-	errTolerance osmoutils.ErrTolerance,
+	errTolerance osmomath.ErrTolerance,
 ) {
 	initialOut := sdk.NewInt64Coin(assetOutDenom, initialCalcOut)
 	initialOutCoins := sdk.NewCoins(initialOut)
diff --git a/x/gamm/pool-models/stableswap/amm_test.go b/x/gamm/pool-models/stableswap/amm_test.go
index 304256e65..418b16003 100644
--- a/x/gamm/pool-models/stableswap/amm_test.go
+++ b/x/gamm/pool-models/stableswap/amm_test.go
@@ -12,7 +12,6 @@ import (
 
 	"github.com/osmosis-labs/osmosis/v13/app/apptesting/osmoassert"
 	"github.com/osmosis-labs/osmosis/v13/osmomath"
-	"github.com/osmosis-labs/osmosis/v13/osmoutils"
 	sdkrand "github.com/osmosis-labs/osmosis/v13/simulation/simtypes/random"
 	"github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/internal/cfmm_common"
 	"github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/internal/test_helpers"
@@ -726,7 +725,7 @@ func (suite *StableSwapTestSuite) Test_StableSwap_CalculateAmountOutAndIn_Invers
 				// TODO: add scaling factors into inverse relationship tests
 				pool := createTestPool(suite.T(), tc.poolLiquidity, swapFeeDec, exitFeeDec, tc.scalingFactors)
 				suite.Require().NotNil(pool)
-				errTolerance := osmoutils.ErrTolerance{
+				errTolerance := osmomath.ErrTolerance{
 					AdditiveTolerance: sdk.Int{}, MultiplicativeTolerance: sdk.NewDecWithPrec(1, 12)}
 				test_helpers.TestCalculateAmountOutAndIn_InverseRelationship(suite.T(), ctx, pool, tc.denomIn, tc.denomOut, tc.initialCalcOut, swapFeeDec, errTolerance)
 			})
diff --git a/x/tokenfactory/client/cli/cli_test.go b/x/tokenfactory/client/cli/cli_test.go
new file mode 100644
index 000000000..638d4581d
--- /dev/null
+++ b/x/tokenfactory/client/cli/cli_test.go
@@ -0,0 +1,35 @@
+package cli_test
+
+import (
+	"testing"
+
+	"github.com/osmosis-labs/osmosis/v13/osmoutils/osmocli"
+	"github.com/osmosis-labs/osmosis/v13/x/tokenfactory/client/cli"
+	"github.com/osmosis-labs/osmosis/v13/x/tokenfactory/types"
+)
+
+func TestGetCmdDenomAuthorityMetadata(t *testing.T) {
+	desc, _ := cli.GetCmdDenomAuthorityMetadata()
+	tcs := map[string]osmocli.QueryCliTestCase[*types.QueryDenomAuthorityMetadataRequest]{
+		"basic test": {
+			Cmd: "uatom",
+			ExpectedQuery: &types.QueryDenomAuthorityMetadataRequest{
+				Denom: "uatom",
+			},
+		},
+	}
+	osmocli.RunQueryTestCases(t, desc, tcs)
+}
+
+func TestGetCmdDenomsFromCreator(t *testing.T) {
+	desc, _ := cli.GetCmdDenomsFromCreator()
+	tcs := map[string]osmocli.QueryCliTestCase[*types.QueryDenomsFromCreatorRequest]{
+		"basic test": {
+			Cmd: "osmo1test",
+			ExpectedQuery: &types.QueryDenomsFromCreatorRequest{
+				Creator: "osmo1test",
+			},
+		},
+	}
+	osmocli.RunQueryTestCases(t, desc, tcs)
+}