refactor: sdk math in other test file

app/test_helpers.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	cosmoserrors "cosmossdk.io/errors"
+	sdkmath "cosmossdk.io/math"
 	pruningtypes "cosmossdk.io/store/pruning/types"
 	bam "github.com/cosmos/cosmos-sdk/baseapp"
 	"github.com/cosmos/cosmos-sdk/codec"
@@ -59,7 +60,7 @@ func Setup(t *testing.T) *App {
 	acc := authtypes.NewBaseAccount(senderPrivKey.PubKey().Address().Bytes(), senderPrivKey.PubKey(), 0, 0)
 	balance := banktypes.Balance{
 		Address: acc.GetAddress().String(),
-		Coins:   sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100000000000000))),
+		Coins:   sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(100000000000000))),
 	}
 
 	app := SetupWithGenesisValSet(t, valSet, []authtypes.GenesisAccount{acc}, balance)

x/alliance/tests/e2e/test_helper.go

@@ -9,6 +9,7 @@ import (
 	teststaking "github.com/cosmos/cosmos-sdk/x/staking/testutil"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 
+	sdkmath "cosmossdk.io/math"
 	test_helpers "github.com/terra-money/alliance/app"
 )
 
@@ -28,9 +29,9 @@ func setupApp(t *testing.T, numValidators int, numDelegators int, initBalance sd
 		_val := teststaking.NewValidator(t, valAddr, pks[i])
 		_val.Commission = stakingtypes.Commission{
 			CommissionRates: stakingtypes.CommissionRates{
-				Rate:          sdk.NewDec(0),
-				MaxRate:       sdk.NewDec(0),
-				MaxChangeRate: sdk.NewDec(0),
+				Rate:          sdkmath.LegacyNewDec(0),
+				MaxRate:       sdkmath.LegacyNewDec(0),
+				MaxChangeRate: sdkmath.LegacyNewDec(0),
 			},
 			UpdateTime: time.Now(),
 		}

x/alliance/tests/simulation/genesis.go

@@ -5,8 +5,9 @@ import (
 	"math/rand"
 	"time"
 
+	sdkmath "cosmossdk.io/math"
+
 	"github.com/cometbft/cometbft/libs/json"
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
 	"github.com/cosmos/cosmos-sdk/types/simulation"
 
@@ -39,10 +40,10 @@ func RandomizedGenesisState(simState *module.SimulationState) {
 
 	var allianceAssets []types.AllianceAsset
 	for i := 0; i < numOfAllianceAssets; i++ {
-		rewardRate := simulation.RandomDecAmount(r, sdk.NewDec(5))
-		takeRate := simulation.RandomDecAmount(r, sdk.MustNewDecFromStr("0.0005"))
+		rewardRate := simulation.RandomDecAmount(r, sdkmath.LegacyNewDec(5))
+		takeRate := simulation.RandomDecAmount(r, sdkmath.LegacyMustNewDecFromStr("0.0005"))
 		startTime := time.Now().Add(time.Duration(simulation.RandIntBetween(r, 60, 60*60*24*3*2)) * time.Second)
-		allianceAssets = append(allianceAssets, types.NewAllianceAsset(fmt.Sprintf("ASSET%d", i), rewardRate, sdk.NewDec(0), sdk.NewDec(15), takeRate, startTime))
+		allianceAssets = append(allianceAssets, types.NewAllianceAsset(fmt.Sprintf("ASSET%d", i), rewardRate, sdkmath.LegacyNewDec(0), sdkmath.LegacyNewDec(15), takeRate, startTime))
 	}
 
 	allianceGenesis := types.GenesisState{

x/alliance/tests/simulation/operations.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/x/auth/tx"
 
+	sdkmath "cosmossdk.io/math"
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -62,7 +63,7 @@ func SimulateMsgDelegate(cdc *codec.ProtoCodec, ak types.AccountKeeper, bk types
 		}
 		idx := simtypes.RandIntBetween(r, 0, len(assets)-1)
 		assetToDelegate := assets[idx]
-		amountToDelegate := simtypes.RandomAmount(r, sdk.NewInt(1000_000_000))
+		amountToDelegate := simtypes.RandomAmount(r, sdkmath.NewInt(1000_000_000))
 		if amountToDelegate.IsZero() {
 			return simtypes.NoOpMsg(types.ModuleName, types.MsgRedelegateType, "0 delegate amount"), nil, nil
 		}
@@ -205,7 +206,7 @@ func SimulateMsgUndelegate(cdc *codec.ProtoCodec, ak types.AccountKeeper, bk typ
 		asset, _ := k.GetAssetByDenom(ctx, delegation.Denom)
 		bondedTokens := types.GetDelegationTokens(delegation, validator, asset)
 
-		amountToUndelegate := simtypes.RandomAmount(r, bondedTokens.Amount.Sub(sdk.NewInt(1))).Add(sdk.NewInt(1))
+		amountToUndelegate := simtypes.RandomAmount(r, bondedTokens.Amount.Sub(sdkmath.NewInt(1))).Add(sdkmath.NewInt(1))
 		if amountToUndelegate.IsZero() {
 			return simtypes.NoOpMsg(types.ModuleName, types.MsgRedelegateType, "0 undelegate amount"), nil, nil
 		}

x/alliance/types/tests/types_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 	"time"
 
+	sdkmath "cosmossdk.io/math"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx"
@@ -29,7 +30,7 @@ func TestMarshalJSONMsgs(t *testing.T) {
 	}{
 		{
 			"Msg Delegate",
-			types.NewMsgDelegate("delegator", "validator", sdk.NewCoin("Alliance", sdk.NewInt(1000000000000000000))),
+			types.NewMsgDelegate("delegator", "validator", sdk.NewCoin("Alliance", sdkmath.NewInt(1000000000000000000))),
 			`{"delegator_address":"delegator","validator_address":"validator","amount":{"denom":"Alliance","amount":"1000000000000000000"}}`,
 		},
 	}
@@ -55,14 +56,14 @@ func TestProposalsContent(t *testing.T) {
 		str   string
 	}{
 		"msg_create_alliance_proposal": {
-			p:     types.NewMsgCreateAllianceProposal("Alliance1", "Alliance with 1", "ibc/denom1", sdk.NewDec(1), types.RewardWeightRange{Min: sdk.NewDec(0), Max: sdk.NewDec(5)}, sdk.NewDec(1), sdk.NewDec(1), time.Second),
+			p:     types.NewMsgCreateAllianceProposal("Alliance1", "Alliance with 1", "ibc/denom1", sdkmath.LegacyNewDec(1), types.RewardWeightRange{Min: sdkmath.LegacyNewDec(0), Max: sdkmath.LegacyNewDec(5)}, sdkmath.LegacyNewDec(1), sdkmath.LegacyNewDec(1), time.Second),
 			title: "Alliance1",
 			desc:  "Alliance with 1",
 			typ:   "msg_create_alliance_proposal",
 			str:   "title:\"Alliance1\" description:\"Alliance with 1\" denom:\"ibc/denom1\" reward_weight:\"1000000000000000000\" take_rate:\"1000000000000000000\" reward_change_rate:\"1000000000000000000\" reward_change_interval:<seconds:1 > reward_weight_range:<min:\"0\" max:\"5000000000000000000\" > ",
 		},
 		"msg_update_alliance_proposal": {
-			p:     types.NewMsgUpdateAllianceProposal("Alliance2", "Alliance with 2", "ibc/denom2", sdk.NewDec(2), sdk.NewDec(2), sdk.NewDec(2), time.Hour),
+			p:     types.NewMsgUpdateAllianceProposal("Alliance2", "Alliance with 2", "ibc/denom2", sdkmath.LegacyNewDec(2), sdkmath.LegacyNewDec(2), sdkmath.LegacyNewDec(2), time.Hour),
 			title: "Alliance2",
 			desc:  "Alliance with 2",
 			typ:   "msg_update_alliance_proposal",
@@ -118,19 +119,19 @@ func TestInvalidProposalsContent(t *testing.T) {
 		str   string
 	}{
 		"msg_create_alliance_proposal": {
-			p:     types.NewMsgCreateAllianceProposal("Alliance1", "Alliance with 1", "ibc/denom1", sdk.NewDec(1), types.RewardWeightRange{Min: sdk.NewDec(0), Max: sdk.NewDec(5)}, sdk.NewDec(1), sdk.NewDec(1), -time.Second),
+			p:     types.NewMsgCreateAllianceProposal("Alliance1", "Alliance with 1", "ibc/denom1", sdkmath.LegacyNewDec(1), types.RewardWeightRange{Min: sdkmath.LegacyNewDec(0), Max: sdkmath.LegacyNewDec(5)}, sdkmath.LegacyNewDec(1), sdkmath.LegacyNewDec(1), -time.Second),
 			title: "Alliance1",
 			desc:  "Alliance with 1",
 			typ:   "msg_create_alliance_proposal",
 		},
 		"msg_create_alliance_proposal_invalid_denom": {
-			p:     types.NewMsgCreateAllianceProposal("Alliance1", "Alliance with 1", invalidDenom, sdk.NewDec(1), types.RewardWeightRange{Min: sdk.NewDec(0), Max: sdk.NewDec(5)}, sdk.NewDec(1), sdk.NewDec(1), time.Second),
+			p:     types.NewMsgCreateAllianceProposal("Alliance1", "Alliance with 1", invalidDenom, sdkmath.LegacyNewDec(1), types.RewardWeightRange{Min: sdkmath.LegacyNewDec(0), Max: sdkmath.LegacyNewDec(5)}, sdkmath.LegacyNewDec(1), sdkmath.LegacyNewDec(1), time.Second),
 			title: "Alliance1",
 			desc:  "Alliance with 1",
 			typ:   "msg_create_alliance_proposal",
 		},
 		"msg_update_alliance_proposal": {
-			p:     types.NewMsgUpdateAllianceProposal("Alliance2", "Alliance with 2", "ibc/denom2", sdk.NewDec(2), sdk.NewDec(2), sdk.NewDec(2), -time.Hour),
+			p:     types.NewMsgUpdateAllianceProposal("Alliance2", "Alliance with 2", "ibc/denom2", sdkmath.LegacyNewDec(2), sdkmath.LegacyNewDec(2), sdkmath.LegacyNewDec(2), -time.Hour),
 			title: "Alliance2",
 			desc:  "Alliance with 2",
 			typ:   "msg_update_alliance_proposal",
@@ -150,19 +151,19 @@ func TestInvalidProposalsContent(t *testing.T) {
 }
 
 func TestAminoJSON(t *testing.T) {
-	msgDelegate := types.NewMsgDelegate("delegator", "validator", sdk.NewCoin("Alliance", sdk.NewInt(1000000000000000000)))
+	msgDelegate := types.NewMsgDelegate("delegator", "validator", sdk.NewCoin("Alliance", sdkmath.NewInt(1000000000000000000)))
 	require.Equal(t,
 		`{"account_number":"1","chain_id":"foo","fee":{"amount":[],"gas":"0"},"memo":"memo","msgs":[{"type":"alliance/MsgDelegate","value":{"amount":{"amount":"1000000000000000000","denom":"Alliance"},"delegator_address":"delegator","validator_address":"validator"}}],"sequence":"1","timeout_height":"1"}`,
 		string(legacytx.StdSignBytes("foo", 1, 1, 1, legacytx.StdFee{}, []sdk.Msg{msgDelegate}, "memo", nil)),
 	)
 
-	msgUndelegate := types.NewMsgUndelegate("delegator", "validator", sdk.NewCoin("Alliance", sdk.NewInt(1000000000000000000)))
+	msgUndelegate := types.NewMsgUndelegate("delegator", "validator", sdk.NewCoin("Alliance", sdkmath.NewInt(1000000000000000000)))
 	require.Equal(t,
 		`{"account_number":"1","chain_id":"foo","fee":{"amount":[],"gas":"0"},"memo":"memo","msgs":[{"type":"alliance/MsgUndelegate","value":{"amount":{"amount":"1000000000000000000","denom":"Alliance"},"delegator_address":"delegator","validator_address":"validator"}}],"sequence":"1","timeout_height":"1"}`,
 		string(legacytx.StdSignBytes("foo", 1, 1, 1, legacytx.StdFee{}, []sdk.Msg{msgUndelegate}, "memo", nil)),
 	)
 
-	msgRedelegate := types.NewMsgRedelegate("delegator", "validator", "validator1", sdk.NewCoin("Alliance", sdk.NewInt(1000000000000000000)))
+	msgRedelegate := types.NewMsgRedelegate("delegator", "validator", "validator1", sdk.NewCoin("Alliance", sdkmath.NewInt(1000000000000000000)))
 	require.Equal(t,
 		`{"account_number":"1","chain_id":"foo","fee":{"amount":[],"gas":"0"},"memo":"memo","msgs":[{"type":"alliance/MsgRedelegate","value":{"amount":{"amount":"1000000000000000000","denom":"Alliance"},"delegator_address":"delegator","validator_dst_address":"validator1","validator_src_address":"validator"}}],"sequence":"1","timeout_height":"1"}`,
 		string(legacytx.StdSignBytes("foo", 1, 1, 1, legacytx.StdFee{}, []sdk.Msg{msgRedelegate}, "memo", nil)),

x/alliance/types/tests/validator_test.go

@@ -3,6 +3,7 @@ package tests_test
 import (
 	"testing"
 
+	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/require"
 
@@ -12,39 +13,39 @@ import (
 func TestSubtractDecCoinsWithRounding(t *testing.T) {
 	// Normal case
 	a := sdk.NewDecCoins(
-		sdk.NewDecCoinFromDec("aaa", sdk.MustNewDecFromStr("1000.00")),
-		sdk.NewDecCoinFromDec("bbb", sdk.MustNewDecFromStr("1000.00")),
-		sdk.NewDecCoinFromDec("ccc", sdk.MustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("aaa", sdkmath.LegacyMustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("bbb", sdkmath.LegacyMustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("ccc", sdkmath.LegacyMustNewDecFromStr("1000.00")),
 	)
 	b := sdk.NewDecCoins(
-		sdk.NewDecCoinFromDec("aaa", sdk.MustNewDecFromStr("400.00")),
-		sdk.NewDecCoinFromDec("bbb", sdk.MustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("aaa", sdkmath.LegacyMustNewDecFromStr("400.00")),
+		sdk.NewDecCoinFromDec("bbb", sdkmath.LegacyMustNewDecFromStr("1000.00")),
 	)
 
 	c := types.SubtractDecCoinsWithRounding(a, b)
 	require.Equal(t, sdk.NewDecCoins(
-		sdk.NewDecCoinFromDec("aaa", sdk.MustNewDecFromStr("600.00")),
-		sdk.NewDecCoinFromDec("bbb", sdk.MustNewDecFromStr("0")),
-		sdk.NewDecCoinFromDec("ccc", sdk.MustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("aaa", sdkmath.LegacyMustNewDecFromStr("600.00")),
+		sdk.NewDecCoinFromDec("bbb", sdkmath.LegacyMustNewDecFromStr("0")),
+		sdk.NewDecCoinFromDec("ccc", sdkmath.LegacyMustNewDecFromStr("1000.00")),
 	), c)
 }
 
 func TestSubtractDecCoinsWithRoundingWithSmallErrors(t *testing.T) {
 	a := sdk.NewDecCoins(
-		sdk.NewDecCoinFromDec("aaa", sdk.MustNewDecFromStr("1000.00")),
-		sdk.NewDecCoinFromDec("bbb", sdk.MustNewDecFromStr("1000.00")),
-		sdk.NewDecCoinFromDec("ccc", sdk.MustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("aaa", sdkmath.LegacyMustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("bbb", sdkmath.LegacyMustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("ccc", sdkmath.LegacyMustNewDecFromStr("1000.00")),
 	)
 	b := sdk.NewDecCoins(
-		sdk.NewDecCoinFromDec("aaa", sdk.MustNewDecFromStr("400.00")),
-		sdk.NewDecCoinFromDec("bbb", sdk.MustNewDecFromStr("1000.90")),
+		sdk.NewDecCoinFromDec("aaa", sdkmath.LegacyMustNewDecFromStr("400.00")),
+		sdk.NewDecCoinFromDec("bbb", sdkmath.LegacyMustNewDecFromStr("1000.90")),
 	)
 
 	c := types.SubtractDecCoinsWithRounding(a, b)
 	require.Equal(t, sdk.NewDecCoins(
-		sdk.NewDecCoinFromDec("aaa", sdk.MustNewDecFromStr("600.00")),
-		sdk.NewDecCoinFromDec("bbb", sdk.MustNewDecFromStr("0")),
-		sdk.NewDecCoinFromDec("ccc", sdk.MustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("aaa", sdkmath.LegacyMustNewDecFromStr("600.00")),
+		sdk.NewDecCoinFromDec("bbb", sdkmath.LegacyMustNewDecFromStr("0")),
+		sdk.NewDecCoinFromDec("ccc", sdkmath.LegacyMustNewDecFromStr("1000.00")),
 	), c)
 }
 
@@ -54,19 +55,19 @@ func TestSubtractDecCoinsWithRoundingWithBigErrors(t *testing.T) {
 		require.NotNil(t, err)
 	}()
 	a := sdk.NewDecCoins(
-		sdk.NewDecCoinFromDec("aaa", sdk.MustNewDecFromStr("1000.00")),
-		sdk.NewDecCoinFromDec("bbb", sdk.MustNewDecFromStr("1000.00")),
-		sdk.NewDecCoinFromDec("ccc", sdk.MustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("aaa", sdkmath.LegacyMustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("bbb", sdkmath.LegacyMustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("ccc", sdkmath.LegacyMustNewDecFromStr("1000.00")),
 	)
 	b := sdk.NewDecCoins(
-		sdk.NewDecCoinFromDec("aaa", sdk.MustNewDecFromStr("400.00")),
-		sdk.NewDecCoinFromDec("bbb", sdk.MustNewDecFromStr("1010.10")),
+		sdk.NewDecCoinFromDec("aaa", sdkmath.LegacyMustNewDecFromStr("400.00")),
+		sdk.NewDecCoinFromDec("bbb", sdkmath.LegacyMustNewDecFromStr("1010.10")),
 	)
 
 	c := types.SubtractDecCoinsWithRounding(a, b)
 	require.Equal(t, sdk.NewDecCoins(
-		sdk.NewDecCoinFromDec("aaa", sdk.MustNewDecFromStr("600.00")),
-		sdk.NewDecCoinFromDec("bbb", sdk.MustNewDecFromStr("0")),
-		sdk.NewDecCoinFromDec("ccc", sdk.MustNewDecFromStr("1000.00")),
+		sdk.NewDecCoinFromDec("aaa", sdkmath.LegacyMustNewDecFromStr("600.00")),
+		sdk.NewDecCoinFromDec("bbb", sdkmath.LegacyMustNewDecFromStr("0")),
+		sdk.NewDecCoinFromDec("ccc", sdkmath.LegacyMustNewDecFromStr("1000.00")),
 	), c)
 }