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 gov module (#15625)

Browse Source 
Co-authored-by: Marko <marbar3778@yahoo.com>
This commit is contained in:
samricotta 2023-03-31 18:12:28 +02:00 committed by GitHub
parent 9332942f37
commit 43a4db5a9e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 194 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
x/gov/client/cli/tx_test.go
View File

@ -7,6 +7,7 @@ import (
"io"
"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"
@ -124,7 +125,7 @@ func (s *CLITestSuite) TestNewCmdSubmitProposal() {
"summary": "My awesome description",
"metadata": "%s",
"deposit": "%s"
}`, authtypes.NewModuleAddress(types.ModuleName), base64.StdEncoding.EncodeToString(propMetadata), sdk.NewCoin("stake", sdk.NewInt(5431)))
}`, authtypes.NewModuleAddress(types.ModuleName), base64.StdEncoding.EncodeToString(propMetadata), sdk.NewCoin("stake", sdkmath.NewInt(5431)))
validPropFile := testutil.WriteToNewTempFile(s.T(), validProp)
defer validPropFile.Close()
@ -139,7 +140,7 @@ func (s *CLITestSuite) TestNewCmdSubmitProposal() {
[]string{
invalidPropFile.Name(),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
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,
},
@ -150,7 +151,7 @@ func (s *CLITestSuite) TestNewCmdSubmitProposal() {
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{},
},
@ -189,7 +190,7 @@ func (s *CLITestSuite) TestNewCmdSubmitLegacyProposal() {
"description": "Hello, World!",
"type": "Text",
"deposit": "%s"
}`, sdk.NewCoin("stake", sdk.NewInt(5431)))
}`, sdk.NewCoin("stake", sdkmath.NewInt(5431)))
validPropFile := testutil.WriteToNewTempFile(s.T(), validProp)
defer validPropFile.Close()
@ -205,7 +206,7 @@ func (s *CLITestSuite) TestNewCmdSubmitLegacyProposal() {
fmt.Sprintf("--%s=%s", cli.FlagProposal, invalidPropFile.Name()),
fmt.Sprintf("--%s=%s", flags.FlagFrom, val[0].Address.String()),
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
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,
},
@ -214,10 +215,10 @@ func (s *CLITestSuite) TestNewCmdSubmitLegacyProposal() {
[]string{
fmt.Sprintf("--%s='Where is the title!?'", cli.FlagDescription),
fmt.Sprintf("--%s=%s", cli.FlagProposalType, v1beta1.ProposalTypeText),
fmt.Sprintf("--%s=%s", cli.FlagDeposit, sdk.NewCoin("stake", sdk.NewInt(5431)).String()),
fmt.Sprintf("--%s=%s", cli.FlagDeposit, 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.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,
},
@ -229,7 +230,7 @@ func (s *CLITestSuite) TestNewCmdSubmitLegacyProposal() {
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{},
},
@ -239,11 +240,11 @@ func (s *CLITestSuite) TestNewCmdSubmitLegacyProposal() {
fmt.Sprintf("--%s='Text Proposal'", cli.FlagTitle),
fmt.Sprintf("--%s='Where is the title!?'", cli.FlagDescription),
fmt.Sprintf("--%s=%s", cli.FlagProposalType, v1beta1.ProposalTypeText),
fmt.Sprintf("--%s=%s", cli.FlagDeposit, sdk.NewCoin("stake", sdk.NewInt(5431)).String()),
fmt.Sprintf("--%s=%s", cli.FlagDeposit, 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{},
},
@ -277,11 +278,11 @@ func (s *CLITestSuite) TestNewCmdDeposit() {
{
"without proposal id",
[]string{
sdk.NewCoin("stake", sdk.NewInt(10)).String(), // 10stake
sdk.NewCoin("stake", sdkmath.NewInt(10)).String(), // 10stake
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,
},
@ -292,7 +293,7 @@ func (s *CLITestSuite) TestNewCmdDeposit() {
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,
},
@ -300,11 +301,11 @@ func (s *CLITestSuite) TestNewCmdDeposit() {
"deposit on a proposal",
[]string{
"10",
sdk.NewCoin("stake", sdk.NewInt(10)).String(), // 10stake
sdk.NewCoin("stake", sdkmath.NewInt(10)).String(), // 10stake
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,
},
@ -351,7 +352,7 @@ func (s *CLITestSuite) TestNewCmdVote() {
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--metadata=%s", "AQ=="),
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, 3,
},
@ -363,7 +364,7 @@ func (s *CLITestSuite) TestNewCmdVote() {
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, 0,
},
@ -376,7 +377,7 @@ func (s *CLITestSuite) TestNewCmdVote() {
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--metadata=%s", "AQ=="),
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, 0,
},
@ -422,7 +423,7 @@ func (s *CLITestSuite) TestNewCmdWeightedVote() {
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, 3,
},
@ -434,7 +435,7 @@ func (s *CLITestSuite) TestNewCmdWeightedVote() {
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, 0,
},
@ -447,7 +448,7 @@ func (s *CLITestSuite) TestNewCmdWeightedVote() {
fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
fmt.Sprintf("--metadata=%s", "AQ=="),
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, 0,
},
@ -459,7 +460,7 @@ func (s *CLITestSuite) TestNewCmdWeightedVote() {
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, 0,
},
@ -471,7 +472,7 @@ func (s *CLITestSuite) TestNewCmdWeightedVote() {
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, 0,
},

7
x/gov/client/cli/util_test.go
View File

@ -9,6 +9,7 @@ import (
"strings"
"testing"
sdkmath "cosmossdk.io/math"
"github.com/spf13/cobra"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@ -181,19 +182,19 @@ func TestParseSubmitProposal(t *testing.T) {
// ok json
proposal, msgs, deposit, err := parseSubmitProposal(cdc, okJSON.Name())
require.NoError(t, err, "unexpected error")
require.Equal(t, sdk.NewCoins(sdk.NewCoin("test", sdk.NewInt(1000))), deposit)
require.Equal(t, sdk.NewCoins(sdk.NewCoin("test", sdkmath.NewInt(1000))), deposit)
require.Equal(t, base64.StdEncoding.EncodeToString(expectedMetadata), proposal.Metadata)
require.Len(t, msgs, 3)
msg1, ok := msgs[0].(*banktypes.MsgSend)
require.True(t, ok)
require.Equal(t, addr.String(), msg1.FromAddress)
require.Equal(t, addr.String(), msg1.ToAddress)
require.Equal(t, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10))), msg1.Amount)
require.Equal(t, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10))), msg1.Amount)
msg2, ok := msgs[1].(*stakingtypes.MsgDelegate)
require.True(t, ok)
require.Equal(t, addr.String(), msg2.DelegatorAddress)
require.Equal(t, addr.String(), msg2.ValidatorAddress)
require.Equal(t, sdk.NewCoin("stake", sdk.NewInt(10)), msg2.Amount)
require.Equal(t, sdk.NewCoin("stake", sdkmath.NewInt(10)), msg2.Amount)
msg3, ok := msgs[2].(*v1.MsgExecLegacyContent)
require.True(t, ok)
require.Equal(t, addr.String(), msg3.Authority)

4
x/gov/client/testutil/helpers.go
View File

@ -3,6 +3,8 @@ package testutil
import (
"fmt"
sdkmath "cosmossdk.io/math"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/testutil"
@ -14,7 +16,7 @@ import (
var commonArgs = []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()),
}
// MsgSubmitLegacyProposal creates a tx for submit legacy proposal

3
x/gov/client/utils/query_test.go
View File

@ -4,6 +4,7 @@ import (
"context"
"testing"
sdkmath "cosmossdk.io/math"
"github.com/cometbft/cometbft/rpc/client/mock"
coretypes "github.com/cometbft/cometbft/rpc/core/types"
cmttypes "github.com/cometbft/cometbft/types"
@ -67,7 +68,7 @@ func TestGetPaginatedVotes(t *testing.T) {
acc1Msgs := []sdk.Msg{
v1.NewMsgVote(acc1, 0, v1.OptionYes, ""),
v1.NewMsgVote(acc1, 0, v1.OptionYes, ""),
v1.NewMsgDeposit(acc1, 0, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(10)))), // should be ignored
v1.NewMsgDeposit(acc1, 0, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10)))), // should be ignored
}
acc2Msgs := []sdk.Msg{
v1.NewMsgVote(acc2, 0, v1.OptionYes, ""),

3
x/gov/genesis_test.go
View File

@ -3,6 +3,7 @@ package gov_test
import (
"testing"
sdkmath "cosmossdk.io/math"
cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
"github.com/stretchr/testify/require"
@ -24,7 +25,7 @@ func TestImportExportQueues_ErrorUnconsistentState(t *testing.T) {
Amount: sdk.Coins{
sdk.NewCoin(
"stake",
sdk.NewInt(1234),
sdkmath.NewInt(1234),
),
},
},

6
x/gov/keeper/common_test.go
View File

@ -42,7 +42,7 @@ func getTestProposal() []sdk.Msg {
}
return []sdk.Msg{
banktypes.NewMsgSend(govAcct, addr, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(1000)))),
banktypes.NewMsgSend(govAcct, addr, sdk.NewCoins(sdk.NewCoin("stake", math.NewInt(1000)))),
legacyProposalMsg,
}
}
@ -109,7 +109,7 @@ func setupGovKeeper(t *testing.T) (
// locally tracks accounts balances (not modules balances).
func trackMockBalances(bankKeeper *govtestutil.MockBankKeeper, distributionKeeper *govtestutil.MockDistributionKeeper) {
balances := make(map[string]sdk.Coins)
balances[distAcct.String()] = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(0)))
balances[distAcct.String()] = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(0)))
// We don't track module account balances.
bankKeeper.EXPECT().MintCoins(gomock.Any(), minttypes.ModuleName, gomock.Any()).AnyTimes()
@ -139,7 +139,7 @@ func trackMockBalances(bankKeeper *govtestutil.MockBankKeeper, distributionKeepe
return balance
}
}
return sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(0))
return sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(0))
}).AnyTimes()
distributionKeeper.EXPECT().FundCommunityPool(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(func(_ sdk.Context, coins sdk.Coins, sender sdk.AccAddress) error {

3
x/gov/keeper/deposit.go
View File

@ -4,6 +4,7 @@ import (
"fmt"
"cosmossdk.io/errors"
sdkmath "cosmossdk.io/math"
storetypes "cosmossdk.io/store/types"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -171,7 +172,7 @@ func (keeper Keeper) AddDeposit(ctx sdk.Context, proposalID uint64, depositorAdd
// Remaining funds are send back to the depositor.
func (keeper Keeper) ChargeDeposit(ctx sdk.Context, proposalID uint64, destAddress, proposalCancelRate string) error {
store := ctx.KVStore(keeper.storeKey)
rate := sdk.MustNewDecFromStr(proposalCancelRate)
rate := sdkmath.LegacyMustNewDecFromStr(proposalCancelRate)
var cancellationCharges sdk.Coins
for _, deposit := range keeper.GetDeposits(ctx, proposalID) {

64
x/gov/keeper/deposit_test.go
View File

@ -4,7 +4,7 @@ import (
"fmt"
"testing"
"cosmossdk.io/math"
sdkmath "cosmossdk.io/math"
"github.com/stretchr/testify/require"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
@ -46,7 +46,7 @@ func TestDeposits(t *testing.T) {
depositMultiplier = v1.DefaultMinExpeditedDepositTokensRatio
}
TestAddrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(10000000*depositMultiplier))
TestAddrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 2, sdkmath.NewInt(10000000*depositMultiplier))
tp := TestProposal
proposal, err := govKeeper.SubmitProposal(ctx, tp, "", "title", "summary", TestAddrs[0], tc.expedited)
@ -156,79 +156,79 @@ func TestValidateInitialDeposit(t *testing.T) {
expectError bool
}{
"min deposit * initial percent == initial deposit: success": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositPercent: baseDepositTestPercent,
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount*baseDepositTestPercent/100))),
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount*baseDepositTestPercent/100))),
},
"min deposit * initial percent < initial deposit: success": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositPercent: baseDepositTestPercent,
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount*baseDepositTestPercent/100+1))),
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount*baseDepositTestPercent/100+1))),
},
"min deposit * initial percent > initial deposit: error": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositPercent: baseDepositTestPercent,
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount*baseDepositTestPercent/100-1))),
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount*baseDepositTestPercent/100-1))),
expectError: true,
},
"min deposit * initial percent == initial deposit (non-base values and denom): success": {
minDeposit: sdk.NewCoins(sdk.NewCoin("uosmo", sdk.NewInt(56912))),
minDeposit: sdk.NewCoins(sdk.NewCoin("uosmo", sdkmath.NewInt(56912))),
minInitialDepositPercent: 50,
initialDeposit: sdk.NewCoins(sdk.NewCoin("uosmo", sdk.NewInt(56912/2+10))),
initialDeposit: sdk.NewCoins(sdk.NewCoin("uosmo", sdkmath.NewInt(56912/2+10))),
},
"min deposit * initial percent == initial deposit but different denoms: error": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositPercent: baseDepositTestPercent,
initialDeposit: sdk.NewCoins(sdk.NewCoin("uosmo", sdk.NewInt(baseDepositTestAmount*baseDepositTestPercent/100))),
initialDeposit: sdk.NewCoins(sdk.NewCoin("uosmo", sdkmath.NewInt(baseDepositTestAmount*baseDepositTestPercent/100))),
expectError: true,
},
"min deposit * initial percent == initial deposit (multiple coins): success": {
minDeposit: sdk.NewCoins(
sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount)),
sdk.NewCoin("uosmo", sdk.NewInt(baseDepositTestAmount*2))),
sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount)),
sdk.NewCoin("uosmo", sdkmath.NewInt(baseDepositTestAmount*2))),
minInitialDepositPercent: baseDepositTestPercent,
initialDeposit: sdk.NewCoins(
sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount*baseDepositTestPercent/100)),
sdk.NewCoin("uosmo", sdk.NewInt(baseDepositTestAmount*2*baseDepositTestPercent/100)),
sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount*baseDepositTestPercent/100)),
sdk.NewCoin("uosmo", sdkmath.NewInt(baseDepositTestAmount*2*baseDepositTestPercent/100)),
),
},
"min deposit * initial percent > initial deposit (multiple coins): error": {
minDeposit: sdk.NewCoins(
sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount)),
sdk.NewCoin("uosmo", sdk.NewInt(baseDepositTestAmount*2))),
sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount)),
sdk.NewCoin("uosmo", sdkmath.NewInt(baseDepositTestAmount*2))),
minInitialDepositPercent: baseDepositTestPercent,
initialDeposit: sdk.NewCoins(
sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount*baseDepositTestPercent/100)),
sdk.NewCoin("uosmo", sdk.NewInt(baseDepositTestAmount*2*baseDepositTestPercent/100-1)),
sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount*baseDepositTestPercent/100)),
sdk.NewCoin("uosmo", sdkmath.NewInt(baseDepositTestAmount*2*baseDepositTestPercent/100-1)),
),
expectError: true,
},
"min deposit * initial percent < initial deposit (multiple coins - coin not required by min deposit): success": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositPercent: baseDepositTestPercent,
initialDeposit: sdk.NewCoins(
sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount*baseDepositTestPercent/100)),
sdk.NewCoin("uosmo", sdk.NewInt(baseDepositTestAmount*baseDepositTestPercent/100-1)),
sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount*baseDepositTestPercent/100)),
sdk.NewCoin("uosmo", sdkmath.NewInt(baseDepositTestAmount*baseDepositTestPercent/100-1)),
),
},
"0 initial percent: success": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositPercent: 0,
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount*baseDepositTestPercent/100))),
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount*baseDepositTestPercent/100))),
},
"expedited min deposit * initial percent == initial deposit: success": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositPercent: baseDepositTestPercent,
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount*baseDepositTestPercent/100))),
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount*baseDepositTestPercent/100))),
expedited: true,
},
"expedited - 0 initial percent: success": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositPercent: 0,
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount*baseDepositTestPercent/100))),
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount*baseDepositTestPercent/100))),
expedited: true,
},
}
@ -243,7 +243,7 @@ func TestValidateInitialDeposit(t *testing.T) {
} else {
params.MinDeposit = tc.minDeposit
}
params.MinInitialDepositRatio = sdk.NewDec(tc.minInitialDepositPercent).Quo(sdk.NewDec(100)).String()
params.MinInitialDepositRatio = sdkmath.LegacyNewDec(tc.minInitialDepositPercent).Quo(sdkmath.LegacyNewDec(100)).String()
govKeeper.SetParams(ctx, params)
@ -347,10 +347,10 @@ func TestChargeDeposit(t *testing.T) {
if len(params.ProposalCancelDest) != 0 {
accAddr := sdk.MustAccAddressFromBech32(params.ProposalCancelDest)
newBalanceAfterCancelProposal := bankKeeper.GetBalance(ctx, accAddr, sdk.DefaultBondDenom)
cancellationCharges := math.NewInt(0)
cancellationCharges := sdkmath.NewInt(0)
for _, deposits := range allDeposits {
for _, deposit := range deposits.Amount {
burnAmount := sdk.NewDecFromInt(deposit.Amount).Mul(sdk.MustNewDecFromStr(params.MinInitialDepositRatio)).TruncateInt()
burnAmount := sdkmath.LegacyNewDecFromInt(deposit.Amount).Mul(sdkmath.LegacyMustNewDecFromStr(params.MinInitialDepositRatio)).TruncateInt()
cancellationCharges = cancellationCharges.Add(burnAmount)
}
}

7
x/gov/keeper/grpc_query.go
View File

@ -6,6 +6,7 @@ import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
sdkmath "cosmossdk.io/math"
"cosmossdk.io/store/prefix"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -402,15 +403,15 @@ func (q legacyQueryServer) Params(c context.Context, req *v1beta1.QueryParamsReq
}
if resp.TallyParams != nil {
quorum, err := sdk.NewDecFromStr(resp.TallyParams.Quorum)
quorum, err := sdkmath.LegacyNewDecFromStr(resp.TallyParams.Quorum)
if err != nil {
return nil, err
}
threshold, err := sdk.NewDecFromStr(resp.TallyParams.Threshold)
threshold, err := sdkmath.LegacyNewDecFromStr(resp.TallyParams.Threshold)
if err != nil {
return nil, err
}
vetoThreshold, err := sdk.NewDecFromStr(resp.TallyParams.VetoThreshold)
vetoThreshold, err := sdkmath.LegacyNewDecFromStr(resp.TallyParams.VetoThreshold)
if err != nil {
return nil, err
}

6
x/gov/keeper/grpc_query_test.go
View File

@ -556,7 +556,7 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryVote() {
Voter: addrs[0].String(),
}
expRes = &v1beta1.QueryVoteResponse{Vote: v1beta1.Vote{ProposalId: proposal.Id, Voter: addrs[0].String(), Options: []v1beta1.WeightedVoteOption{{Option: v1beta1.OptionAbstain, Weight: sdk.MustNewDecFromStr("1.0")}}}}
expRes = &v1beta1.QueryVoteResponse{Vote: v1beta1.Vote{ProposalId: proposal.Id, Voter: addrs[0].String(), Options: []v1beta1.WeightedVoteOption{{Option: v1beta1.OptionAbstain, Weight: math.LegacyMustNewDecFromStr("1.0")}}}}
},
true,
},
@ -595,7 +595,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryVotes() {
suite.reset()
ctx, queryClient := suite.ctx, suite.queryClient
addrs := simtestutil.AddTestAddrsIncremental(suite.bankKeeper, suite.stakingKeeper, ctx, 2, sdk.NewInt(30000000))
addrs := simtestutil.AddTestAddrsIncremental(suite.bankKeeper, suite.stakingKeeper, ctx, 2, math.NewInt(30000000))
var (
req *v1.QueryVotesRequest
@ -697,7 +697,7 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryVotes() {
suite.reset()
ctx, queryClient := suite.ctx, suite.legacyQueryClient
addrs := simtestutil.AddTestAddrsIncremental(suite.bankKeeper, suite.stakingKeeper, ctx, 2, sdk.NewInt(30000000))
addrs := simtestutil.AddTestAddrsIncremental(suite.bankKeeper, suite.stakingKeeper, ctx, 2, math.NewInt(30000000))
var (
req *v1beta1.QueryVotesRequest

6
x/gov/keeper/keeper_test.go
View File

@ -6,6 +6,8 @@ import (
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
sdkmath "cosmossdk.io/math"
"github.com/cosmos/cosmos-sdk/baseapp"
"github.com/cosmos/cosmos-sdk/codec"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
@ -44,7 +46,7 @@ func (suite *KeeperTestSuite) reset() {
// Populate the gov account with some coins, as the TestProposal we have
// is a MsgSend from the gov account.
coins := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100000)))
coins := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(100000)))
err := bankKeeper.MintCoins(suite.ctx, minttypes.ModuleName, coins)
suite.NoError(err)
err = bankKeeper.SendCoinsFromModuleToModule(ctx, minttypes.ModuleName, types.ModuleName, coins)
@ -69,7 +71,7 @@ func (suite *KeeperTestSuite) reset() {
suite.msgSrvr = keeper.NewMsgServerImpl(suite.govKeeper)
suite.legacyMsgSrvr = keeper.NewLegacyMsgServerImpl(govAcct.String(), suite.msgSrvr)
suite.addrs = simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 3, sdk.NewInt(30000000))
suite.addrs = simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 3, sdkmath.NewInt(30000000))
}
func TestIncrementProposalNumber(t *testing.T) {

45
x/gov/keeper/msg_server_test.go
View File

@ -4,6 +4,7 @@ import (
"strings"
"time"
sdkmath "cosmossdk.io/math"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
"github.com/cosmos/cosmos-sdk/testutil/testdata"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -18,7 +19,7 @@ func (suite *KeeperTestSuite) TestSubmitProposalReq() {
addrs := suite.addrs
proposer := addrs[0]
coins := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100)))
coins := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(100)))
initialDeposit := coins
minDeposit := suite.govKeeper.GetParams(suite.ctx).MinDeposit
bankMsg := &banktypes.MsgSend{
@ -143,7 +144,7 @@ func (suite *KeeperTestSuite) TestCancelProposalReq() {
addrs := suite.addrs
proposer := addrs[0]
coins := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100)))
coins := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(100)))
bankMsg := &banktypes.MsgSend{
FromAddress: govAcct.String(),
ToAddress: proposer.String(),
@ -213,7 +214,7 @@ func (suite *KeeperTestSuite) TestVoteReq() {
addrs := suite.addrs
proposer := addrs[0]
coins := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100)))
coins := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(100)))
minDeposit := suite.govKeeper.GetParams(suite.ctx).MinDeposit
bankMsg := &banktypes.MsgSend{
FromAddress: govAcct.String(),
@ -335,7 +336,7 @@ func (suite *KeeperTestSuite) TestVoteWeightedReq() {
addrs := suite.addrs
proposer := addrs[0]
coins := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100)))
coins := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(100)))
minDeposit := suite.govKeeper.GetParams(suite.ctx).MinDeposit
bankMsg := &banktypes.MsgSend{
FromAddress: govAcct.String(),
@ -457,7 +458,7 @@ func (suite *KeeperTestSuite) TestDepositReq() {
addrs := suite.addrs
proposer := addrs[0]
coins := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100)))
coins := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(100)))
minDeposit := suite.govKeeper.GetParams(suite.ctx).MinDeposit
bankMsg := &banktypes.MsgSend{
FromAddress: govAcct.String(),
@ -528,7 +529,7 @@ func (suite *KeeperTestSuite) TestLegacyMsgSubmitProposal() {
addrs := suite.addrs
proposer := addrs[0]
coins := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100)))
coins := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(100)))
initialDeposit := coins
minDeposit := suite.govKeeper.GetParams(suite.ctx).MinDeposit
@ -578,7 +579,7 @@ func (suite *KeeperTestSuite) TestLegacyMsgVote() {
addrs := suite.addrs
proposer := addrs[0]
coins := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100)))
coins := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(100)))
minDeposit := suite.govKeeper.GetParams(suite.ctx).MinDeposit
bankMsg := &banktypes.MsgSend{
FromAddress: govAcct.String(),
@ -690,7 +691,7 @@ func (suite *KeeperTestSuite) TestLegacyVoteWeighted() {
addrs := suite.addrs
proposer := addrs[0]
coins := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100)))
coins := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(100)))
minDeposit := suite.govKeeper.GetParams(suite.ctx).MinDeposit
bankMsg := &banktypes.MsgSend{
FromAddress: govAcct.String(),
@ -802,7 +803,7 @@ func (suite *KeeperTestSuite) TestLegacyMsgDeposit() {
addrs := suite.addrs
proposer := addrs[0]
coins := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100)))
coins := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(100)))
minDeposit := suite.govKeeper.GetParams(suite.ctx).MinDeposit
bankMsg := &banktypes.MsgSend{
FromAddress: govAcct.String(),
@ -918,7 +919,7 @@ func (suite *KeeperTestSuite) TestMsgUpdateParams() {
params1 := params
params1.MinDeposit = sdk.Coins{{
Denom: sdk.DefaultBondDenom,
Amount: sdk.NewInt(-100),
Amount: sdkmath.NewInt(-100),
}}
return &v1.MsgUpdateParams{
@ -1154,32 +1155,32 @@ func (suite *KeeperTestSuite) TestSubmitProposal_InitialDeposit() {
expectError bool
}{
"meets initial deposit, enough balance - success": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositRatio: baseDepositRatioDec,
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(meetsDepositValue))),
accountBalance: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(meetsDepositValue))),
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(meetsDepositValue))),
accountBalance: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(meetsDepositValue))),
},
"does not meet initial deposit, enough balance - error": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositRatio: baseDepositRatioDec,
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(meetsDepositValue-1))),
accountBalance: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(meetsDepositValue))),
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(meetsDepositValue-1))),
accountBalance: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(meetsDepositValue))),
expectError: true,
},
"meets initial deposit, not enough balance - error": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositRatio: baseDepositRatioDec,
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(meetsDepositValue))),
accountBalance: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(meetsDepositValue-1))),
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(meetsDepositValue))),
accountBalance: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(meetsDepositValue-1))),
expectError: true,
},
"does not meet initial deposit and not enough balance - error": {
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(baseDepositTestAmount))),
minDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(baseDepositTestAmount))),
minInitialDepositRatio: baseDepositRatioDec,
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(meetsDepositValue-1))),
accountBalance: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(meetsDepositValue-1))),
initialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(meetsDepositValue-1))),
accountBalance: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdkmath.NewInt(meetsDepositValue-1))),
expectError: true,
},

