LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

refactor: remove aliases from types/math.go in crisis and distribution (#15674)

Browse Source
This commit is contained in:
samricotta 2023-04-05 13:19:22 +02:00 committed by GitHub
parent 917a038b4f
commit 81d3b186be
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 133 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
x/crisis/client/cli/tx_test.go
View File

@ -6,6 +6,7 @@ import (
"io"
"testing"
sdkmath "cosmossdk.io/math"
rpcclientmock "github.com/cometbft/cometbft/rpc/client/mock"
clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
"github.com/stretchr/testify/require"
@ -48,7 +49,7 @@ func TestNewMsgVerifyInvariantTxCmd(t *testing.T) {
fmt.Sprintf("--%s=%s", flags.FlagFrom, accounts[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(10))).String()),
},
true, "invalid module name", 0,
},
@ -59,7 +60,7 @@ func TestNewMsgVerifyInvariantTxCmd(t *testing.T) {
fmt.Sprintf("--%s=%s", flags.FlagFrom, accounts[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(10))).String()),
},
true, "invalid invariant route", 0,
},
@ -70,7 +71,7 @@ func TestNewMsgVerifyInvariantTxCmd(t *testing.T) {
fmt.Sprintf("--%s=%s", flags.FlagFrom, accounts[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(10))).String()),
},
false, "", 0,
},

7
x/crisis/keeper/genesis_test.go
View File

@ -6,6 +6,7 @@ import (
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/suite"
sdkmath "cosmossdk.io/math"
storetypes "cosmossdk.io/store/types"
"github.com/cosmos/cosmos-sdk/codec"
@ -47,13 +48,13 @@ func (s *GenesisTestSuite) SetupTest() {
func (s *GenesisTestSuite) TestImportExportGenesis() {
// default params
constantFee := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000))
constantFee := sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(1000))
err := s.keeper.SetConstantFee(s.sdkCtx, constantFee)
s.Require().NoError(err)
genesis := s.keeper.ExportGenesis(s.sdkCtx)
// set constant fee to zero
constantFee = sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(0))
constantFee = sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(0))
err = s.keeper.SetConstantFee(s.sdkCtx, constantFee)
s.Require().NoError(err)
@ -64,7 +65,7 @@ func (s *GenesisTestSuite) TestImportExportGenesis() {
func (s *GenesisTestSuite) TestInitGenesis() {
genesisState := types.DefaultGenesisState()
genesisState.ConstantFee = sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000))
genesisState.ConstantFee = sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(1000))
s.keeper.InitGenesis(s.sdkCtx, genesisState)
constantFee := s.keeper.GetConstantFee(s.sdkCtx)

3
x/crisis/keeper/msg_server_test.go
View File

@ -6,6 +6,7 @@ import (
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/suite"
sdkmath "cosmossdk.io/math"
storetypes "cosmossdk.io/store/types"
"github.com/cosmos/cosmos-sdk/testutil"
@ -143,7 +144,7 @@ func (s *KeeperTestSuite) TestMsgUpdateParams() {
name: "negative constant fee",
input: &types.MsgUpdateParams{
Authority: s.keeper.GetAuthority(),
ConstantFee: sdk.Coin{Denom: sdk.DefaultBondDenom, Amount: sdk.NewInt(-1000)},
ConstantFee: sdk.Coin{Denom: sdk.DefaultBondDenom, Amount: sdkmath.NewInt(-1000)},
},
expErr: true,
},

6
x/crisis/keeper/params_test.go
View File

@ -1,12 +1,14 @@
package keeper_test
import (
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
)
func (s *KeeperTestSuite) TestParams() {
// default params
constantFee := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000))
constantFee := sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(1000))
testCases := []struct {
name string
@ -21,7 +23,7 @@ func (s *KeeperTestSuite) TestParams() {
},
{
name: "negative constant fee",
constantFee: sdk.Coin{Denom: sdk.DefaultBondDenom, Amount: sdk.NewInt(-1000)},
constantFee: sdk.Coin{Denom: sdk.DefaultBondDenom, Amount: sdkmath.NewInt(-1000)},
expErr: true,
},
{

4
x/crisis/types/genesis.go
View File

@ -3,6 +3,8 @@ package types
import (
"fmt"
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
)
@ -16,7 +18,7 @@ func NewGenesisState(constantFee sdk.Coin) *GenesisState {
// DefaultGenesisState creates a default GenesisState object
func DefaultGenesisState() *GenesisState {
return &GenesisState{
ConstantFee: sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000)),
ConstantFee: sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(1000)),
}
}

4
x/distribution/README.md
View File

