refactor: remove usage of global basedenom

CHANGELOG.md

@@ -182,6 +182,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * (x/staking) [#18257](https://github.com/cosmos/cosmos-sdk/pull/18257) Staking module was moved to its own go.mod `cosmossdk.io/x/staking`
 * (x/consensus) [#18041](https://github.com/cosmos/cosmos-sdk/pull/18041) `ToProtoConsensusParams()` returns an error 
 * (x/slashing) [#18115](https://github.com/cosmos/cosmos-sdk/pull/18115) `NewValidatorSigningInfo` takes strings instead of `sdk.AccAddress`
+* (types) [#18268](https://github.com/cosmos/cosmos-sdk/pull/18268) Remove global setting of basedenom. Use the staking module parameter instead
 
 ### CLI Breaking Changes
 

types/coin.go

@@ -881,7 +881,7 @@ func ParseCoinNormalized(coinStr string) (coin Coin, err error) {
 		return Coin{}, err
 	}
 
-	coin, _ = NormalizeDecCoin(decCoin).TruncateDecimal()
+	coin, _ = normalizeDecCoin(decCoin).TruncateDecimal()
 	return coin, nil
 }
 
@@ -900,3 +900,75 @@ func ParseCoinsNormalized(coinStr string) (Coins, error) {
 	}
 	return NormalizeCoins(coins), nil
 }
+
+// ----------------------------------------------------------------------------
+// Functions used for testing purposes.
+
+// NormalizeDecCoin try to convert a decimal coin to the smallest unit registered,
+// returns original one if failed.
+func normalizeDecCoin(coin DecCoin) DecCoin {
+	newCoin, err := convertDecCoin(coin, coin.Denom)
+	if err != nil {
+		return coin
+	}
+	return newCoin
+}
+
+// NormalizeCoins normalize and truncate a list of decimal coins
+func NormalizeCoins(coins []DecCoin) Coins {
+	if coins == nil {
+		return nil
+	}
+	result := make([]Coin, 0, len(coins))
+
+	for _, coin := range coins {
+		newCoin, _ := normalizeDecCoin(coin).TruncateDecimal()
+		result = append(result, newCoin)
+	}
+
+	return result
+}
+
+// ConvertDecCoin attempts to convert a decimal coin to a given denomination. If the given
+// denomination is invalid or if neither denomination is registered, an error
+// is returned.
+func convertDecCoin(coin DecCoin, denom string) (DecCoin, error) {
+	if err := ValidateDenom(denom); err != nil {
+		return DecCoin{}, err
+	}
+
+	srcUnit, ok := getDenomUnit(coin.Denom)
+	if !ok {
+		return DecCoin{}, fmt.Errorf("source denom not registered: %s", coin.Denom)
+	}
+
+	dstUnit, ok := getDenomUnit(denom)
+	if !ok {
+		return DecCoin{}, fmt.Errorf("destination denom not registered: %s", denom)
+	}
+
+	if srcUnit.Equal(dstUnit) {
+		return NewDecCoinFromDec(denom, coin.Amount), nil
+	}
+
+	return NewDecCoinFromDec(denom, coin.Amount.Mul(srcUnit).Quo(dstUnit)), nil
+}
+
+// denomUnits contains a mapping of denomination mapped to their respective unit
+// multipliers (e.g. 1atom = 10^-6uatom).
+var denomUnits = map[string]math.LegacyDec{}
+
+// getDenomUnit returns a unit for a given denomination if it exists. A boolean
+// is returned if the denomination is registered.
+func getDenomUnit(denom string) (math.LegacyDec, bool) {
+	if err := ValidateDenom(denom); err != nil {
+		return math.LegacyZeroDec(), false
+	}
+
+	unit, ok := denomUnits[denom]
+	if !ok {
+		return math.LegacyZeroDec(), false
+	}
+
+	return unit, true
+}