12
x/gov/keeper/tally.go
View File

@ -58,7 +58,7 @@ func (keeper Keeper) Tally(ctx sdk.Context, proposal v1.Proposal) (passes, burnD
votingPower := delegation.GetShares().MulInt(val.BondedTokens).Quo(val.DelegatorShares)
for _, option := range vote.Options {
weight, _ := sdk.NewDecFromStr(option.Weight)
weight, _ := math.LegacyNewDecFromStr(option.Weight)
subPower := votingPower.Mul(weight)
results[option.Option] = results[option.Option].Add(subPower)
}
@ -82,7 +82,7 @@ func (keeper Keeper) Tally(ctx sdk.Context, proposal v1.Proposal) (passes, burnD
votingPower := sharesAfterDeductions.MulInt(val.BondedTokens).Quo(val.DelegatorShares)
for _, option := range val.Vote {
weight, _ := sdk.NewDecFromStr(option.Weight)
weight, _ := math.LegacyNewDecFromStr(option.Weight)
subPower := votingPower.Mul(weight)
results[option.Option] = results[option.Option].Add(subPower)
}
@ -99,8 +99,8 @@ func (keeper Keeper) Tally(ctx sdk.Context, proposal v1.Proposal) (passes, burnD
}
// If there is not enough quorum of votes, the proposal fails
percentVoting := totalVotingPower.Quo(sdk.NewDecFromInt(keeper.sk.TotalBondedTokens(ctx)))
quorum, _ := sdk.NewDecFromStr(params.Quorum)
percentVoting := totalVotingPower.Quo(math.LegacyNewDecFromInt(keeper.sk.TotalBondedTokens(ctx)))
quorum, _ := math.LegacyNewDecFromStr(params.Quorum)
if percentVoting.LT(quorum) {
return false, params.BurnVoteQuorum, tallyResults
}
@ -111,7 +111,7 @@ func (keeper Keeper) Tally(ctx sdk.Context, proposal v1.Proposal) (passes, burnD
}
// If more than 1/3 of voters veto, proposal fails
vetoThreshold, _ := sdk.NewDecFromStr(params.VetoThreshold)
vetoThreshold, _ := math.LegacyNewDecFromStr(params.VetoThreshold)
if results[v1.OptionNoWithVeto].Quo(totalVotingPower).GT(vetoThreshold) {
return false, params.BurnVoteVeto, tallyResults
}
@ -125,7 +125,7 @@ func (keeper Keeper) Tally(ctx sdk.Context, proposal v1.Proposal) (passes, burnD
thresholdStr = params.GetThreshold()
}
threshold, _ := sdk.NewDecFromStr(thresholdStr)
threshold, _ := math.LegacyNewDecFromStr(thresholdStr)
if results[v1.OptionYes].Quo(totalVotingPower.Sub(results[v1.OptionAbstain])).GT(threshold) {
return true, false, tallyResults
}

27
x/gov/keeper/vote_test.go
View File

@ -3,6 +3,7 @@ package keeper_test
import (
"testing"
sdkmath "cosmossdk.io/math"
"github.com/stretchr/testify/require"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
@ -12,7 +13,7 @@ import (
func TestVotes(t *testing.T) {
govKeeper, _, bankKeeper, stakingKeeper, _, _, ctx := setupGovKeeper(t)
addrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(10000000))
addrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 2, sdkmath.NewInt(10000000))
tp := TestProposal
proposal, err := govKeeper.SubmitProposal(ctx, tp, "", "title", "description", sdk.AccAddress("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r"), false)
@ -50,10 +51,10 @@ func TestVotes(t *testing.T) {
// Test second vote
require.NoError(t, govKeeper.AddVote(ctx, proposalID, addrs[1], v1.WeightedVoteOptions{
v1.NewWeightedVoteOption(v1.OptionYes, sdk.NewDecWithPrec(60, 2)),
v1.NewWeightedVoteOption(v1.OptionNo, sdk.NewDecWithPrec(30, 2)),
v1.NewWeightedVoteOption(v1.OptionAbstain, sdk.NewDecWithPrec(5, 2)),
v1.NewWeightedVoteOption(v1.OptionNoWithVeto, sdk.NewDecWithPrec(5, 2)),
v1.NewWeightedVoteOption(v1.OptionYes, sdkmath.LegacyNewDecWithPrec(60, 2)),
v1.NewWeightedVoteOption(v1.OptionNo, sdkmath.LegacyNewDecWithPrec(30, 2)),
v1.NewWeightedVoteOption(v1.OptionAbstain, sdkmath.LegacyNewDecWithPrec(5, 2)),
v1.NewWeightedVoteOption(v1.OptionNoWithVeto, sdkmath.LegacyNewDecWithPrec(5, 2)),
}, ""))
vote, found = govKeeper.GetVote(ctx, proposalID, addrs[1])
require.True(t, found)
@ -64,10 +65,10 @@ func TestVotes(t *testing.T) {
require.Equal(t, v1.OptionNo, vote.Options[1].Option)
require.Equal(t, v1.OptionAbstain, vote.Options[2].Option)
require.Equal(t, v1.OptionNoWithVeto, vote.Options[3].Option)
require.Equal(t, vote.Options[0].Weight, sdk.NewDecWithPrec(60, 2).String())
require.Equal(t, vote.Options[1].Weight, sdk.NewDecWithPrec(30, 2).String())
require.Equal(t, vote.Options[2].Weight, sdk.NewDecWithPrec(5, 2).String())
require.Equal(t, vote.Options[3].Weight, sdk.NewDecWithPrec(5, 2).String())
require.Equal(t, vote.Options[0].Weight, sdkmath.LegacyNewDecWithPrec(60, 2).String())
require.Equal(t, vote.Options[1].Weight, sdkmath.LegacyNewDecWithPrec(30, 2).String())
require.Equal(t, vote.Options[2].Weight, sdkmath.LegacyNewDecWithPrec(5, 2).String())
require.Equal(t, vote.Options[3].Weight, sdkmath.LegacyNewDecWithPrec(5, 2).String())
// Test vote iterator
// NOTE order of deposits is determined by the addresses
@ -81,8 +82,8 @@ func TestVotes(t *testing.T) {
require.Equal(t, addrs[1].String(), votes[1].Voter)
require.Equal(t, proposalID, votes[1].ProposalId)
require.True(t, len(votes[1].Options) == 4)
require.Equal(t, votes[1].Options[0].Weight, sdk.NewDecWithPrec(60, 2).String())
require.Equal(t, votes[1].Options[1].Weight, sdk.NewDecWithPrec(30, 2).String())
require.Equal(t, votes[1].Options[2].Weight, sdk.NewDecWithPrec(5, 2).String())
require.Equal(t, votes[1].Options[3].Weight, sdk.NewDecWithPrec(5, 2).String())
require.Equal(t, votes[1].Options[0].Weight, sdkmath.LegacyNewDecWithPrec(60, 2).String())
require.Equal(t, votes[1].Options[1].Weight, sdkmath.LegacyNewDecWithPrec(30, 2).String())
require.Equal(t, votes[1].Options[2].Weight, sdkmath.LegacyNewDecWithPrec(5, 2).String())
require.Equal(t, votes[1].Options[3].Weight, sdkmath.LegacyNewDecWithPrec(5, 2).String())
}

10
x/gov/migrations/v3/convert_test.go
View File

@ -60,10 +60,10 @@ func TestConvertToLegacyProposal(t *testing.T) {
require.Equal(t, v1beta1Proposal.VotingEndTime, *proposal.VotingEndTime)
require.Equal(t, v1beta1Proposal.SubmitTime, *proposal.SubmitTime)
require.Equal(t, v1beta1Proposal.DepositEndTime, *proposal.DepositEndTime)
require.Equal(t, v1beta1Proposal.FinalTallyResult.Yes, sdk.NewInt(0))
require.Equal(t, v1beta1Proposal.FinalTallyResult.No, sdk.NewInt(0))
require.Equal(t, v1beta1Proposal.FinalTallyResult.NoWithVeto, sdk.NewInt(0))
require.Equal(t, v1beta1Proposal.FinalTallyResult.Abstain, sdk.NewInt(0))
require.Equal(t, v1beta1Proposal.FinalTallyResult.Yes, math.NewInt(0))
require.Equal(t, v1beta1Proposal.FinalTallyResult.No, math.NewInt(0))
require.Equal(t, v1beta1Proposal.FinalTallyResult.NoWithVeto, math.NewInt(0))
require.Equal(t, v1beta1Proposal.FinalTallyResult.Abstain, math.NewInt(0))
tp, ok := v1beta1Proposal.Content.GetCachedValue().(*v1beta1.TextProposal)
require.Truef(t, ok, "expected *TextProposal, got %T", v1beta1Proposal.Content.GetCachedValue())
require.Equal(t, tp.Title, "title")
@ -203,7 +203,7 @@ func TestConvertToLegacyDeposit(t *testing.T) {
deposit := v1.Deposit{
ProposalId: 1,
Depositor: "cosmos1fl48vsnmsdzcv85q5d2q4z5ajdha8yu34mf0eh",
Amount: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1))),
Amount: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(1))),
}
v1beta1Deposit := v3.ConvertToLegacyDeposit(&deposit)

3
x/gov/migrations/v3/json_test.go
View File

@ -5,6 +5,7 @@ import (
"testing"
"time"
sdkmath "cosmossdk.io/math"
"github.com/cosmos/gogoproto/proto"
"github.com/stretchr/testify/require"
@ -43,7 +44,7 @@ func TestMigrateJSON(t *testing.T) {
VotingEndTime: propTime,
Status: v1beta1.StatusDepositPeriod,
FinalTallyResult: v1beta1.EmptyTallyResult(),
TotalDeposit: sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(123))),
TotalDeposit: sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(123))),
},
}
govGenState.Votes = v1beta1.Votes{

3
x/gov/migrations/v4/store_test.go
View File

@ -6,6 +6,7 @@ import (
"github.com/stretchr/testify/require"
sdkmath "cosmossdk.io/math"
storetypes "cosmossdk.io/store/types"
"github.com/cosmos/cosmos-sdk/testutil"
@ -129,7 +130,7 @@ func getTestProposal() []sdk.Msg {
}
return []sdk.Msg{
banktypes.NewMsgSend(govAcct, addr, sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(1000)))),
banktypes.NewMsgSend(govAcct, addr, sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(1000)))),
legacyProposalMsg,
}
}