@ -145,7 +145,7 @@ When coins are distributed from the pool they are truncated back to
type DecCoins []DecCoin
type DecCoin struct {
Amount sdk.Dec
Amount math.LegacyDec
Denom string
}
```
@ -167,7 +167,7 @@ Validator distribution information for the relevant validator is updated each ti
```go
type ValidatorDistInfo struct {
OperatorAddress sdk.AccAddress
SelfBondRewards sdk.DecCoins
SelfBondRewards sdkmath.DecCoins
ValidatorCommission types.ValidatorAccumulatedCommission
}
```

21
x/distribution/client/cli/suite_test.go
View File

@ -7,6 +7,7 @@ import (
"strings"
"testing"
sdkmath "cosmossdk.io/math"
abci "github.com/cometbft/cometbft/abci/types"
rpcclientmock "github.com/cometbft/cometbft/rpc/client/mock"
"github.com/cosmos/gogoproto/proto"
@ -483,7 +484,7 @@ func (s *CLITestSuite) TestNewWithdrawRewardsCmd() {
fmt.Sprintf("--%s=%s", flags.FlagFrom, val[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10))).String()),
},
true, nil,
},
@ -494,7 +495,7 @@ func (s *CLITestSuite) TestNewWithdrawRewardsCmd() {
fmt.Sprintf("--%s=%s", flags.FlagFrom, val[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10))).String()),
},
false, &sdk.TxResponse{},
},
@ -506,7 +507,7 @@ func (s *CLITestSuite) TestNewWithdrawRewardsCmd() {
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=true", cli.FlagCommission),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10))).String()),
},
false, &sdk.TxResponse{},
},
@ -543,7 +544,7 @@ func (s *CLITestSuite) TestNewWithdrawAllRewardsCmd() {
fmt.Sprintf("--%s=%s", flags.FlagFrom, val[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagOffline),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10))).String()),
},
true,
"cannot generate tx in offline mode",
@ -555,7 +556,7 @@ func (s *CLITestSuite) TestNewWithdrawAllRewardsCmd() {
fmt.Sprintf("--%s=%s", flags.FlagFrom, val[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10))).String()),
},
false, "", &sdk.TxResponse{},
},
@ -595,7 +596,7 @@ func (s *CLITestSuite) TestNewSetWithdrawAddrCmd() {
fmt.Sprintf("--%s=%s", flags.FlagFrom, val[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10))).String()),
},
true, nil,
},
@ -606,7 +607,7 @@ func (s *CLITestSuite) TestNewSetWithdrawAddrCmd() {
fmt.Sprintf("--%s=%s", flags.FlagFrom, val[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10))).String()),
},
false, &sdk.TxResponse{},
},
@ -645,18 +646,18 @@ func (s *CLITestSuite) TestNewFundCommunityPoolCmd() {
fmt.Sprintf("--%s=%s", flags.FlagFrom, val[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10))).String()),
},
true, nil,
},
{
"valid transaction",
[]string{
sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(5431))).String(),
sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(5431))).String(),
fmt.Sprintf("--%s=%s", flags.FlagFrom, val[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))).String()),
fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10))).String()),
},
false, &sdk.TxResponse{},
},

24
x/distribution/keeper/allocation_test.go
View File

@ -49,7 +49,7 @@ func TestAllocateTokensToValidatorWithCommission(t *testing.T) {
// create validator with 50% commission
val, err := distrtestutil.CreateValidator(valConsPk0, math.NewInt(100))
require.NoError(t, err)
val.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0))
val.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDec(0))
stakingKeeper.EXPECT().ValidatorByConsAddr(gomock.Any(), sdk.GetConsAddress(valConsPk0)).Return(val).AnyTimes()
// allocate tokens
@ -101,7 +101,7 @@ func TestAllocateTokensToManyValidators(t *testing.T) {
valAddr0 := sdk.ValAddress(valConsAddr0)
val0, err := distrtestutil.CreateValidator(valConsPk0, math.NewInt(100))
require.NoError(t, err)
val0.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0))
val0.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDec(0))
stakingKeeper.EXPECT().ValidatorByConsAddr(gomock.Any(), sdk.GetConsAddress(valConsPk0)).Return(val0).AnyTimes()
// create second validator with 0% commission
@ -130,7 +130,7 @@ func TestAllocateTokensToManyValidators(t *testing.T) {
require.True(t, distrKeeper.GetValidatorCurrentRewards(ctx, valAddr1).Rewards.IsZero())
// allocate tokens as if both had voted and second was proposer
fees := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100)))
fees := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(100)))
bankKeeper.EXPECT().GetAllBalances(gomock.Any(), feeCollectorAcc.GetAddress()).Return(fees)
bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), "fee_collector", disttypes.ModuleName, fees)
@ -147,23 +147,23 @@ func TestAllocateTokensToManyValidators(t *testing.T) {
distrKeeper.AllocateTokens(ctx, 200, votes)
// 98 outstanding rewards (100 less 2 to community pool)
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecWithPrec(490, 1)}}, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddr0).Rewards)
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecWithPrec(490, 1)}}, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddr1).Rewards)
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDecWithPrec(490, 1)}}, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddr0).Rewards)
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDecWithPrec(490, 1)}}, distrKeeper.GetValidatorOutstandingRewards(ctx, valAddr1).Rewards)
// 2 community pool coins
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDec(2)}}, distrKeeper.GetFeePool(ctx).CommunityPool)
// 50% commission for first proposer, (0.5 * 98%) * 100 / 2 = 23.25
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecWithPrec(2450, 2)}}, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddr0).Commission)
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDecWithPrec(2450, 2)}}, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddr0).Commission)
// zero commission for second proposer
require.True(t, distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddr1).Commission.IsZero())
// just staking.proportional for first proposer less commission = (0.5 * 98%) * 100 / 2 = 24.50
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecWithPrec(2450, 2)}}, distrKeeper.GetValidatorCurrentRewards(ctx, valAddr0).Rewards)
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDecWithPrec(2450, 2)}}, distrKeeper.GetValidatorCurrentRewards(ctx, valAddr0).Rewards)
// proposer reward + staking.proportional for second proposer = (0.5 * (98%)) * 100 = 49
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecWithPrec(490, 1)}}, distrKeeper.GetValidatorCurrentRewards(ctx, valAddr1).Rewards)
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDecWithPrec(490, 1)}}, distrKeeper.GetValidatorCurrentRewards(ctx, valAddr1).Rewards)
}
func TestAllocateTokensTruncation(t *testing.T) {
@ -199,21 +199,21 @@ func TestAllocateTokensTruncation(t *testing.T) {
valAddr0 := sdk.ValAddress(valConsAddr0)
val0, err := distrtestutil.CreateValidator(valConsPk0, math.NewInt(100))
require.NoError(t, err)
val0.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(1, 1), sdk.NewDecWithPrec(1, 1), math.LegacyNewDec(0))
val0.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(1, 1), math.LegacyNewDecWithPrec(1, 1), math.LegacyNewDec(0))
stakingKeeper.EXPECT().ValidatorByConsAddr(gomock.Any(), sdk.GetConsAddress(valConsPk0)).Return(val0).AnyTimes()
// create second validator with 10% commission
valAddr1 := sdk.ValAddress(valConsAddr1)
val1, err := distrtestutil.CreateValidator(valConsPk1, math.NewInt(100))
require.NoError(t, err)
val1.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(1, 1), sdk.NewDecWithPrec(1, 1), math.LegacyNewDec(0))
val1.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(1, 1), math.LegacyNewDecWithPrec(1, 1), math.LegacyNewDec(0))
stakingKeeper.EXPECT().ValidatorByConsAddr(gomock.Any(), sdk.GetConsAddress(valConsPk1)).Return(val1).AnyTimes()
// create third validator with 10% commission
valAddr2 := sdk.ValAddress(valConsAddr2)
val2, err := stakingtypes.NewValidator(sdk.ValAddress(valConsAddr2), valConsPk1, stakingtypes.Description{})
require.NoError(t, err)
val2.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(1, 1), sdk.NewDecWithPrec(1, 1), math.LegacyNewDec(0))
val2.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(1, 1), math.LegacyNewDecWithPrec(1, 1), math.LegacyNewDec(0))
stakingKeeper.EXPECT().ValidatorByConsAddr(gomock.Any(), sdk.GetConsAddress(valConsPk2)).Return(val2).AnyTimes()
abciValA := abci.Validator{
@ -240,7 +240,7 @@ func TestAllocateTokensTruncation(t *testing.T) {
require.True(t, distrKeeper.GetValidatorCurrentRewards(ctx, valAddr1).Rewards.IsZero())
// allocate tokens as if both had voted and second was proposer
fees := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(634195840)))
fees := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(634195840)))
bankKeeper.EXPECT().GetAllBalances(gomock.Any(), feeCollectorAcc.GetAddress()).Return(fees)
bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), "fee_collector", disttypes.ModuleName, fees)

2
x/distribution/keeper/delegation.go
View File

@ -30,7 +30,7 @@ func (k Keeper) initializeDelegation(ctx sdk.Context, val sdk.ValAddress, del sd
// calculate the rewards accrued by a delegation between two periods
func (k Keeper) calculateDelegationRewardsBetween(ctx sdk.Context, val stakingtypes.ValidatorI,
startingPeriod, endingPeriod uint64, stake sdk.Dec,
startingPeriod, endingPeriod uint64, stake math.LegacyDec,
) (rewards sdk.DecCoins) {
// sanity check
if startingPeriod > endingPeriod {

60
x/distribution/keeper/delegation_test.go
View File

@ -51,9 +51,9 @@ func TestCalculateRewardsBasic(t *testing.T) {
// create validator with 50% commission
valAddr := sdk.ValAddress(valConsAddr0)
addr := sdk.AccAddress(valAddr)
val, err := distrtestutil.CreateValidator(valConsPk0, sdk.NewInt(1000))
val, err := distrtestutil.CreateValidator(valConsPk0, math.NewInt(1000))
require.NoError(t, err)
val.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0))
val.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDec(0))
// delegation mock
del := stakingtypes.NewDelegation(addr, valAddr, val.DelegatorShares)
@ -133,7 +133,7 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
stake := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
val, err := distrtestutil.CreateValidator(valConsPk0, stake)
require.NoError(t, err)
val.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0))
val.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDec(0))
del := stakingtypes.NewDelegation(addr, valAddr, val.DelegatorShares)
@ -166,7 +166,7 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
valConsAddr0,
ctx.BlockHeight(),
valPower,
sdk.NewDecWithPrec(5, 1),
math.LegacyNewDecWithPrec(5, 1),
&val,
&distrKeeper,
)
@ -177,7 +177,7 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
// allocate some rewards
initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial)}}
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDecFromInt(initial)}}
distrKeeper.AllocateTokensToValidator(ctx, val, tokens)
// end period
@ -187,10 +187,10 @@ func TestCalculateRewardsAfterSlash(t *testing.T) {
rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del, endingPeriod)
// rewards should be half the tokens
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial.QuoRaw(2))}}, rewards)
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDecFromInt(initial.QuoRaw(2))}}, rewards)
// commission should be the other half
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial.QuoRaw(2))}},
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDecFromInt(initial.QuoRaw(2))}},
distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddr).Commission)
}
@ -228,7 +228,7 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
stake := sdk.TokensFromConsensusPower(valPower, sdk.DefaultPowerReduction)
val, err := distrtestutil.CreateValidator(valConsPk0, stake)
require.NoError(t, err)
val.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0))
val.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDec(0))
// delegation mocks
del := stakingtypes.NewDelegation(addr, valAddr, val.DelegatorShares)
@ -260,7 +260,7 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
valConsAddr0,
ctx.BlockHeight(),
valPower,
sdk.NewDecWithPrec(5, 1),
math.LegacyNewDecWithPrec(5, 1),
&val,
&distrKeeper,
)
@ -274,7 +274,7 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
// allocate some rewards
initial := sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial)}}
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDecFromInt(initial)}}
distrKeeper.AllocateTokensToValidator(ctx, val, tokens)
// slash the validator by 50% again
@ -283,7 +283,7 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
valConsAddr0,
ctx.BlockHeight(),
valPower/2,
sdk.NewDecWithPrec(2, 1),
math.LegacyNewDecWithPrec(2, 1),
&val,
&distrKeeper,
)
@ -302,10 +302,10 @@ func TestCalculateRewardsAfterManySlashes(t *testing.T) {
rewards = distrKeeper.CalculateDelegationRewards(ctx, val, del, endingPeriod)
// rewards should be half the tokens
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial)}}, rewards)
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDecFromInt(initial)}}, rewards)
// commission should be the other half
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: sdk.NewDecFromInt(initial)}},
require.Equal(t, sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: math.LegacyNewDecFromInt(initial)}},
distrKeeper.GetValidatorAccumulatedCommission(ctx, valAddr).Commission)
}
@ -342,7 +342,7 @@ func TestCalculateRewardsMultiDelegator(t *testing.T) {
val, err := distrtestutil.CreateValidator(valConsPk0, math.NewInt(100))
require.NoError(t, err)
val.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0))
val.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDec(0))
del0 := stakingtypes.NewDelegation(addr0, valAddr, val.DelegatorShares)
@ -364,7 +364,7 @@ func TestCalculateRewardsMultiDelegator(t *testing.T) {
// second delegation
addr1 := sdk.AccAddress(valConsAddr1)
_, del1, err := distrtestutil.Delegate(ctx, distrKeeper, addr1, &val, sdk.NewInt(100), nil)
_, del1, err := distrtestutil.Delegate(ctx, distrKeeper, addr1, &val, math.NewInt(100), nil)
require.NoError(t, err)
stakingKeeper.EXPECT().Delegation(gomock.Any(), addr1, valAddr).Return(del1)
@ -432,7 +432,7 @@ func TestWithdrawDelegationRewardsBasic(t *testing.T) {
val, err := distrtestutil.CreateValidator(valConsPk0, math.NewInt(100))
require.NoError(t, err)
val.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0))
val.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDec(0))
// delegation mock
del := stakingtypes.NewDelegation(addr, valAddr, val.DelegatorShares)
@ -504,7 +504,7 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
val, err := distrtestutil.CreateValidator(valConsPk0, math.NewInt(100))
require.NoError(t, err)
val.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0))
val.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDec(0))
// delegation mock
del := stakingtypes.NewDelegation(addr, valAddr, val.DelegatorShares)
@ -531,7 +531,7 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 3)
// allocate some rewards
initial := sdk.NewDecFromInt(sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))
initial := math.LegacyNewDecFromInt(sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction))
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}
distrKeeper.AllocateTokensToValidator(ctx, val, tokens)
@ -542,19 +542,19 @@ func TestCalculateRewardsAfterManySlashesInSameBlock(t *testing.T) {
valConsAddr0,
ctx.BlockHeight(),
valPower,
sdk.NewDecWithPrec(5, 1),
math.LegacyNewDecWithPrec(5, 1),
&val,
&distrKeeper,
)
// slash the validator by 50% again
// stakingKeeper.Slash(ctx, valConsAddr0, ctx.BlockHeight(), valPower/2, sdk.NewDecWithPrec(5, 1))
// stakingKeeper.Slash(ctx, valConsAddr0, ctx.BlockHeight(), valPower/2, math.LegacyNewDecWithPrec(5, 1))
distrtestutil.SlashValidator(
ctx,
valConsAddr0,
ctx.BlockHeight(),
valPower/2,
sdk.NewDecWithPrec(5, 1),
math.LegacyNewDecWithPrec(5, 1),
&val,
&distrKeeper,
)
@ -612,7 +612,7 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
addr := sdk.AccAddress(valAddr)
val, err := distrtestutil.CreateValidator(valConsPk0, sdk.TokensFromConsensusPower(valPower, sdk.DefaultPowerReduction))
require.NoError(t, err)
val.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0))
val.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDec(0))
// validator and delegation mocks
del := stakingtypes.NewDelegation(addr, valAddr, val.DelegatorShares)
@ -628,7 +628,7 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1)
// allocate some rewards
initial := sdk.NewDecFromInt(sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction))
initial := math.LegacyNewDecFromInt(sdk.TokensFromConsensusPower(30, sdk.DefaultPowerReduction))
tokens := sdk.DecCoins{{Denom: sdk.DefaultBondDenom, Amount: initial}}
distrKeeper.AllocateTokensToValidator(ctx, val, tokens)
@ -639,7 +639,7 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
valConsAddr0,
ctx.BlockHeight(),
valPower,
sdk.NewDecWithPrec(5, 1),
math.LegacyNewDecWithPrec(5, 1),
&val,
&distrKeeper,
)
@ -680,7 +680,7 @@ func TestCalculateRewardsMultiDelegatorMultiSlash(t *testing.T) {
valConsAddr0,
ctx.BlockHeight(),
valPower,
sdk.NewDecWithPrec(5, 1),
math.LegacyNewDecWithPrec(5, 1),
&val,
&distrKeeper,
)
@ -735,9 +735,9 @@ func TestCalculateRewardsMultiDelegatorMultWithdraw(t *testing.T) {
// create validator with 50% commission
valAddr := sdk.ValAddress(valConsAddr0)
addr := sdk.AccAddress(valAddr)
val, err := distrtestutil.CreateValidator(valConsPk0, sdk.NewInt(100))
val, err := distrtestutil.CreateValidator(valConsPk0, math.NewInt(100))
require.NoError(t, err)
val.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(5, 1), sdk.NewDecWithPrec(5, 1), math.LegacyNewDec(0))
val.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDecWithPrec(5, 1), math.LegacyNewDec(0))
// validator and delegation mocks
del := stakingtypes.NewDelegation(addr, valAddr, val.DelegatorShares)
@ -766,7 +766,7 @@ func TestCalculateRewardsMultiDelegatorMultWithdraw(t *testing.T) {
distrKeeper,
sdk.AccAddress(valConsAddr1),
&val,
sdk.NewInt(100),
math.NewInt(100),
nil,
)
require.NoError(t, err)
@ -918,9 +918,9 @@ func Test100PercentCommissionReward(t *testing.T) {
// create validator with 50% commission
valAddr := sdk.ValAddress(valConsAddr0)
addr := sdk.AccAddress(valAddr)
val, err := distrtestutil.CreateValidator(valConsPk0, sdk.NewInt(100))
val, err := distrtestutil.CreateValidator(valConsPk0, math.NewInt(100))
require.NoError(t, err)
val.Commission = stakingtypes.NewCommission(sdk.NewDecWithPrec(10, 1), sdk.NewDecWithPrec(10, 1), math.LegacyNewDec(0))
val.Commission = stakingtypes.NewCommission(math.LegacyNewDecWithPrec(10, 1), math.LegacyNewDecWithPrec(10, 1), math.LegacyNewDec(0))
// validator and delegation mocks
del := stakingtypes.NewDelegation(addr, valAddr, val.DelegatorShares)

4
x/distribution/keeper/hooks.go
View File

@ -1,6 +1,8 @@
package keeper
import (
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/distribution/types"
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
@ -106,7 +108,7 @@ func (h Hooks) AfterDelegationModified(ctx sdk.Context, delAddr sdk.AccAddress,
}
// record the slash event
func (h Hooks) BeforeValidatorSlashed(ctx sdk.Context, valAddr sdk.ValAddress, fraction sdk.Dec) error {
func (h Hooks) BeforeValidatorSlashed(ctx sdk.Context, valAddr sdk.ValAddress, fraction sdkmath.LegacyDec) error {
h.k.updateValidatorSlashFraction(ctx, valAddr, fraction)
return nil
}

2
x/distribution/keeper/keeper_test.go
View File

@ -106,7 +106,7 @@ func TestWithdrawValidatorCommission(t *testing.T) {
distrKeeper.SetValidatorAccumulatedCommission(ctx, valAddr, types.ValidatorAccumulatedCommission{Commission: valCommission})
// withdraw commission
coins := sdk.NewCoins(sdk.NewCoin("mytoken", sdk.NewInt(1)), sdk.NewCoin("stake", sdk.NewInt(1)))
coins := sdk.NewCoins(sdk.NewCoin("mytoken", math.NewInt(1)), sdk.NewCoin("stake", math.NewInt(1)))
// if SendCoinsFromModuleToAccount is called, we know that the withdraw was successful
bankKeeper.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), "distribution", addrs[0], coins).Return(nil)

28
x/distribution/keeper/params_test.go
View File

@ -3,13 +3,13 @@ package keeper_test
import (
"testing"
sdkmath "cosmossdk.io/math"
storetypes "cosmossdk.io/store/types"
cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/testutil"
sdk "github.com/cosmos/cosmos-sdk/types"
moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
"github.com/cosmos/cosmos-sdk/x/distribution"
@ -42,7 +42,7 @@ func TestParams(t *testing.T) {
)
// default params
communityTax := sdk.NewDecWithPrec(2, 2) // 2%
communityTax := sdkmath.LegacyNewDecWithPrec(2, 2) // 2%
withdrawAddrEnabled := true
testCases := []struct {
@ -54,9 +54,9 @@ func TestParams(t *testing.T) {
{
name: "community tax > 1",
input: types.Params{
CommunityTax: sdk.NewDecWithPrec(2, 0),
BaseProposerReward: sdk.ZeroDec(),
BonusProposerReward: sdk.ZeroDec(),
CommunityTax: sdkmath.LegacyNewDecWithPrec(2, 0),
BaseProposerReward: sdkmath.LegacyZeroDec(),
BonusProposerReward: sdkmath.LegacyZeroDec(),
WithdrawAddrEnabled: withdrawAddrEnabled,
},
expErr: true,
@ -65,9 +65,9 @@ func TestParams(t *testing.T) {
{
name: "negative community tax",
input: types.Params{
CommunityTax: sdk.NewDecWithPrec(-2, 1),
BaseProposerReward: sdk.ZeroDec(),
BonusProposerReward: sdk.ZeroDec(),
CommunityTax: sdkmath.LegacyNewDecWithPrec(-2, 1),
BaseProposerReward: sdkmath.LegacyZeroDec(),
BonusProposerReward: sdkmath.LegacyZeroDec(),
WithdrawAddrEnabled: withdrawAddrEnabled,
},
expErr: true,
@ -77,8 +77,8 @@ func TestParams(t *testing.T) {
name: "base proposer reward > 1",
input: types.Params{
CommunityTax: communityTax,
BaseProposerReward: sdk.NewDecWithPrec(1, 2),
BonusProposerReward: sdk.ZeroDec(),
BaseProposerReward: sdkmath.LegacyNewDecWithPrec(1, 2),
BonusProposerReward: sdkmath.LegacyZeroDec(),
WithdrawAddrEnabled: withdrawAddrEnabled,
},
expErr: false,
@ -88,8 +88,8 @@ func TestParams(t *testing.T) {
name: "bonus proposer reward > 1",
input: types.Params{
CommunityTax: communityTax,
BaseProposerReward: sdk.NewDecWithPrec(1, 2),
BonusProposerReward: sdk.ZeroDec(),
BaseProposerReward: sdkmath.LegacyNewDecWithPrec(1, 2),
BonusProposerReward: sdkmath.LegacyZeroDec(),
WithdrawAddrEnabled: withdrawAddrEnabled,
},
expErr: false,
@ -99,8 +99,8 @@ func TestParams(t *testing.T) {
name: "all good",
input: types.Params{
CommunityTax: communityTax,
BaseProposerReward: sdk.ZeroDec(),
BonusProposerReward: sdk.ZeroDec(),
BaseProposerReward: sdkmath.LegacyZeroDec(),
BonusProposerReward: sdkmath.LegacyZeroDec(),
WithdrawAddrEnabled: withdrawAddrEnabled,
},
expErr: false,

2
x/distribution/keeper/validator.go
View File

@ -46,7 +46,7 @@ func (k Keeper) IncrementValidatorPeriod(ctx sdk.Context, val stakingtypes.Valid
current = sdk.DecCoins{}
} else {
// note: necessary to truncate so we don't allow withdrawing more rewards than owed
current = rewards.Rewards.QuoDecTruncate(sdk.NewDecFromInt(val.GetTokens()))
current = rewards.Rewards.QuoDecTruncate(math.LegacyNewDecFromInt(val.GetTokens()))
}
// fetch historical rewards for last period

6
x/distribution/migrations/v3/json.go
View File

@ -1,7 +1,7 @@
package v3
import (
sdk "github.com/cosmos/cosmos-sdk/types"
sdkmath "cosmossdk.io/math"
"github.com/cosmos/cosmos-sdk/x/distribution/types"
)
@ -11,8 +11,8 @@ import (
// Reset of the deprecated rewards to zero.
func MigrateJSON(oldState *types.GenesisState) *types.GenesisState {
// reset deprecated rewards to zero
oldState.Params.BaseProposerReward = sdk.ZeroDec()
oldState.Params.BonusProposerReward = sdk.ZeroDec()
oldState.Params.BaseProposerReward = sdkmath.LegacyZeroDec()
oldState.Params.BonusProposerReward = sdkmath.LegacyZeroDec()
return oldState
}

6
x/distribution/migrations/v3/json_test.go
View File

@ -4,10 +4,10 @@ import (
"encoding/json"
"testing"
sdkmath "cosmossdk.io/math"
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/client"
sdk "github.com/cosmos/cosmos-sdk/types"
moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
"github.com/cosmos/cosmos-sdk/x/distribution"
v3 "github.com/cosmos/cosmos-sdk/x/distribution/migrations/v3"
@ -24,8 +24,8 @@ func TestMigrateJSON(t *testing.T) {
distrGenState := types.DefaultGenesisState()
oldDistrState := distrGenState
oldDistrState.Params.BaseProposerReward = sdk.NewDecWithPrec(1, 2)
oldDistrState.Params.BonusProposerReward = sdk.NewDecWithPrec(4, 2)
oldDistrState.Params.BaseProposerReward = sdkmath.LegacyNewDecWithPrec(1, 2)
oldDistrState.Params.BonusProposerReward = sdkmath.LegacyNewDecWithPrec(4, 2)
migrated := v3.MigrateJSON(oldDistrState)
require.Equal(t, migrated, distrGenState)

6
x/distribution/migrations/v3/migrate.go
View File

@ -3,6 +3,8 @@ package v3
import (
storetypes "cosmossdk.io/store/types"
sdkmath "cosmossdk.io/math"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/distribution/exported"
@ -25,8 +27,8 @@ func MigrateStore(ctx sdk.Context, storeKey storetypes.StoreKey, legacySubspace
legacySubspace.GetParamSet(ctx, &currParams)
// reset unused params
currParams.BaseProposerReward = sdk.ZeroDec()
currParams.BonusProposerReward = sdk.ZeroDec()
currParams.BaseProposerReward = sdkmath.LegacyZeroDec()
currParams.BonusProposerReward = sdkmath.LegacyZeroDec()
if err := currParams.ValidateBasic(); err != nil {
return err

5
x/distribution/simulation/genesis.go
View File

@ -6,7 +6,6 @@ import (
"math/rand"
"cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/module"
"github.com/cosmos/cosmos-sdk/x/distribution/types"
)
@ -19,7 +18,7 @@ const (
// GenCommunityTax randomized CommunityTax
func GenCommunityTax(r *rand.Rand) math.LegacyDec {
return sdk.NewDecWithPrec(1, 2).Add(sdk.NewDecWithPrec(int64(r.Intn(30)), 2))
return math.LegacyNewDecWithPrec(1, 2).Add(math.LegacyNewDecWithPrec(int64(r.Intn(30)), 2))
}
// GenWithdrawEnabled returns a randomized WithdrawEnabled parameter.
@ -29,7 +28,7 @@ func GenWithdrawEnabled(r *rand.Rand) bool {
// RandomizedGenState generates a random GenesisState for distribution
func RandomizedGenState(simState *module.SimulationState) {
var communityTax sdk.Dec
var communityTax math.LegacyDec
simState.AppParams.GetOrGenerate(
simState.Cdc, CommunityTax, &communityTax, simState.Rand,
func(r *rand.Rand) { communityTax = GenCommunityTax(r) },

3
x/distribution/simulation/genesis_test.go
View File

@ -10,7 +10,6 @@ import (
sdkmath "cosmossdk.io/math"
"github.com/cosmos/cosmos-sdk/codec"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/module"
simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
"github.com/cosmos/cosmos-sdk/x/distribution/simulation"
@ -40,7 +39,7 @@ func TestRandomizedGenState(t *testing.T) {
var distrGenesis types.GenesisState
simState.Cdc.MustUnmarshalJSON(simState.GenState[types.ModuleName], &distrGenesis)
dec1, _ := sdk.NewDecFromStr("0.210000000000000000")
dec1, _ := sdkmath.LegacyNewDecFromStr("0.210000000000000000")
require.Equal(t, dec1, distrGenesis.Params.CommunityTax)
require.Equal(t, true, distrGenesis.Params.WithdrawAddrEnabled)

6
x/distribution/simulation/operations_test.go
View File

@ -149,8 +149,8 @@ func (suite *SimTestSuite) testSimulateMsgWithdrawValidatorCommission(tokenName
// set module account coins
distrAcc := suite.distrKeeper.GetDistributionAccount(suite.ctx)
suite.Require().NoError(banktestutil.FundModuleAccount(suite.bankKeeper, suite.ctx, distrAcc.GetName(), sdk.NewCoins(
sdk.NewCoin(tokenName, sdk.NewInt(10)),
sdk.NewCoin("stake", sdk.NewInt(5)),
sdk.NewCoin(tokenName, math.NewInt(10)),
sdk.NewCoin("stake", math.NewInt(5)),
)))
suite.accountKeeper.SetModuleAccount(suite.ctx, distrAcc)
@ -284,7 +284,7 @@ func (suite *SimTestSuite) getTestingValidator(accounts []simtypes.Account, comm
validator, err = validator.SetInitialCommission(commission)
require.NoError(err)
validator.DelegatorShares = math.LegacyNewDec(100)
validator.Tokens = sdk.NewInt(1000000)
validator.Tokens = math.NewInt(1000000)
suite.stakingKeeper.SetValidator(suite.ctx, validator)

4
x/distribution/simulation/proposals.go
View File

@ -3,6 +3,8 @@ package simulation
import (
"math/rand"
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/address"
simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
@ -34,7 +36,7 @@ func SimulateMsgUpdateParams(r *rand.Rand, _ sdk.Context, _ []simtypes.Account)
var authority sdk.AccAddress = address.Module("gov")
params := types.DefaultParams()
params.CommunityTax = simtypes.RandomDecAmount(r, sdk.NewDec(1))
params.CommunityTax = simtypes.RandomDecAmount(r, sdkmath.LegacyNewDec(1))
params.WithdrawAddrEnabled = r.Intn(2) == 0
return &types.MsgUpdateParams{

3
x/distribution/simulation/proposals_test.go
View File

@ -4,6 +4,7 @@ import (
"math/rand"
"testing"
sdkmath "cosmossdk.io/math"
cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
"gotest.tools/v3/assert"
@ -37,6 +38,6 @@ func TestProposalMsgs(t *testing.T) {
assert.Assert(t, ok)
assert.Equal(t, sdk.AccAddress(address.Module("gov")).String(), msgUpdateParams.Authority)
assert.DeepEqual(t, sdk.NewDec(0), msgUpdateParams.Params.CommunityTax)
assert.DeepEqual(t, sdkmath.LegacyNewDec(0), msgUpdateParams.Params.CommunityTax)
assert.Equal(t, true, msgUpdateParams.Params.WithdrawAddrEnabled)
}

12
x/distribution/testutil/staking_helper.go
View File

@ -45,7 +45,7 @@ func SlashValidator(
consAddr sdk.ConsAddress,
infractionHeight int64,
power int64,
slashFactor sdk.Dec,
slashFactor math.LegacyDec,
validator *stakingtypes.Validator,
distrKeeper *keeper.Keeper,
) math.Int {
@ -67,16 +67,16 @@ func SlashValidator(
panic("we can't test any other case here")
}
slashAmountDec := sdk.NewDecFromInt(validator.Tokens).Mul(sdk.NewDecWithPrec(5, 1))
slashAmountDec := math.LegacyNewDecFromInt(validator.Tokens).Mul(math.LegacyNewDecWithPrec(5, 1))
slashAmount := slashAmountDec.TruncateInt()
// cannot decrease balance below zero
tokensToBurn := sdk.MinInt(slashAmount, validator.Tokens)
tokensToBurn = sdk.MaxInt(tokensToBurn, math.ZeroInt()) // defensive.
tokensToBurn := math.MinInt(slashAmount, validator.Tokens)
tokensToBurn = math.MaxInt(tokensToBurn, math.ZeroInt()) // defensive.
// we need to calculate the *effective* slash fraction for distribution
if validator.Tokens.IsPositive() {
effectiveFraction := sdk.NewDecFromInt(tokensToBurn).QuoRoundUp(sdk.NewDecFromInt(validator.Tokens))
effectiveFraction := math.LegacyNewDecFromInt(tokensToBurn).QuoRoundUp(math.LegacyNewDecFromInt(validator.Tokens))
// possible if power has changed
if effectiveFraction.GT(math.LegacyOneDec()) {
effectiveFraction = math.LegacyOneDec()
@ -102,7 +102,7 @@ func Delegate(
amount math.Int,
delegation *stakingtypes.Delegation,
) (
newShares sdk.Dec,
newShares math.LegacyDec,
updatedDel stakingtypes.Delegation,
err error,
) {

6
x/distribution/types/delegator.go
View File

@ -1,11 +1,9 @@
package types
import (
sdk "github.com/cosmos/cosmos-sdk/types"
)
import sdkmath "cosmossdk.io/math"
// create a new DelegatorStartingInfo
func NewDelegatorStartingInfo(previousPeriod uint64, stake sdk.Dec, height uint64) DelegatorStartingInfo {
func NewDelegatorStartingInfo(previousPeriod uint64, stake sdkmath.LegacyDec, height uint64) DelegatorStartingInfo {
return DelegatorStartingInfo{
PreviousPeriod: previousPeriod,
Stake: stake,

10
x/distribution/types/params.go
View File

@ -4,16 +4,14 @@ import (
"fmt"
"cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
)
// DefaultParams returns default distribution parameters
func DefaultParams() Params {
return Params{
CommunityTax: sdk.NewDecWithPrec(2, 2), // 2%
BaseProposerReward: sdk.ZeroDec(), // deprecated
BonusProposerReward: sdk.ZeroDec(), // deprecated
CommunityTax: math.LegacyNewDecWithPrec(2, 2), // 2%
BaseProposerReward: math.LegacyZeroDec(), // deprecated
BonusProposerReward: math.LegacyZeroDec(), // deprecated
WithdrawAddrEnabled: true,
}
}
@ -30,7 +28,7 @@ func (p Params) ValidateBasic() error {
}
func validateCommunityTax(i interface{}) error {
v, ok := i.(sdk.Dec)
v, ok := i.(math.LegacyDec)
if !ok {
return fmt.Errorf("invalid parameter type: %T", i)
}

4
x/distribution/types/params_internal_test.go
View File

@ -5,8 +5,6 @@ import (
"cosmossdk.io/math"
"github.com/stretchr/testify/require"
sdk "github.com/cosmos/cosmos-sdk/types"
)
func Test_validateAuxFuncs(t *testing.T) {
@ -19,7 +17,7 @@ func Test_validateAuxFuncs(t *testing.T) {
wantErr bool
}{
{"wrong type", args{10.5}, true},
{"empty sdk.Dec", args{sdk.Dec{}}, true},
{"empty math.LegacyDec", args{math.LegacyDec{}}, true},
{"negative", args{math.LegacyNewDec(-1)}, true},
{"one dec", args{math.LegacyNewDec(1)}, false},
{"two dec", args{math.LegacyNewDec(2)}, true},

7
x/distribution/types/params_test.go
View File

@ -3,6 +3,7 @@ package types_test
import (
"testing"
sdkmath "cosmossdk.io/math"
"github.com/stretchr/testify/require"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -13,9 +14,9 @@ func TestParams_ValidateBasic(t *testing.T) {
toDec := sdk.MustNewDecFromStr
type fields struct {
CommunityTax sdk.Dec
BaseProposerReward sdk.Dec
BonusProposerReward sdk.Dec
CommunityTax sdkmath.LegacyDec
BaseProposerReward sdkmath.LegacyDec
BonusProposerReward sdkmath.LegacyDec
WithdrawAddrEnabled bool
}
tests := []struct {

4
x/distribution/types/validator.go
View File

@ -1,6 +1,8 @@
package types
import (
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
)
@ -26,7 +28,7 @@ func InitialValidatorAccumulatedCommission() ValidatorAccumulatedCommission {
}
// create a new ValidatorSlashEvent
func NewValidatorSlashEvent(validatorPeriod uint64, fraction sdk.Dec) ValidatorSlashEvent {
func NewValidatorSlashEvent(validatorPeriod uint64, fraction sdkmath.LegacyDec) ValidatorSlashEvent {
return ValidatorSlashEvent{
ValidatorPeriod: validatorPeriod,
Fraction: fraction,