16
x/gov/simulation/genesis.go
View File

@ -6,7 +6,7 @@ import (
"math/rand"
"time"
"cosmossdk.io/math"
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/module"
@ -75,23 +75,23 @@ func GenExpeditedVotingPeriod(r *rand.Rand) time.Duration {
}
// GenQuorum returns randomized Quorum
func GenQuorum(r *rand.Rand) math.LegacyDec {
return sdk.NewDecWithPrec(int64(simulation.RandIntBetween(r, 334, 500)), 3)
func GenQuorum(r *rand.Rand) sdkmath.LegacyDec {
return sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(r, 334, 500)), 3)
}
// GenThreshold returns randomized Threshold
func GenThreshold(r *rand.Rand) math.LegacyDec {
return sdk.NewDecWithPrec(int64(simulation.RandIntBetween(r, 450, tallyNonExpeditedMax+1)), 3)
func GenThreshold(r *rand.Rand) sdkmath.LegacyDec {
return sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(r, 450, tallyNonExpeditedMax+1)), 3)
}
// GenExpeditedThreshold randomized ExpeditedThreshold
func GenExpeditedThreshold(r *rand.Rand) sdk.Dec {
return sdk.NewDecWithPrec(int64(simulation.RandIntBetween(r, tallyNonExpeditedMax, 550)), 3)
return sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(r, tallyNonExpeditedMax, 550)), 3)
}
// GenVeto returns randomized Veto
func GenVeto(r *rand.Rand) math.LegacyDec {
return sdk.NewDecWithPrec(int64(simulation.RandIntBetween(r, 250, 334)), 3)
func GenVeto(r *rand.Rand) sdkmath.LegacyDec {
return sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(r, 250, 334)), 3)
}
// RandomizedGenState generates a random GenesisState for gov

14
x/gov/simulation/operations.go
View File

@ -5,6 +5,8 @@ import (
"math/rand"
"time"
sdkmath "cosmossdk.io/math"
"github.com/cosmos/cosmos-sdk/baseapp"
"github.com/cosmos/cosmos-sdk/codec"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
@ -509,14 +511,14 @@ func randomDeposit(
minDepositAmount := minDeposit[denomIndex].Amount
minAmount := sdk.ZeroInt()
minAmount := sdkmath.ZeroInt()
if useMinAmount {
minDepositPercent, err := sdk.NewDecFromStr(params.MinInitialDepositRatio)
minDepositPercent, err := sdkmath.LegacyNewDecFromStr(params.MinInitialDepositRatio)
if err != nil {
return nil, false, err
}
minAmount = sdk.NewDecFromInt(minDepositAmount).Mul(minDepositPercent).TruncateInt()
minAmount = sdkmath.LegacyNewDecFromInt(minDepositAmount).Mul(minDepositPercent).TruncateInt()
}
amount, err := simtypes.RandPositiveInt(r, minDepositAmount.Sub(minAmount))
@ -600,19 +602,19 @@ func randomWeightedVotingOptions(r *rand.Rand) v1.WeightedVoteOptions {
if w2 > 0 {
weightedVoteOptions = append(weightedVoteOptions, &v1.WeightedVoteOption{
Option: v1.OptionAbstain,
Weight: sdk.NewDecWithPrec(int64(w2), 2).String(),
Weight: sdkmath.LegacyNewDecWithPrec(int64(w2), 2).String(),
})
}
if w3 > 0 {
weightedVoteOptions = append(weightedVoteOptions, &v1.WeightedVoteOption{
Option: v1.OptionNo,
Weight: sdk.NewDecWithPrec(int64(w3), 2).String(),
Weight: sdkmath.LegacyNewDecWithPrec(int64(w3), 2).String(),
})
}
if w4 > 0 {
weightedVoteOptions = append(weightedVoteOptions, &v1.WeightedVoteOption{
Option: v1.OptionNoWithVeto,
Weight: sdk.NewDecWithPrec(int64(w4), 2).String(),
Weight: sdkmath.LegacyNewDecWithPrec(int64(w4), 2).String(),
})
}
return weightedVoteOptions

2
x/gov/testutil/expected_keepers.go
View File

@ -5,7 +5,7 @@ package testutil
import (
context "context"
math "cosmossdk.io/math"
"cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"

4
x/gov/types/v1/genesis_test.go
View File

@ -3,6 +3,8 @@ package v1_test
import (
"testing"
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
"github.com/stretchr/testify/require"
@ -43,7 +45,7 @@ func TestValidateGenesis(t *testing.T) {
params1 := params
params1.MinDeposit = sdk.Coins{{
Denom: sdk.DefaultBondDenom,
Amount: sdk.NewInt(-100),
Amount: sdkmath.NewInt(-100),
}}
return v1.NewGenesisState(0, params1)

42
x/gov/types/v1/params.go
View File

@ -4,7 +4,7 @@ import (
"fmt"
"time"
"cosmossdk.io/math"
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
)
@ -18,14 +18,14 @@ const (
// Default governance params
var (
DefaultMinDepositTokens = sdk.NewInt(10000000)
DefaultMinExpeditedDepositTokens = DefaultMinDepositTokens.Mul(math.NewInt(DefaultMinExpeditedDepositTokensRatio))
DefaultQuorum = sdk.NewDecWithPrec(334, 3)
DefaultThreshold = sdk.NewDecWithPrec(5, 1)
DefaultExpeditedThreshold = sdk.NewDecWithPrec(667, 3)
DefaultVetoThreshold = sdk.NewDecWithPrec(334, 3)
DefaultMinInitialDepositRatio = sdk.ZeroDec()
DefaultProposalCancelRatio = sdk.MustNewDecFromStr("0.5")
DefaultMinDepositTokens = sdkmath.NewInt(10000000)
DefaultMinExpeditedDepositTokens = DefaultMinDepositTokens.Mul(sdkmath.NewInt(DefaultMinExpeditedDepositTokensRatio))
DefaultQuorum = sdkmath.LegacyNewDecWithPrec(334, 3)
DefaultThreshold = sdkmath.LegacyNewDecWithPrec(5, 1)
DefaultExpeditedThreshold = sdkmath.LegacyNewDecWithPrec(667, 3)
DefaultVetoThreshold = sdkmath.LegacyNewDecWithPrec(334, 3)
DefaultMinInitialDepositRatio = sdkmath.LegacyZeroDec()
DefaultProposalCancelRatio = sdkmath.LegacyMustNewDecFromStr("0.5")
DefaultProposalCancelDestAddress = ""
DefaultBurnProposalPrevote = false // set to false to replicate behavior of when this change was made (0.47)
DefaultBurnVoteQuorom = false // set to false to replicate behavior of when this change was made (0.47)
@ -122,50 +122,50 @@ func (p Params) ValidateBasic() error {
return fmt.Errorf("maximum deposit period must be positive: %d", p.MaxDepositPeriod)
}
quorum, err := sdk.NewDecFromStr(p.Quorum)
quorum, err := sdkmath.LegacyNewDecFromStr(p.Quorum)
if err != nil {
return fmt.Errorf("invalid quorum string: %w", err)
}
if quorum.IsNegative() {
return fmt.Errorf("quorom cannot be negative: %s", quorum)
}
if quorum.GT(math.LegacyOneDec()) {
if quorum.GT(sdkmath.LegacyOneDec()) {
return fmt.Errorf("quorom too large: %s", p.Quorum)
}
threshold, err := sdk.NewDecFromStr(p.Threshold)
threshold, err := sdkmath.LegacyNewDecFromStr(p.Threshold)
if err != nil {
return fmt.Errorf("invalid threshold string: %w", err)
}
if !threshold.IsPositive() {
return fmt.Errorf("vote threshold must be positive: %s", threshold)
}
if threshold.GT(math.LegacyOneDec()) {
if threshold.GT(sdkmath.LegacyOneDec()) {
return fmt.Errorf("vote threshold too large: %s", threshold)
}
expeditedThreshold, err := sdk.NewDecFromStr(p.ExpeditedThreshold)
expeditedThreshold, err := sdkmath.LegacyNewDecFromStr(p.ExpeditedThreshold)
if err != nil {
return fmt.Errorf("invalid expedited threshold string: %w", err)
}
if !threshold.IsPositive() {
return fmt.Errorf("expedited vote threshold must be positive: %s", threshold)
}
if threshold.GT(math.LegacyOneDec()) {
if threshold.GT(sdkmath.LegacyOneDec()) {
return fmt.Errorf("expedited vote threshold too large: %s", threshold)
}
if expeditedThreshold.LTE(threshold) {
return fmt.Errorf("expedited vote threshold %s, must be greater than the regular threshold %s", expeditedThreshold, threshold)
}
vetoThreshold, err := sdk.NewDecFromStr(p.VetoThreshold)
vetoThreshold, err := sdkmath.LegacyNewDecFromStr(p.VetoThreshold)
if err != nil {
return fmt.Errorf("invalid vetoThreshold string: %w", err)
}
if !vetoThreshold.IsPositive() {
return fmt.Errorf("veto threshold must be positive: %s", vetoThreshold)
}
if vetoThreshold.GT(math.LegacyOneDec()) {
if vetoThreshold.GT(sdkmath.LegacyOneDec()) {
return fmt.Errorf("veto threshold too large: %s", vetoThreshold)
}
@ -186,25 +186,25 @@ func (p Params) ValidateBasic() error {
return fmt.Errorf("expedited voting period %s must be strictly less that the regular voting period %s", p.ExpeditedVotingPeriod, p.VotingPeriod)
}
minInitialDepositRatio, err := sdk.NewDecFromStr(p.MinInitialDepositRatio)
minInitialDepositRatio, err := sdkmath.LegacyNewDecFromStr(p.MinInitialDepositRatio)
if err != nil {
return fmt.Errorf("invalid mininum initial deposit ratio of proposal: %w", err)
}
if minInitialDepositRatio.IsNegative() {
return fmt.Errorf("mininum initial deposit ratio of proposal must be positive: %s", minInitialDepositRatio)
}
if minInitialDepositRatio.GT(math.LegacyOneDec()) {
if minInitialDepositRatio.GT(sdkmath.LegacyOneDec()) {
return fmt.Errorf("mininum initial deposit ratio of proposal is too large: %s", minInitialDepositRatio)
}
proposalCancelRate, err := sdk.NewDecFromStr(p.ProposalCancelRatio)
proposalCancelRate, err := sdkmath.LegacyNewDecFromStr(p.ProposalCancelRatio)
if err != nil {
return fmt.Errorf("invalid burn rate of cancel proposal: %w", err)
}
if proposalCancelRate.IsNegative() {
return fmt.Errorf("burn rate of cancel proposal must be positive: %s", proposalCancelRate)
}
if proposalCancelRate.GT(math.LegacyOneDec()) {
if proposalCancelRate.GT(sdkmath.LegacyOneDec()) {
return fmt.Errorf("burn rate of cancel proposal is too large: %s", proposalCancelRate)
}

6
x/gov/types/v1/params_legacy.go
View File

@ -47,7 +47,7 @@ func validateTallyParams(i interface{}) error {
return fmt.Errorf("invalid parameter type: %T", i)
}
quorum, err := sdk.NewDecFromStr(v.Quorum)
quorum, err := math.LegacyNewDecFromStr(v.Quorum)
if err != nil {
return fmt.Errorf("invalid quorum string: %w", err)
}
@ -58,7 +58,7 @@ func validateTallyParams(i interface{}) error {
return fmt.Errorf("quorom too large: %s", v)
}
threshold, err := sdk.NewDecFromStr(v.Threshold)
threshold, err := math.LegacyNewDecFromStr(v.Threshold)
if err != nil {
return fmt.Errorf("invalid threshold string: %w", err)
}
@ -69,7 +69,7 @@ func validateTallyParams(i interface{}) error {
return fmt.Errorf("vote threshold too large: %s", v)
}
vetoThreshold, err := sdk.NewDecFromStr(v.VetoThreshold)
vetoThreshold, err := math.LegacyNewDecFromStr(v.VetoThreshold)
if err != nil {
return fmt.Errorf("invalid vetoThreshold string: %w", err)
}

4
x/gov/types/v1/vote.go
View File

@ -63,7 +63,7 @@ func NewWeightedVoteOption(option VoteOption, weight sdk.Dec) *WeightedVoteOptio
// IsValid returns true if the sub vote is valid and false otherwise.
func (w *WeightedVoteOption) IsValid() bool {
weight, err := sdk.NewDecFromStr(w.Weight)
weight, err := math.LegacyNewDecFromStr(w.Weight)
if err != nil {
return false
}
@ -123,7 +123,7 @@ func WeightedVoteOptionsFromString(str string) (WeightedVoteOptions, error) {
if len(fields) < 2 {
return options, fmt.Errorf("weight field does not exist for %s option", fields[0])
}
weight, err := sdk.NewDecFromStr(fields[1])
weight, err := math.LegacyNewDecFromStr(fields[1])
if err != nil {
return options, err
}

6
x/gov/types/v1beta1/msgs_test.go
View File

@ -140,8 +140,8 @@ func TestMsgVoteWeighted(t *testing.T) {
WeightedVoteOption{Option: OptionAbstain, Weight: math.LegacyNewDec(1)},
}, false},
{0, addrs[0], WeightedVoteOptions{ // duplicate option
WeightedVoteOption{Option: OptionYes, Weight: sdk.NewDecWithPrec(5, 1)},
WeightedVoteOption{Option: OptionYes, Weight: sdk.NewDecWithPrec(5, 1)},
WeightedVoteOption{Option: OptionYes, Weight: math.LegacyNewDecWithPrec(5, 1)},
WeightedVoteOption{Option: OptionYes, Weight: math.LegacyNewDecWithPrec(5, 1)},
}, false},
{0, addrs[0], WeightedVoteOptions{ // zero weight
WeightedVoteOption{Option: OptionYes, Weight: math.LegacyNewDec(0)},
@ -152,7 +152,7 @@ func TestMsgVoteWeighted(t *testing.T) {
{0, addrs[0], WeightedVoteOptions{}, false},
{0, addrs[0], NewNonSplitVoteOption(VoteOption(0x13)), false},
{0, addrs[0], WeightedVoteOptions{ // weight sum <1
WeightedVoteOption{Option: OptionYes, Weight: sdk.NewDecWithPrec(5, 1)},
WeightedVoteOption{Option: OptionYes, Weight: math.LegacyNewDecWithPrec(5, 1)},
}, false},
}

10
x/gov/types/v1beta1/params.go
View File

@ -3,6 +3,8 @@ package v1beta1
import (
"time"
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
)
@ -13,10 +15,10 @@ const (
// Default governance params
var (
DefaultMinDepositTokens = sdk.NewInt(10000000)
DefaultQuorum = sdk.NewDecWithPrec(334, 3)
DefaultThreshold = sdk.NewDecWithPrec(5, 1)
DefaultVetoThreshold = sdk.NewDecWithPrec(334, 3)
DefaultMinDepositTokens = sdkmath.NewInt(10000000)
DefaultQuorum = sdkmath.LegacyNewDecWithPrec(334, 3)
DefaultThreshold = sdkmath.LegacyNewDecWithPrec(5, 1)
DefaultVetoThreshold = sdkmath.LegacyNewDecWithPrec(334, 3)
)
// NewDepositParams creates a new DepositParams object

8
x/gov/types/v1beta1/vote.go
View File

@ -4,7 +4,7 @@ import (
"fmt"
"strings"
"cosmossdk.io/math"
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
)
@ -51,7 +51,7 @@ func (v Votes) String() string {
// NewNonSplitVoteOption creates a single option vote with weight 1
func NewNonSplitVoteOption(option VoteOption) WeightedVoteOptions {
return WeightedVoteOptions{{option, math.LegacyNewDec(1)}}
return WeightedVoteOptions{{option, sdkmath.LegacyNewDec(1)}}
}
// WeightedVoteOptions describes array of WeightedVoteOptions
@ -67,7 +67,7 @@ func (v WeightedVoteOptions) String() (out string) {
// ValidWeightedVoteOption returns true if the sub vote is valid and false otherwise.
func ValidWeightedVoteOption(option WeightedVoteOption) bool {
if !option.Weight.IsPositive() || option.Weight.GT(math.LegacyNewDec(1)) {
if !option.Weight.IsPositive() || option.Weight.GT(sdkmath.LegacyNewDec(1)) {
return false
}
return ValidVoteOption(option.Option)
@ -96,7 +96,7 @@ func WeightedVoteOptionsFromString(str string) (WeightedVoteOptions, error) {
if len(fields) < 2 {
return options, fmt.Errorf("weight field does not exist for %s option", fields[0])
}
weight, err := sdk.NewDecFromStr(fields[1])
weight, err := sdkmath.LegacyNewDecFromStr(fields[1])
if err != nil {
return options, err
}