diff --git a/server/grpc/gogoreflection/fix_registration.go b/server/grpc/gogoreflection/fix_registration.go index 58cc60c4a760..d1aa6e3c8f09 100644 --- a/server/grpc/gogoreflection/fix_registration.go +++ b/server/grpc/gogoreflection/fix_registration.go @@ -39,7 +39,7 @@ func getExtension(extID int32, m proto.Message) *gogoproto.ExtensionDesc { } // check into proto registry - for id, desc := range proto.RegisteredExtensions(m) { //nolint:staticcheck // kept for backwards compatibility + for id, desc := range proto.RegisteredExtensions(m) { //nolint:staticcheck // keep for backward compatibility if id == extID { return &gogoproto.ExtensionDesc{ ExtendedType: desc.ExtendedType, diff --git a/types/bench_test.go b/types/bench_test.go index 639ba471d214..21b0604d24be 100644 --- a/types/bench_test.go +++ b/types/bench_test.go @@ -3,6 +3,8 @@ package types_test import ( "testing" + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" ) @@ -44,7 +46,7 @@ func BenchmarkUintMarshal(b *testing.B) { b.ReportAllocs() for i := 0; i < b.N; i++ { for _, value := range values { - u := sdk.NewUint(value) + u := sdkmath.NewUint(value) n, err := u.MarshalTo(scratch[:]) if err != nil { b.Fatal(err) @@ -69,7 +71,7 @@ func BenchmarkIntMarshal(b *testing.B) { b.ReportAllocs() for i := 0; i < b.N; i++ { for _, value := range values { - in := sdk.NewInt(value) + in := sdkmath.NewInt(value) n, err := in.MarshalTo(scratch[:]) if err != nil { b.Fatal(err) diff --git a/types/coin_test.go b/types/coin_test.go index 28f20fe9b17d..536937c1e613 100644 --- a/types/coin_test.go +++ b/types/coin_test.go @@ -29,10 +29,10 @@ func TestCoinTestSuite(t *testing.T) { } func (s *coinTestSuite) SetupSuite() { - zero := sdk.NewInt(0) + zero := math.NewInt(0) one := math.OneInt() - two := sdk.NewInt(2) - four := sdk.NewInt(4) + two := math.NewInt(2) + four := math.NewInt(4) s.ca0, s.ca1, s.ca2, s.ca4 = sdk.NewCoin(testDenom1, zero), sdk.NewCoin(testDenom1, one), sdk.NewCoin(testDenom1, two), sdk.NewCoin(testDenom1, four) s.cm0, s.cm1, s.cm2, s.cm4 = sdk.NewCoin(testDenom2, zero), sdk.NewCoin(testDenom2, one), sdk.NewCoin(testDenom2, two), sdk.NewCoin(testDenom2, four) @@ -44,15 +44,15 @@ func (s *coinTestSuite) SetupSuite() { func (s *coinTestSuite) TestCoin() { s.Require().Panics(func() { sdk.NewInt64Coin(testDenom1, -1) }) - s.Require().Panics(func() { sdk.NewCoin(testDenom1, sdk.NewInt(-1)) }) - s.Require().Equal(sdk.NewInt(10), sdk.NewInt64Coin(strings.ToUpper(testDenom1), 10).Amount) - s.Require().Equal(sdk.NewInt(10), sdk.NewCoin(strings.ToUpper(testDenom1), sdk.NewInt(10)).Amount) - s.Require().Equal(sdk.NewInt(5), sdk.NewInt64Coin(testDenom1, 5).Amount) - s.Require().Equal(sdk.NewInt(5), sdk.NewCoin(testDenom1, sdk.NewInt(5)).Amount) + s.Require().Panics(func() { sdk.NewCoin(testDenom1, math.NewInt(-1)) }) + s.Require().Equal(math.NewInt(10), sdk.NewInt64Coin(strings.ToUpper(testDenom1), 10).Amount) + s.Require().Equal(math.NewInt(10), sdk.NewCoin(strings.ToUpper(testDenom1), math.NewInt(10)).Amount) + s.Require().Equal(math.NewInt(5), sdk.NewInt64Coin(testDenom1, 5).Amount) + s.Require().Equal(math.NewInt(5), sdk.NewCoin(testDenom1, math.NewInt(5)).Amount) } func (s *coinTestSuite) TestCoin_String() { - coin := sdk.NewCoin(testDenom1, sdk.NewInt(10)) + coin := sdk.NewCoin(testDenom1, math.NewInt(10)) s.Require().Equal(fmt.Sprintf("10%s", testDenom1), coin.String()) } @@ -86,8 +86,8 @@ func (s *coinTestSuite) TestCoinIsValid() { coin sdk.Coin expectPass bool }{ - {sdk.Coin{testDenom1, sdk.NewInt(-1)}, false}, - {sdk.Coin{testDenom1, sdk.NewInt(0)}, true}, + {sdk.Coin{testDenom1, math.NewInt(-1)}, false}, + {sdk.Coin{testDenom1, math.NewInt(0)}, true}, {sdk.Coin{testDenom1, math.OneInt()}, true}, {sdk.Coin{"Atom", math.OneInt()}, true}, {sdk.Coin{"ATOM", math.OneInt()}, true}, @@ -114,11 +114,11 @@ func (s *coinTestSuite) TestCustomValidation() { coin sdk.Coin expectPass bool }{ - {sdk.Coin{"🙂", sdk.NewInt(1)}, true}, - {sdk.Coin{"🙁", sdk.NewInt(1)}, true}, - {sdk.Coin{"🌶", sdk.NewInt(1)}, false}, // outside the unicode range listed above - {sdk.Coin{"asdf", sdk.NewInt(1)}, false}, - {sdk.Coin{"", sdk.NewInt(1)}, false}, + {sdk.Coin{"🙂", math.NewInt(1)}, true}, + {sdk.Coin{"🙁", math.NewInt(1)}, true}, + {sdk.Coin{"🌶", math.NewInt(1)}, false}, // outside the unicode range listed above + {sdk.Coin{"asdf", math.NewInt(1)}, false}, + {sdk.Coin{"", math.NewInt(1)}, false}, } for i, tc := range cases { @@ -133,8 +133,8 @@ func (s *coinTestSuite) TestCoinsDenoms() { testOutput []string expectPass bool }{ - {sdk.NewCoins(sdk.Coin{"ATOM", sdk.NewInt(1)}, sdk.Coin{"JUNO", sdk.NewInt(1)}, sdk.Coin{"OSMO", sdk.NewInt(1)}, sdk.Coin{"RAT", sdk.NewInt(1)}), []string{"ATOM", "JUNO", "OSMO", "RAT"}, true}, - {sdk.NewCoins(sdk.Coin{"ATOM", sdk.NewInt(1)}, sdk.Coin{"JUNO", sdk.NewInt(1)}), []string{"ATOM"}, false}, + {sdk.NewCoins(sdk.Coin{"ATOM", math.NewInt(1)}, sdk.Coin{"JUNO", math.NewInt(1)}, sdk.Coin{"OSMO", math.NewInt(1)}, sdk.Coin{"RAT", math.NewInt(1)}), []string{"ATOM", "JUNO", "OSMO", "RAT"}, true}, + {sdk.NewCoins(sdk.Coin{"ATOM", math.NewInt(1)}, sdk.Coin{"JUNO", math.NewInt(1)}), []string{"ATOM"}, false}, } for i, tc := range cases { @@ -183,8 +183,8 @@ func (s *coinTestSuite) TestAddCoinAmount() { amount math.Int expected sdk.Coin }{ - {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt(1), sdk.NewInt64Coin(testDenom1, 2)}, - {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt(0), sdk.NewInt64Coin(testDenom1, 1)}, + {sdk.NewInt64Coin(testDenom1, 1), math.NewInt(1), sdk.NewInt64Coin(testDenom1, 2)}, + {sdk.NewInt64Coin(testDenom1, 1), math.NewInt(0), sdk.NewInt64Coin(testDenom1, 1)}, } for i, tc := range cases { res := tc.coin.AddAmount(tc.amount) @@ -232,11 +232,11 @@ func (s *coinTestSuite) TestSubCoinAmount() { expected sdk.Coin shouldPanic bool }{ - {sdk.NewInt64Coin(testDenom1, 2), sdk.NewInt(1), sdk.NewInt64Coin(testDenom1, 1), false}, - {sdk.NewInt64Coin(testDenom1, 10), sdk.NewInt(1), sdk.NewInt64Coin(testDenom1, 9), false}, - {sdk.NewInt64Coin(testDenom1, 5), sdk.NewInt(3), sdk.NewInt64Coin(testDenom1, 2), false}, - {sdk.NewInt64Coin(testDenom1, 5), sdk.NewInt(0), sdk.NewInt64Coin(testDenom1, 5), false}, - {sdk.NewInt64Coin(testDenom1, 1), sdk.NewInt(5), sdk.Coin{}, true}, + {sdk.NewInt64Coin(testDenom1, 2), math.NewInt(1), sdk.NewInt64Coin(testDenom1, 1), false}, + {sdk.NewInt64Coin(testDenom1, 10), math.NewInt(1), sdk.NewInt64Coin(testDenom1, 9), false}, + {sdk.NewInt64Coin(testDenom1, 5), math.NewInt(3), sdk.NewInt64Coin(testDenom1, 2), false}, + {sdk.NewInt64Coin(testDenom1, 5), math.NewInt(0), sdk.NewInt64Coin(testDenom1, 5), false}, + {sdk.NewInt64Coin(testDenom1, 1), math.NewInt(5), sdk.Coin{}, true}, } for i, tc := range cases { @@ -256,9 +256,9 @@ func (s *coinTestSuite) TestMulIntCoins() { expected sdk.Coins shouldPanic bool }{ - {sdk.Coins{s.ca2}, sdk.NewInt(0), sdk.Coins{s.ca0}, true}, - {sdk.Coins{s.ca2}, sdk.NewInt(2), sdk.Coins{s.ca4}, false}, - {sdk.Coins{s.ca1, s.cm2}, sdk.NewInt(2), sdk.Coins{s.ca2, s.cm4}, false}, + {sdk.Coins{s.ca2}, math.NewInt(0), sdk.Coins{s.ca0}, true}, + {sdk.Coins{s.ca2}, math.NewInt(2), sdk.Coins{s.ca4}, false}, + {sdk.Coins{s.ca1, s.cm2}, math.NewInt(2), sdk.Coins{s.ca2, s.cm4}, false}, } assert := s.Assert() @@ -282,10 +282,10 @@ func (s *coinTestSuite) TestQuoIntCoins() { isValid bool shouldPanic bool }{ - {sdk.Coins{s.ca2, s.ca1}, sdk.NewInt(0), sdk.Coins{s.ca0, s.ca0}, true, true}, - {sdk.Coins{s.ca2}, sdk.NewInt(4), sdk.Coins{s.ca0}, false, false}, - {sdk.Coins{s.ca2, s.cm4}, sdk.NewInt(2), sdk.Coins{s.ca1, s.cm2}, true, false}, - {sdk.Coins{s.ca4}, sdk.NewInt(2), sdk.Coins{s.ca2}, true, false}, + {sdk.Coins{s.ca2, s.ca1}, math.NewInt(0), sdk.Coins{s.ca0, s.ca0}, true, true}, + {sdk.Coins{s.ca2}, math.NewInt(4), sdk.Coins{s.ca0}, false, false}, + {sdk.Coins{s.ca2, s.cm4}, math.NewInt(2), sdk.Coins{s.ca1, s.cm2}, true, false}, + {sdk.Coins{s.ca4}, math.NewInt(2), sdk.Coins{s.ca2}, true, false}, } assert := s.Assert() @@ -410,10 +410,10 @@ func (s *coinTestSuite) TestFilteredZeroCoins() { name: "all greater than zero", input: sdk.Coins{ {"testa", math.OneInt()}, - {"testb", sdk.NewInt(2)}, - {"testc", sdk.NewInt(3)}, - {"testd", sdk.NewInt(4)}, - {"teste", sdk.NewInt(5)}, + {"testb", math.NewInt(2)}, + {"testc", math.NewInt(3)}, + {"testd", math.NewInt(4)}, + {"teste", math.NewInt(5)}, }, original: "1testa,2testb,3testc,4testd,5teste", expected: "1testa,2testb,3testc,4testd,5teste", @@ -422,10 +422,10 @@ func (s *coinTestSuite) TestFilteredZeroCoins() { name: "zero coin in middle", input: sdk.Coins{ {"testa", math.OneInt()}, - {"testb", sdk.NewInt(2)}, - {"testc", sdk.NewInt(0)}, - {"testd", sdk.NewInt(4)}, - {"teste", sdk.NewInt(5)}, + {"testb", math.NewInt(2)}, + {"testc", math.NewInt(0)}, + {"testd", math.NewInt(4)}, + {"teste", math.NewInt(5)}, }, original: "1testa,2testb,0testc,4testd,5teste", expected: "1testa,2testb,4testd,5teste", @@ -433,11 +433,11 @@ func (s *coinTestSuite) TestFilteredZeroCoins() { { name: "zero coin end (unordered)", input: sdk.Coins{ - {"teste", sdk.NewInt(5)}, - {"testc", sdk.NewInt(3)}, + {"teste", math.NewInt(5)}, + {"testc", math.NewInt(3)}, {"testa", math.OneInt()}, - {"testd", sdk.NewInt(4)}, - {"testb", sdk.NewInt(0)}, + {"testd", math.NewInt(4)}, + {"testb", math.NewInt(0)}, }, original: "5teste,3testc,1testa,4testd,0testb", expected: "1testa,3testc,4testd,5teste", @@ -584,13 +584,13 @@ func (s *coinTestSuite) TestAddCoins() { // are correctly coalesced. Please see issue https://github.com/cosmos/cosmos-sdk/issues/13234 func TestCoinsAddCoalescesDuplicateDenominations(t *testing.T) { A := sdk.Coins{ - {"den", sdk.NewInt(2)}, - {"den", sdk.NewInt(3)}, + {"den", math.NewInt(2)}, + {"den", math.NewInt(3)}, } B := sdk.Coins{ - {"den", sdk.NewInt(3)}, - {"den", sdk.NewInt(2)}, - {"den", sdk.NewInt(1)}, + {"den", math.NewInt(3)}, + {"den", math.NewInt(2)}, + {"den", math.NewInt(1)}, } A = A.Sort() @@ -598,7 +598,7 @@ func TestCoinsAddCoalescesDuplicateDenominations(t *testing.T) { got := A.Add(B...) want := sdk.Coins{ - {"den", sdk.NewInt(11)}, + {"den", math.NewInt(11)}, } if !got.Equal(want) { @@ -758,7 +758,7 @@ func (s *coinTestSuite) TestCoins_Validate() { "IBC denominations (ADR 001)", sdk.Coins{ {"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", math.OneInt()}, - {"ibc/876563AAAACF739EB061C67CDB5EDF2B7C9FD4AA9D876450CC21210807C2820A", sdk.NewInt(2)}, + {"ibc/876563AAAACF739EB061C67CDB5EDF2B7C9FD4AA9D876450CC21210807C2820A", math.NewInt(2)}, }, true, }, @@ -820,7 +820,7 @@ func (s *coinTestSuite) TestCoins_Validate() { "non-positive amount (1)", sdk.Coins{ {"gas", math.OneInt()}, - {"tree", sdk.NewInt(0)}, + {"tree", math.NewInt(0)}, {"mineral", math.OneInt()}, }, false, @@ -828,7 +828,7 @@ func (s *coinTestSuite) TestCoins_Validate() { { "non-positive amount (2)", sdk.Coins{ - {"gas", sdk.NewInt(-1)}, + {"gas", math.NewInt(-1)}, {"tree", math.OneInt()}, {"mineral", math.OneInt()}, }, @@ -875,7 +875,7 @@ func (s *coinTestSuite) TestCoins_Validate() { func (s *coinTestSuite) TestMinMax() { one := math.OneInt() - two := sdk.NewInt(2) + two := math.NewInt(2) cases := []struct { name string @@ -907,7 +907,7 @@ func (s *coinTestSuite) TestMinMax() { func (s *coinTestSuite) TestCoinsGT() { one := math.OneInt() - two := sdk.NewInt(2) + two := math.NewInt(2) s.Require().False(sdk.Coins{}.IsAllGT(sdk.Coins{})) s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{})) @@ -919,7 +919,7 @@ func (s *coinTestSuite) TestCoinsGT() { func (s *coinTestSuite) TestCoinsLT() { one := math.OneInt() - two := sdk.NewInt(2) + two := math.NewInt(2) s.Require().False(sdk.Coins{}.IsAllLT(sdk.Coins{})) s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLT(sdk.Coins{})) @@ -934,7 +934,7 @@ func (s *coinTestSuite) TestCoinsLT() { func (s *coinTestSuite) TestCoinsLTE() { one := math.OneInt() - two := sdk.NewInt(2) + two := math.NewInt(2) s.Require().True(sdk.Coins{}.IsAllLTE(sdk.Coins{})) s.Require().False(sdk.Coins{{testDenom1, one}}.IsAllLTE(sdk.Coins{})) @@ -957,22 +957,22 @@ func (s *coinTestSuite) TestParseCoins() { }{ {"", true, nil}, {"0stake", true, sdk.Coins{}}, // remove zero coins - {"0stake,1foo,99bar", true, sdk.Coins{{"bar", sdk.NewInt(99)}, {"foo", one}}}, // remove zero coins + {"0stake,1foo,99bar", true, sdk.Coins{{"bar", math.NewInt(99)}, {"foo", one}}}, // remove zero coins {"1foo", true, sdk.Coins{{"foo", one}}}, {"10btc,1atom,20btc", false, nil}, - {"10bar", true, sdk.Coins{{"bar", sdk.NewInt(10)}}}, - {"99bar,1foo", true, sdk.Coins{{"bar", sdk.NewInt(99)}, {"foo", one}}}, - {"98 bar , 1 foo ", true, sdk.Coins{{"bar", sdk.NewInt(98)}, {"foo", one}}}, - {" 55\t \t bling\n", true, sdk.Coins{{"bling", sdk.NewInt(55)}}}, - {"2foo, 97 bar", true, sdk.Coins{{"bar", sdk.NewInt(97)}, {"foo", sdk.NewInt(2)}}}, - {"5 mycoin,", false, nil}, // no empty coins in a list - {"2 3foo, 97 bar", false, nil}, // 3foo is invalid coin name - {"11me coin, 12you coin", false, nil}, // no spaces in coin names - {"1.2btc", true, sdk.Coins{{"btc", sdk.NewInt(1)}}}, // amount can be decimal, will get truncated - {"5foo:bar", true, sdk.Coins{{"foo:bar", sdk.NewInt(5)}}}, - {"10atom10", true, sdk.Coins{{"atom10", sdk.NewInt(10)}}}, - {"200transfer/channelToA/uatom", true, sdk.Coins{{"transfer/channelToA/uatom", sdk.NewInt(200)}}}, - {"50ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", true, sdk.Coins{{"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", sdk.NewInt(50)}}}, + {"10bar", true, sdk.Coins{{"bar", math.NewInt(10)}}}, + {"99bar,1foo", true, sdk.Coins{{"bar", math.NewInt(99)}, {"foo", one}}}, + {"98 bar , 1 foo ", true, sdk.Coins{{"bar", math.NewInt(98)}, {"foo", one}}}, + {" 55\t \t bling\n", true, sdk.Coins{{"bling", math.NewInt(55)}}}, + {"2foo, 97 bar", true, sdk.Coins{{"bar", math.NewInt(97)}, {"foo", math.NewInt(2)}}}, + {"5 mycoin,", false, nil}, // no empty coins in a list + {"2 3foo, 97 bar", false, nil}, // 3foo is invalid coin name + {"11me coin, 12you coin", false, nil}, // no spaces in coin names + {"1.2btc", true, sdk.Coins{{"btc", math.NewInt(1)}}}, // amount can be decimal, will get truncated + {"5foo:bar", true, sdk.Coins{{"foo:bar", math.NewInt(5)}}}, + {"10atom10", true, sdk.Coins{{"atom10", math.NewInt(10)}}}, + {"200transfer/channelToA/uatom", true, sdk.Coins{{"transfer/channelToA/uatom", math.NewInt(200)}}}, + {"50ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", true, sdk.Coins{{"ibc/7F1D3FCF4AE79E1554D670D1AD949A9BA4E4A3C76C63093E17E446A46061A7A2", math.NewInt(50)}}}, {"120000000000000000000000000000000000000000000000000000000000000000000000000000btc", false, nil}, } @@ -1085,9 +1085,9 @@ func (s *coinTestSuite) TestSearch() { s.Run("AmountOf", func() { for i, tc := range amountOfCases { - require.Equal(sdk.NewInt(tc.amountOfGAS), tc.coins.AmountOf("gas"), i) - require.Equal(sdk.NewInt(tc.amountOfMINERAL), tc.coins.AmountOf("mineral"), i) - require.Equal(sdk.NewInt(tc.amountOfTREE), tc.coins.AmountOf("tree"), i) + require.Equal(math.NewInt(tc.amountOfGAS), tc.coins.AmountOf("gas"), i) + require.Equal(math.NewInt(tc.amountOfMINERAL), tc.coins.AmountOf("mineral"), i) + require.Equal(math.NewInt(tc.amountOfTREE), tc.coins.AmountOf("tree"), i) } require.Panics(func() { amountOfCases[0].coins.AmountOf("10Invalid") }) }) @@ -1119,7 +1119,7 @@ func (s *coinTestSuite) TestSearch() { func (s *coinTestSuite) TestCoinsIsAnyGTE() { one := math.OneInt() - two := sdk.NewInt(2) + two := math.NewInt(2) s.Require().False(sdk.Coins{}.IsAnyGTE(sdk.Coins{})) s.Require().False(sdk.Coins{{testDenom1, one}}.IsAnyGTE(sdk.Coins{})) @@ -1139,7 +1139,7 @@ func (s *coinTestSuite) TestCoinsIsAnyGTE() { func (s *coinTestSuite) TestCoinsIsAllGT() { one := math.OneInt() - two := sdk.NewInt(2) + two := math.NewInt(2) s.Require().False(sdk.Coins{}.IsAllGT(sdk.Coins{})) s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllGT(sdk.Coins{})) @@ -1159,7 +1159,7 @@ func (s *coinTestSuite) TestCoinsIsAllGT() { func (s *coinTestSuite) TestCoinsIsAllGTE() { one := math.OneInt() - two := sdk.NewInt(2) + two := math.NewInt(2) s.Require().True(sdk.Coins{}.IsAllGTE(sdk.Coins{})) s.Require().True(sdk.Coins{{testDenom1, one}}.IsAllGTE(sdk.Coins{})) diff --git a/types/dec_coin_test.go b/types/dec_coin_test.go index e072b2aadb90..3e746c028f28 100644 --- a/types/dec_coin_test.go +++ b/types/dec_coin_test.go @@ -50,16 +50,16 @@ func (s *decCoinTestSuite) TestNewDecCoinFromDec() { func (s *decCoinTestSuite) TestNewDecCoinFromCoin() { s.Require().NotPanics(func() { - sdk.NewDecCoinFromCoin(sdk.Coin{testDenom1, sdk.NewInt(5)}) + sdk.NewDecCoinFromCoin(sdk.Coin{testDenom1, math.NewInt(5)}) }) s.Require().NotPanics(func() { - sdk.NewDecCoinFromCoin(sdk.Coin{testDenom1, sdk.NewInt(0)}) + sdk.NewDecCoinFromCoin(sdk.Coin{testDenom1, math.NewInt(0)}) }) s.Require().NotPanics(func() { - sdk.NewDecCoinFromCoin(sdk.Coin{strings.ToUpper(testDenom1), sdk.NewInt(5)}) + sdk.NewDecCoinFromCoin(sdk.Coin{strings.ToUpper(testDenom1), math.NewInt(5)}) }) s.Require().Panics(func() { - sdk.NewDecCoinFromCoin(sdk.Coin{testDenom1, sdk.NewInt(-5)}) + sdk.NewDecCoinFromCoin(sdk.Coin{testDenom1, math.NewInt(-5)}) }) } @@ -188,7 +188,7 @@ func (s *decCoinTestSuite) TestIsValid() { msg string }{ { - sdk.NewDecCoin("mytoken", sdk.NewInt(10)), + sdk.NewDecCoin("mytoken", math.NewInt(10)), true, "valid coins should have passed", }, @@ -226,23 +226,23 @@ func (s *decCoinTestSuite) TestSubDecCoin() { msg string }{ { - sdk.NewDecCoin("mytoken", sdk.NewInt(20)), + sdk.NewDecCoin("mytoken", math.NewInt(20)), true, "valid coins should have passed", }, { - sdk.NewDecCoin("othertoken", sdk.NewInt(20)), + sdk.NewDecCoin("othertoken", math.NewInt(20)), false, "denom mismatch", }, { - sdk.NewDecCoin("mytoken", sdk.NewInt(9)), + sdk.NewDecCoin("mytoken", math.NewInt(9)), false, "negative amount", }, } - decCoin := sdk.NewDecCoin("mytoken", sdk.NewInt(10)) + decCoin := sdk.NewDecCoin("mytoken", math.NewInt(10)) for _, tc := range tests { tc := tc @@ -262,23 +262,23 @@ func (s *decCoinTestSuite) TestSubDecCoins() { msg string }{ { - sdk.NewDecCoinsFromCoins(sdk.NewCoin("mytoken", sdk.NewInt(10)), sdk.NewCoin("btc", sdk.NewInt(20)), sdk.NewCoin("eth", sdk.NewInt(30))), + sdk.NewDecCoinsFromCoins(sdk.NewCoin("mytoken", math.NewInt(10)), sdk.NewCoin("btc", math.NewInt(20)), sdk.NewCoin("eth", math.NewInt(30))), true, "sorted coins should have passed", }, { - sdk.DecCoins{sdk.NewDecCoin("mytoken", sdk.NewInt(10)), sdk.NewDecCoin("btc", sdk.NewInt(20)), sdk.NewDecCoin("eth", sdk.NewInt(30))}, + sdk.DecCoins{sdk.NewDecCoin("mytoken", math.NewInt(10)), sdk.NewDecCoin("btc", math.NewInt(20)), sdk.NewDecCoin("eth", math.NewInt(30))}, false, "unorted coins should panic", }, { - sdk.DecCoins{sdk.DecCoin{Denom: "BTC", Amount: math.LegacyNewDec(10)}, sdk.NewDecCoin("eth", sdk.NewInt(15)), sdk.NewDecCoin("mytoken", sdk.NewInt(5))}, + sdk.DecCoins{sdk.DecCoin{Denom: "BTC", Amount: math.LegacyNewDec(10)}, sdk.NewDecCoin("eth", math.NewInt(15)), sdk.NewDecCoin("mytoken", math.NewInt(5))}, false, "invalid denoms", }, } - decCoins := sdk.NewDecCoinsFromCoins(sdk.NewCoin("btc", sdk.NewInt(10)), sdk.NewCoin("eth", sdk.NewInt(15)), sdk.NewCoin("mytoken", sdk.NewInt(5))) + decCoins := sdk.NewDecCoinsFromCoins(sdk.NewCoin("btc", math.NewInt(10)), sdk.NewCoin("eth", math.NewInt(15)), sdk.NewCoin("mytoken", math.NewInt(5))) for _, tc := range tests { tc := tc @@ -375,7 +375,7 @@ func (s *decCoinTestSuite) TestParseDecCoins() { expectedErr bool }{ {"", nil, false}, - {"4stake", sdk.DecCoins{sdk.NewDecCoinFromDec("stake", sdk.NewDecFromInt(sdk.NewInt(4)))}, false}, + {"4stake", sdk.DecCoins{sdk.NewDecCoinFromDec("stake", sdk.NewDecFromInt(math.NewInt(4)))}, false}, {"5.5atom,4stake", sdk.DecCoins{ sdk.NewDecCoinFromDec("atom", sdk.NewDecWithPrec(5500000000000000000, sdk.Precision)), sdk.NewDecCoinFromDec("stake", math.LegacyNewDec(4)), @@ -513,7 +513,7 @@ func (s *decCoinTestSuite) TestDecCoinsQuoDecTruncate() { testCases := []struct { coins sdk.DecCoins - input sdk.Dec + input math.LegacyDec result sdk.DecCoins panics bool }{ @@ -534,8 +534,8 @@ func (s *decCoinTestSuite) TestDecCoinsQuoDecTruncate() { } func (s *decCoinTestSuite) TestNewDecCoinsWithIsValid() { - fake1 := append(sdk.NewDecCoins(sdk.NewDecCoin("mytoken", sdk.NewInt(10))), sdk.DecCoin{Denom: "10BTC", Amount: math.LegacyNewDec(10)}) - fake2 := append(sdk.NewDecCoins(sdk.NewDecCoin("mytoken", sdk.NewInt(10))), sdk.DecCoin{Denom: "BTC", Amount: math.LegacyNewDec(-10)}) + fake1 := append(sdk.NewDecCoins(sdk.NewDecCoin("mytoken", math.NewInt(10))), sdk.DecCoin{Denom: "10BTC", Amount: math.LegacyNewDec(10)}) + fake2 := append(sdk.NewDecCoins(sdk.NewDecCoin("mytoken", math.NewInt(10))), sdk.DecCoin{Denom: "BTC", Amount: math.LegacyNewDec(-10)}) tests := []struct { coin sdk.DecCoins @@ -543,7 +543,7 @@ func (s *decCoinTestSuite) TestNewDecCoinsWithIsValid() { msg string }{ { - sdk.NewDecCoins(sdk.NewDecCoin("mytoken", sdk.NewInt(10))), + sdk.NewDecCoins(sdk.NewDecCoin("mytoken", math.NewInt(10))), true, "valid coins should have passed", }, @@ -570,14 +570,14 @@ func (s *decCoinTestSuite) TestNewDecCoinsWithIsValid() { } func (s *decCoinTestSuite) TestNewDecCoinsWithZeroCoins() { - zeroCoins := append(sdk.NewCoins(sdk.NewCoin("mytoken", sdk.NewInt(0))), sdk.Coin{Denom: "wbtc", Amount: sdk.NewInt(10)}) + zeroCoins := append(sdk.NewCoins(sdk.NewCoin("mytoken", math.NewInt(0))), sdk.Coin{Denom: "wbtc", Amount: math.NewInt(10)}) tests := []struct { coins sdk.Coins expectLength int }{ { - sdk.NewCoins(sdk.NewCoin("mytoken", sdk.NewInt(10)), sdk.NewCoin("wbtc", sdk.NewInt(10))), + sdk.NewCoins(sdk.NewCoin("mytoken", math.NewInt(10)), sdk.NewCoin("wbtc", math.NewInt(10))), 2, }, { @@ -593,7 +593,7 @@ func (s *decCoinTestSuite) TestNewDecCoinsWithZeroCoins() { } func (s *decCoinTestSuite) TestDecCoins_AddDecCoinWithIsValid() { - lengthTestDecCoins := sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", sdk.NewInt(10))).Add(sdk.DecCoin{Denom: "BTC", Amount: math.LegacyNewDec(10)}) + lengthTestDecCoins := sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", math.NewInt(10))).Add(sdk.DecCoin{Denom: "BTC", Amount: math.LegacyNewDec(10)}) s.Require().Equal(2, len(lengthTestDecCoins), "should be 2") tests := []struct { @@ -602,17 +602,17 @@ func (s *decCoinTestSuite) TestDecCoins_AddDecCoinWithIsValid() { msg string }{ { - sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", sdk.NewInt(10))), + sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", math.NewInt(10))), true, "valid coins should have passed", }, { - sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", sdk.NewInt(10))).Add(sdk.DecCoin{Denom: "0BTC", Amount: math.LegacyNewDec(10)}), + sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", math.NewInt(10))).Add(sdk.DecCoin{Denom: "0BTC", Amount: math.LegacyNewDec(10)}), false, "invalid denoms", }, { - sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", sdk.NewInt(10))).Add(sdk.DecCoin{Denom: "BTC", Amount: math.LegacyNewDec(-10)}), + sdk.NewDecCoins().Add(sdk.NewDecCoin("mytoken", math.NewInt(10))).Add(sdk.DecCoin{Denom: "BTC", Amount: math.LegacyNewDec(-10)}), false, "negative amount", }, diff --git a/x/gov/keeper/deposit_test.go b/x/gov/keeper/deposit_test.go index 90eb68069cde..d0fec3191214 100644 --- a/x/gov/keeper/deposit_test.go +++ b/x/gov/keeper/deposit_test.go @@ -305,7 +305,7 @@ func TestChargeDeposit(t *testing.T) { govKeeper, authKeeper, bankKeeper, stakingKeeper, _, _, ctx := setupGovKeeper(t) params := v1.DefaultParams() params.ProposalCancelRatio = tc.proposalCancelRatio - TestAddrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(10000000000)) + TestAddrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 2, sdkmath.NewInt(10000000000)) for _, addr := range TestAddrs { authKeeper.EXPECT().BytesToString(addr).Return(addr.String(), nil).AnyTimes() authKeeper.EXPECT().StringToBytes(addr.String()).Return(addr, nil).AnyTimes() diff --git a/x/gov/keeper/tally.go b/x/gov/keeper/tally.go index d40778d8038c..48321d2effcf 100644 --- a/x/gov/keeper/tally.go +++ b/x/gov/keeper/tally.go @@ -12,7 +12,7 @@ import ( // Tally iterates over the votes and updates the tally of a proposal based on the voting power of the // voters func (keeper Keeper) Tally(ctx sdk.Context, proposal v1.Proposal) (passes, burnDeposits bool, tallyResults v1.TallyResult) { - results := make(map[v1.VoteOption]sdk.Dec) + results := make(map[v1.VoteOption]math.LegacyDec) results[v1.OptionYes] = math.LegacyZeroDec() results[v1.OptionAbstain] = math.LegacyZeroDec() results[v1.OptionNo] = math.LegacyZeroDec() diff --git a/x/gov/simulation/genesis.go b/x/gov/simulation/genesis.go index f6a3a9fd9bc5..e0d76aecd4d0 100644 --- a/x/gov/simulation/genesis.go +++ b/x/gov/simulation/genesis.go @@ -55,13 +55,13 @@ func GenExpeditedMinDeposit(r *rand.Rand, bondDenom string) sdk.Coins { } // GenDepositMinInitialRatio returns randomized DepositMinInitialRatio -func GenDepositMinInitialDepositRatio(r *rand.Rand) sdk.Dec { - return sdk.NewDec(int64(simulation.RandIntBetween(r, 0, 99))).Quo(sdk.NewDec(100)) +func GenDepositMinInitialDepositRatio(r *rand.Rand) sdkmath.LegacyDec { + return sdkmath.LegacyNewDec(int64(simulation.RandIntBetween(r, 0, 99))).Quo(sdkmath.LegacyNewDec(100)) } // GenProposalCancelRate returns randomized ProposalCancelRate -func GenProposalCancelRate(r *rand.Rand) sdk.Dec { - return sdk.NewDec(int64(simulation.RandIntBetween(r, 0, 99))).Quo(sdk.NewDec(100)) +func GenProposalCancelRate(r *rand.Rand) sdkmath.LegacyDec { + return sdkmath.LegacyNewDec(int64(simulation.RandIntBetween(r, 0, 99))).Quo(sdkmath.LegacyNewDec(100)) } // GenVotingPeriod returns randomized VotingPeriod @@ -85,7 +85,7 @@ func GenThreshold(r *rand.Rand) sdkmath.LegacyDec { } // GenExpeditedThreshold randomized ExpeditedThreshold -func GenExpeditedThreshold(r *rand.Rand) sdk.Dec { +func GenExpeditedThreshold(r *rand.Rand) sdkmath.LegacyDec { return sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(r, tallyNonExpeditedMax, 550)), 3) } @@ -116,13 +116,13 @@ func RandomizedGenState(simState *module.SimulationState) { func(r *rand.Rand) { depositPeriod = GenDepositPeriod(r) }, ) - var minInitialDepositRatio sdk.Dec + var minInitialDepositRatio sdkmath.LegacyDec simState.AppParams.GetOrGenerate( simState.Cdc, MinInitialRatio, &minInitialDepositRatio, simState.Rand, func(r *rand.Rand) { minInitialDepositRatio = GenDepositMinInitialDepositRatio(r) }, ) - var proposalCancelRate sdk.Dec + var proposalCancelRate sdkmath.LegacyDec simState.AppParams.GetOrGenerate( simState.Cdc, ProposalCancelRate, &proposalCancelRate, simState.Rand, func(r *rand.Rand) { proposalCancelRate = GenProposalCancelRate(r) }, @@ -140,25 +140,25 @@ func RandomizedGenState(simState *module.SimulationState) { func(r *rand.Rand) { expeditedVotingPeriod = GenExpeditedVotingPeriod(r) }, ) - var quorum sdk.Dec + var quorum sdkmath.LegacyDec simState.AppParams.GetOrGenerate( simState.Cdc, Quorum, &quorum, simState.Rand, func(r *rand.Rand) { quorum = GenQuorum(r) }, ) - var threshold sdk.Dec + var threshold sdkmath.LegacyDec simState.AppParams.GetOrGenerate( simState.Cdc, Threshold, &threshold, simState.Rand, func(r *rand.Rand) { threshold = GenThreshold(r) }, ) - var expitedVotingThreshold sdk.Dec + var expitedVotingThreshold sdkmath.LegacyDec simState.AppParams.GetOrGenerate( simState.Cdc, ExpeditedThreshold, &expitedVotingThreshold, simState.Rand, func(r *rand.Rand) { expitedVotingThreshold = GenExpeditedThreshold(r) }, ) - var veto sdk.Dec + var veto sdkmath.LegacyDec simState.AppParams.GetOrGenerate( simState.Cdc, Veto, &veto, simState.Rand, func(r *rand.Rand) { veto = GenVeto(r) }, diff --git a/x/params/keeper/keeper_test.go b/x/params/keeper/keeper_test.go index 4abc039932e1..721253ca6b19 100644 --- a/x/params/keeper/keeper_test.go +++ b/x/params/keeper/keeper_test.go @@ -209,7 +209,7 @@ func TestSubspace(t *testing.T) { types.NewParamSetPair([]byte("uint64"), uint64(0), validateNoOp), types.NewParamSetPair([]byte("int"), math.Int{}, validateNoOp), types.NewParamSetPair([]byte("uint"), math.Uint{}, validateNoOp), - types.NewParamSetPair([]byte("dec"), sdk.Dec{}, validateNoOp), + types.NewParamSetPair([]byte("dec"), math.LegacyDec{}, validateNoOp), types.NewParamSetPair([]byte("struct"), s{}, validateNoOp), ) diff --git a/x/slashing/client/cli/tx_test.go b/x/slashing/client/cli/tx_test.go index b7dff299e14c..c3b5d3803e5c 100644 --- a/x/slashing/client/cli/tx_test.go +++ b/x/slashing/client/cli/tx_test.go @@ -3,6 +3,8 @@ package cli_test import ( "fmt" + sdkmath "cosmossdk.io/math" + "github.com/cosmos/cosmos-sdk/client/flags" clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli" sdk "github.com/cosmos/cosmos-sdk/types" @@ -22,7 +24,7 @@ func (s *CLITestSuite) TestNewUnjailTxCmd() { fmt.Sprintf("--%s=%s", flags.FlagFrom, val.String()), fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync), // sync mode as there are no funds yet - 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()), }, "", }, diff --git a/x/slashing/keeper/hooks.go b/x/slashing/keeper/hooks.go index bdb2f38c1439..ede4480be7fd 100644 --- a/x/slashing/keeper/hooks.go +++ b/x/slashing/keeper/hooks.go @@ -3,6 +3,7 @@ package keeper import ( "time" + sdkmath "cosmossdk.io/math" "github.com/cometbft/cometbft/crypto" sdk "github.com/cosmos/cosmos-sdk/types" @@ -83,7 +84,7 @@ func (h Hooks) AfterDelegationModified(_ sdk.Context, _ sdk.AccAddress, _ sdk.Va return nil } -func (h Hooks) BeforeValidatorSlashed(_ sdk.Context, _ sdk.ValAddress, _ sdk.Dec) error { +func (h Hooks) BeforeValidatorSlashed(_ sdk.Context, _ sdk.ValAddress, _ sdkmath.LegacyDec) error { return nil } diff --git a/x/slashing/keeper/keeper.go b/x/slashing/keeper/keeper.go index 2c160f0a791e..92e810eebd41 100644 --- a/x/slashing/keeper/keeper.go +++ b/x/slashing/keeper/keeper.go @@ -4,6 +4,7 @@ import ( "fmt" "cosmossdk.io/log" + sdkmath "cosmossdk.io/math" storetypes "cosmossdk.io/store/types" @@ -72,13 +73,13 @@ func (k Keeper) GetPubkey(ctx sdk.Context, a cryptotypes.Address) (cryptotypes.P // Slash attempts to slash a validator. The slash is delegated to the staking // module to make the necessary validator changes. It specifies no intraction reason. -func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, fraction sdk.Dec, power, distributionHeight int64) { +func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, fraction sdkmath.LegacyDec, power, distributionHeight int64) { k.SlashWithInfractionReason(ctx, consAddr, fraction, power, distributionHeight, stakingtypes.Infraction_INFRACTION_UNSPECIFIED) } // SlashWithInfractionReason attempts to slash a validator. The slash is delegated to the staking // module to make the necessary validator changes. It specifies an intraction reason. -func (k Keeper) SlashWithInfractionReason(ctx sdk.Context, consAddr sdk.ConsAddress, fraction sdk.Dec, power, distributionHeight int64, infraction stakingtypes.Infraction) { +func (k Keeper) SlashWithInfractionReason(ctx sdk.Context, consAddr sdk.ConsAddress, fraction sdkmath.LegacyDec, power, distributionHeight int64, infraction stakingtypes.Infraction) { coinsBurned := k.sk.SlashWithInfractionReason(ctx, consAddr, distributionHeight, power, fraction, infraction) ctx.EventManager().EmitEvent( sdk.NewEvent( diff --git a/x/slashing/keeper/keeper_test.go b/x/slashing/keeper/keeper_test.go index e27cd8173e03..48ea926366d4 100644 --- a/x/slashing/keeper/keeper_test.go +++ b/x/slashing/keeper/keeper_test.go @@ -9,6 +9,7 @@ import ( cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" cmttime "github.com/cometbft/cometbft/types/time" + sdkmath "cosmossdk.io/math" storetypes "cosmossdk.io/store/types" "github.com/cosmos/cosmos-sdk/baseapp" @@ -81,16 +82,16 @@ func (s *KeeperTestSuite) TestJailAndSlash() { s.stakingKeeper.EXPECT().SlashWithInfractionReason(s.ctx, consAddr, s.ctx.BlockHeight(), - sdk.TokensToConsensusPower(sdk.NewInt(1), sdk.DefaultPowerReduction), + sdk.TokensToConsensusPower(sdkmath.NewInt(1), sdk.DefaultPowerReduction), s.slashingKeeper.SlashFractionDoubleSign(s.ctx), stakingtypes.Infraction_INFRACTION_UNSPECIFIED, - ).Return(sdk.NewInt(0)) + ).Return(sdkmath.NewInt(0)) s.slashingKeeper.Slash( s.ctx, consAddr, s.slashingKeeper.SlashFractionDoubleSign(s.ctx), - sdk.TokensToConsensusPower(sdk.NewInt(1), sdk.DefaultPowerReduction), + sdk.TokensToConsensusPower(sdkmath.NewInt(1), sdk.DefaultPowerReduction), s.ctx.BlockHeight(), ) @@ -102,16 +103,16 @@ func (s *KeeperTestSuite) TestJailAndSlashWithInfractionReason() { s.stakingKeeper.EXPECT().SlashWithInfractionReason(s.ctx, consAddr, s.ctx.BlockHeight(), - sdk.TokensToConsensusPower(sdk.NewInt(1), sdk.DefaultPowerReduction), + sdk.TokensToConsensusPower(sdkmath.NewInt(1), sdk.DefaultPowerReduction), s.slashingKeeper.SlashFractionDoubleSign(s.ctx), stakingtypes.Infraction_INFRACTION_DOUBLE_SIGN, - ).Return(sdk.NewInt(0)) + ).Return(sdkmath.NewInt(0)) s.slashingKeeper.SlashWithInfractionReason( s.ctx, consAddr, s.slashingKeeper.SlashFractionDoubleSign(s.ctx), - sdk.TokensToConsensusPower(sdk.NewInt(1), sdk.DefaultPowerReduction), + sdk.TokensToConsensusPower(sdkmath.NewInt(1), sdk.DefaultPowerReduction), s.ctx.BlockHeight(), stakingtypes.Infraction_INFRACTION_DOUBLE_SIGN, ) diff --git a/x/slashing/keeper/msg_server_test.go b/x/slashing/keeper/msg_server_test.go index 2fa9bc681638..cb401957771e 100644 --- a/x/slashing/keeper/msg_server_test.go +++ b/x/slashing/keeper/msg_server_test.go @@ -3,6 +3,8 @@ package keeper_test import ( "time" + sdkmath "cosmossdk.io/math" + "github.com/cosmos/cosmos-sdk/testutil/testdata" sdk "github.com/cosmos/cosmos-sdk/types" slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types" @@ -12,16 +14,16 @@ import ( func (s *KeeperTestSuite) TestUpdateParams() { require := s.Require() - minSignedPerWindow, err := sdk.NewDecFromStr("0.60") + minSignedPerWindow, err := sdkmath.LegacyNewDecFromStr("0.60") require.NoError(err) - slashFractionDoubleSign, err := sdk.NewDecFromStr("0.022") + slashFractionDoubleSign, err := sdkmath.LegacyNewDecFromStr("0.022") require.NoError(err) - slashFractionDowntime, err := sdk.NewDecFromStr("0.0089") + slashFractionDowntime, err := sdkmath.LegacyNewDecFromStr("0.0089") require.NoError(err) - invalidVal, err := sdk.NewDecFromStr("-1") + invalidVal, err := sdkmath.LegacyNewDecFromStr("-1") require.NoError(err) testCases := []struct { @@ -200,8 +202,8 @@ func (s *KeeperTestSuite) TestUnjail() { valAddr := sdk.ValAddress(addr) val, err := types.NewValidator(valAddr, pubKey, types.Description{Moniker: "test"}) - val.Tokens = sdk.NewInt(1000) - val.DelegatorShares = sdk.NewDec(1) + val.Tokens = sdkmath.NewInt(1000) + val.DelegatorShares = sdkmath.LegacyNewDec(1) val.Jailed = false s.Require().NoError(err) @@ -212,7 +214,7 @@ func (s *KeeperTestSuite) TestUnjail() { s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info) s.stakingKeeper.EXPECT().Validator(s.ctx, valAddr).Return(val) - del := types.NewDelegation(addr, valAddr, sdk.NewDec(100)) + del := types.NewDelegation(addr, valAddr, sdkmath.LegacyNewDec(100)) s.stakingKeeper.EXPECT().Delegation(s.ctx, addr, valAddr).Return(del) @@ -230,8 +232,8 @@ func (s *KeeperTestSuite) TestUnjail() { valAddr := sdk.ValAddress(addr) val, err := types.NewValidator(valAddr, pubKey, types.Description{Moniker: "test"}) - val.Tokens = sdk.NewInt(1000) - val.DelegatorShares = sdk.NewDec(1) + val.Tokens = sdkmath.NewInt(1000) + val.DelegatorShares = sdkmath.LegacyNewDec(1) val.Jailed = true s.Require().NoError(err) @@ -242,7 +244,7 @@ func (s *KeeperTestSuite) TestUnjail() { s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info) s.stakingKeeper.EXPECT().Validator(s.ctx, valAddr).Return(val) - del := types.NewDelegation(addr, valAddr, sdk.NewDec(100)) + del := types.NewDelegation(addr, valAddr, sdkmath.LegacyNewDec(100)) s.stakingKeeper.EXPECT().Delegation(s.ctx, addr, valAddr).Return(del) @@ -260,8 +262,8 @@ func (s *KeeperTestSuite) TestUnjail() { valAddr := sdk.ValAddress(addr) val, err := types.NewValidator(valAddr, pubKey, types.Description{Moniker: "test"}) - val.Tokens = sdk.NewInt(1000) - val.DelegatorShares = sdk.NewDec(1) + val.Tokens = sdkmath.NewInt(1000) + val.DelegatorShares = sdkmath.LegacyNewDec(1) val.Jailed = true s.Require().NoError(err) @@ -272,7 +274,7 @@ func (s *KeeperTestSuite) TestUnjail() { s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info) s.stakingKeeper.EXPECT().Validator(s.ctx, valAddr).Return(val) - del := types.NewDelegation(addr, valAddr, sdk.NewDec(10000)) + del := types.NewDelegation(addr, valAddr, sdkmath.LegacyNewDec(10000)) s.stakingKeeper.EXPECT().Delegation(s.ctx, addr, valAddr).Return(del) @@ -290,8 +292,8 @@ func (s *KeeperTestSuite) TestUnjail() { valAddr := sdk.ValAddress(addr) val, err := types.NewValidator(valAddr, pubKey, types.Description{Moniker: "test"}) - val.Tokens = sdk.NewInt(1000) - val.DelegatorShares = sdk.NewDec(1) + val.Tokens = sdkmath.NewInt(1000) + val.DelegatorShares = sdkmath.LegacyNewDec(1) val.Jailed = true s.Require().NoError(err) @@ -302,7 +304,7 @@ func (s *KeeperTestSuite) TestUnjail() { s.slashingKeeper.SetValidatorSigningInfo(s.ctx, sdk.ConsAddress(addr), info) s.stakingKeeper.EXPECT().Validator(s.ctx, valAddr).Return(val) - del := types.NewDelegation(addr, valAddr, sdk.NewDec(100)) + del := types.NewDelegation(addr, valAddr, sdkmath.LegacyNewDec(100)) s.stakingKeeper.EXPECT().Delegation(s.ctx, addr, valAddr).Return(del) s.stakingKeeper.EXPECT().Unjail(s.ctx, sdk.ConsAddress(addr)).Return() diff --git a/x/slashing/keeper/params.go b/x/slashing/keeper/params.go index 787b108be6e6..77371845a696 100644 --- a/x/slashing/keeper/params.go +++ b/x/slashing/keeper/params.go @@ -3,6 +3,8 @@ package keeper import ( "time" + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/slashing/types" ) @@ -28,12 +30,12 @@ func (k Keeper) DowntimeJailDuration(ctx sdk.Context) (res time.Duration) { } // SlashFractionDoubleSign - fraction of power slashed in case of double sign -func (k Keeper) SlashFractionDoubleSign(ctx sdk.Context) (res sdk.Dec) { +func (k Keeper) SlashFractionDoubleSign(ctx sdk.Context) (res sdkmath.LegacyDec) { return k.GetParams(ctx).SlashFractionDoubleSign } // SlashFractionDowntime - fraction of power slashed for downtime -func (k Keeper) SlashFractionDowntime(ctx sdk.Context) (res sdk.Dec) { +func (k Keeper) SlashFractionDowntime(ctx sdk.Context) (res sdkmath.LegacyDec) { return k.GetParams(ctx).SlashFractionDowntime } diff --git a/x/slashing/simulation/genesis.go b/x/slashing/simulation/genesis.go index 456d2b06c983..f5b00bc39657 100644 --- a/x/slashing/simulation/genesis.go +++ b/x/slashing/simulation/genesis.go @@ -7,7 +7,6 @@ import ( "time" "cosmossdk.io/math" - sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" "github.com/cosmos/cosmos-sdk/types/simulation" "github.com/cosmos/cosmos-sdk/x/slashing/types" @@ -29,7 +28,7 @@ func GenSignedBlocksWindow(r *rand.Rand) int64 { // GenMinSignedPerWindow randomized MinSignedPerWindow func GenMinSignedPerWindow(r *rand.Rand) math.LegacyDec { - return sdk.NewDecWithPrec(int64(r.Intn(10)), 1) + return math.LegacyNewDecWithPrec(int64(r.Intn(10)), 1) } // GenDowntimeJailDuration randomized DowntimeJailDuration @@ -55,7 +54,7 @@ func RandomizedGenState(simState *module.SimulationState) { func(r *rand.Rand) { signedBlocksWindow = GenSignedBlocksWindow(r) }, ) - var minSignedPerWindow sdk.Dec + var minSignedPerWindow math.LegacyDec simState.AppParams.GetOrGenerate( simState.Cdc, MinSignedPerWindow, &minSignedPerWindow, simState.Rand, func(r *rand.Rand) { minSignedPerWindow = GenMinSignedPerWindow(r) }, @@ -67,13 +66,13 @@ func RandomizedGenState(simState *module.SimulationState) { func(r *rand.Rand) { downtimeJailDuration = GenDowntimeJailDuration(r) }, ) - var slashFractionDoubleSign sdk.Dec + var slashFractionDoubleSign math.LegacyDec simState.AppParams.GetOrGenerate( simState.Cdc, SlashFractionDoubleSign, &slashFractionDoubleSign, simState.Rand, func(r *rand.Rand) { slashFractionDoubleSign = GenSlashFractionDoubleSign(r) }, ) - var slashFractionDowntime sdk.Dec + var slashFractionDowntime math.LegacyDec simState.AppParams.GetOrGenerate( simState.Cdc, SlashFractionDowntime, &slashFractionDowntime, simState.Rand, func(r *rand.Rand) { slashFractionDowntime = GenSlashFractionDowntime(r) }, diff --git a/x/slashing/simulation/genesis_test.go b/x/slashing/simulation/genesis_test.go index 55bce42a84a6..b24c6e08d60f 100644 --- a/x/slashing/simulation/genesis_test.go +++ b/x/slashing/simulation/genesis_test.go @@ -11,7 +11,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/slashing/simulation" @@ -42,9 +41,9 @@ func TestRandomizedGenState(t *testing.T) { var slashingGenesis types.GenesisState simState.Cdc.MustUnmarshalJSON(simState.GenState[types.ModuleName], &slashingGenesis) - dec1, _ := sdk.NewDecFromStr("0.600000000000000000") - dec2, _ := sdk.NewDecFromStr("0.022222222222222222") - dec3, _ := sdk.NewDecFromStr("0.008928571428571429") + dec1, _ := sdkmath.LegacyNewDecFromStr("0.600000000000000000") + dec2, _ := sdkmath.LegacyNewDecFromStr("0.022222222222222222") + dec3, _ := sdkmath.LegacyNewDecFromStr("0.008928571428571429") require.Equal(t, dec1, slashingGenesis.Params.MinSignedPerWindow) require.Equal(t, dec2, slashingGenesis.Params.SlashFractionDoubleSign) diff --git a/x/slashing/simulation/operations_test.go b/x/slashing/simulation/operations_test.go index 324d55e2d160..5c7f6129d8d3 100644 --- a/x/slashing/simulation/operations_test.go +++ b/x/slashing/simulation/operations_test.go @@ -215,7 +215,7 @@ func getTestingValidator(ctx sdk.Context, stakingKeeper *stakingkeeper.Keeper, a } validator.DelegatorShares = math.LegacyNewDec(100) - validator.Tokens = sdk.NewInt(1000000) + validator.Tokens = math.NewInt(1000000) stakingKeeper.SetValidator(ctx, validator) diff --git a/x/slashing/simulation/proposals.go b/x/slashing/simulation/proposals.go index 86b5d5a532d8..7985e2290e67 100644 --- a/x/slashing/simulation/proposals.go +++ b/x/slashing/simulation/proposals.go @@ -4,6 +4,8 @@ import ( "math/rand" "time" + 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" @@ -37,9 +39,9 @@ func SimulateMsgUpdateParams(r *rand.Rand, _ sdk.Context, _ []simtypes.Account) params := types.DefaultParams() params.DowntimeJailDuration = time.Duration(simtypes.RandTimestamp(r).UnixNano()) params.SignedBlocksWindow = int64(simtypes.RandIntBetween(r, 1, 1000)) - params.MinSignedPerWindow = sdk.NewDecWithPrec(int64(simtypes.RandIntBetween(r, 1, 100)), 2) - params.SlashFractionDoubleSign = sdk.NewDecWithPrec(int64(simtypes.RandIntBetween(r, 1, 100)), 2) - params.SlashFractionDowntime = sdk.NewDecWithPrec(int64(simtypes.RandIntBetween(r, 1, 100)), 2) + params.MinSignedPerWindow = sdkmath.LegacyNewDecWithPrec(int64(simtypes.RandIntBetween(r, 1, 100)), 2) + params.SlashFractionDoubleSign = sdkmath.LegacyNewDecWithPrec(int64(simtypes.RandIntBetween(r, 1, 100)), 2) + params.SlashFractionDowntime = sdkmath.LegacyNewDecWithPrec(int64(simtypes.RandIntBetween(r, 1, 100)), 2) return &types.MsgUpdateParams{ Authority: authority.String(), diff --git a/x/slashing/simulation/proposals_test.go b/x/slashing/simulation/proposals_test.go index 97ac001140c9..356c53777155 100644 --- a/x/slashing/simulation/proposals_test.go +++ b/x/slashing/simulation/proposals_test.go @@ -5,6 +5,7 @@ import ( "testing" "time" + sdkmath "cosmossdk.io/math" cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" "gotest.tools/v3/assert" @@ -39,8 +40,8 @@ func TestProposalMsgs(t *testing.T) { assert.Equal(t, sdk.AccAddress(address.Module("gov")).String(), msgUpdateParams.Authority) assert.Equal(t, int64(905), msgUpdateParams.Params.SignedBlocksWindow) - assert.DeepEqual(t, sdk.NewDecWithPrec(7, 2), msgUpdateParams.Params.MinSignedPerWindow) - assert.DeepEqual(t, sdk.NewDecWithPrec(60, 2), msgUpdateParams.Params.SlashFractionDoubleSign) - assert.DeepEqual(t, sdk.NewDecWithPrec(89, 2), msgUpdateParams.Params.SlashFractionDowntime) + assert.DeepEqual(t, sdkmath.LegacyNewDecWithPrec(7, 2), msgUpdateParams.Params.MinSignedPerWindow) + assert.DeepEqual(t, sdkmath.LegacyNewDecWithPrec(60, 2), msgUpdateParams.Params.SlashFractionDoubleSign) + assert.DeepEqual(t, sdkmath.LegacyNewDecWithPrec(89, 2), msgUpdateParams.Params.SlashFractionDowntime) assert.Equal(t, 3313479009*time.Second, msgUpdateParams.Params.DowntimeJailDuration) } diff --git a/x/slashing/types/expected_keepers.go b/x/slashing/types/expected_keepers.go index ba7a34c58ac5..495d25b6011b 100644 --- a/x/slashing/types/expected_keepers.go +++ b/x/slashing/types/expected_keepers.go @@ -43,8 +43,8 @@ type StakingKeeper interface { ValidatorByConsAddr(sdk.Context, sdk.ConsAddress) stakingtypes.ValidatorI // get a particular validator by consensus address // slash the validator and delegators of the validator, specifying offense height, offense power, and slash fraction - Slash(sdk.Context, sdk.ConsAddress, int64, int64, sdk.Dec) math.Int - SlashWithInfractionReason(sdk.Context, sdk.ConsAddress, int64, int64, sdk.Dec, stakingtypes.Infraction) math.Int + Slash(sdk.Context, sdk.ConsAddress, int64, int64, math.LegacyDec) math.Int + SlashWithInfractionReason(sdk.Context, sdk.ConsAddress, int64, int64, math.LegacyDec, stakingtypes.Infraction) math.Int Jail(sdk.Context, sdk.ConsAddress) // jail a validator Unjail(sdk.Context, sdk.ConsAddress) // unjail a validator @@ -73,5 +73,5 @@ type StakingHooks interface { BeforeDelegationSharesModified(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) error // Must be called when a delegation's shares are modified BeforeDelegationRemoved(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) error // Must be called when a delegation is removed AfterDelegationModified(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) error - BeforeValidatorSlashed(ctx sdk.Context, valAddr sdk.ValAddress, fraction sdk.Dec) error + BeforeValidatorSlashed(ctx sdk.Context, valAddr sdk.ValAddress, fraction math.LegacyDec) error } diff --git a/x/slashing/types/params.go b/x/slashing/types/params.go index ec7ef191b6dc..2003922d6d2f 100644 --- a/x/slashing/types/params.go +++ b/x/slashing/types/params.go @@ -5,8 +5,6 @@ import ( "time" "cosmossdk.io/math" - - sdk "github.com/cosmos/cosmos-sdk/types" ) // Default parameter namespace @@ -16,15 +14,15 @@ const ( ) var ( - DefaultMinSignedPerWindow = sdk.NewDecWithPrec(5, 1) + DefaultMinSignedPerWindow = math.LegacyNewDecWithPrec(5, 1) DefaultSlashFractionDoubleSign = math.LegacyNewDec(1).Quo(math.LegacyNewDec(20)) DefaultSlashFractionDowntime = math.LegacyNewDec(1).Quo(math.LegacyNewDec(100)) ) // NewParams creates a new Params object func NewParams( - signedBlocksWindow int64, minSignedPerWindow sdk.Dec, downtimeJailDuration time.Duration, - slashFractionDoubleSign, slashFractionDowntime sdk.Dec, + signedBlocksWindow int64, minSignedPerWindow math.LegacyDec, downtimeJailDuration time.Duration, + slashFractionDoubleSign, slashFractionDowntime math.LegacyDec, ) Params { return Params{ SignedBlocksWindow: signedBlocksWindow, @@ -80,7 +78,7 @@ func validateSignedBlocksWindow(i interface{}) error { } func validateMinSignedPerWindow(i interface{}) error { - v, ok := i.(sdk.Dec) + v, ok := i.(math.LegacyDec) if !ok { return fmt.Errorf("invalid parameter type: %T", i) } @@ -112,7 +110,7 @@ func validateDowntimeJailDuration(i interface{}) error { } func validateSlashFractionDoubleSign(i interface{}) error { - v, ok := i.(sdk.Dec) + v, ok := i.(math.LegacyDec) if !ok { return fmt.Errorf("invalid parameter type: %T", i) } @@ -131,7 +129,7 @@ func validateSlashFractionDoubleSign(i interface{}) error { } func validateSlashFractionDowntime(i interface{}) error { - v, ok := i.(sdk.Dec) + v, ok := i.(math.LegacyDec) if !ok { return fmt.Errorf("invalid parameter type: %T", i) } diff --git a/x/staking/bench_test.go b/x/staking/bench_test.go index 26f533e2e132..1d0fe95c4b4e 100644 --- a/x/staking/bench_test.go +++ b/x/staking/bench_test.go @@ -32,7 +32,7 @@ func benchmarkValidateGenesis(b *testing.B, n int) { addr, pubKey := addressL[i], pubKeyL[i] validator := testutil.NewValidator(b, addr, pubKey) ni := int64(i + 1) - validator.Tokens = sdk.NewInt(ni) + validator.Tokens = math.NewInt(ni) validator.DelegatorShares = math.LegacyNewDec(ni) validators = append(validators, validator) } diff --git a/x/staking/client/cli/tx.go b/x/staking/client/cli/tx.go index 35599b0b6089..879fa30589d8 100644 --- a/x/staking/client/cli/tx.go +++ b/x/staking/client/cli/tx.go @@ -136,11 +136,11 @@ func NewEditValidatorCmd() *cobra.Command { details, _ := cmd.Flags().GetString(FlagDetails) description := types.NewDescription(moniker, identity, website, security, details) - var newRate *sdk.Dec + var newRate *math.LegacyDec commissionRate, _ := cmd.Flags().GetString(FlagCommissionRate) if commissionRate != "" { - rate, err := sdk.NewDecFromStr(commissionRate) + rate, err := math.LegacyNewDecFromStr(commissionRate) if err != nil { return fmt.Errorf("invalid new commission rate: %v", err) } @@ -152,7 +152,7 @@ func NewEditValidatorCmd() *cobra.Command { minSelfDelegationString, _ := cmd.Flags().GetString(FlagMinSelfDelegation) if minSelfDelegationString != "" { - msb, ok := sdk.NewIntFromString(minSelfDelegationString) + msb, ok := math.NewIntFromString(minSelfDelegationString) if !ok { return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "minimum self delegation must be a positive integer") } @@ -577,7 +577,7 @@ func BuildCreateValidatorMsg(clientCtx client.Context, config TxCreateValidatorC // get the initial validator min self delegation msbStr := config.MinSelfDelegation - minSelfDelegation, ok := sdk.NewIntFromString(msbStr) + minSelfDelegation, ok := math.NewIntFromString(msbStr) if !ok { return txBldr, nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "minimum self delegation must be a positive integer") diff --git a/x/staking/client/cli/utils.go b/x/staking/client/cli/utils.go index de3f0655992f..bd9ba90df934 100644 --- a/x/staking/client/cli/utils.go +++ b/x/staking/client/cli/utils.go @@ -83,7 +83,7 @@ func parseAndValidateValidatorJSON(cdc codec.Codec, path string) (validator, err if v.MinSelfDelegation == "" { return validator{}, fmt.Errorf("must specify minimum self delegation") } - minSelfDelegation, ok := sdk.NewIntFromString(v.MinSelfDelegation) + minSelfDelegation, ok := math.NewIntFromString(v.MinSelfDelegation) if !ok { return validator{}, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "minimum self delegation must be a positive integer") } @@ -106,17 +106,17 @@ func buildCommissionRates(rateStr, maxRateStr, maxChangeRateStr string) (commiss return commission, errors.New("must specify all validator commission parameters") } - rate, err := sdk.NewDecFromStr(rateStr) + rate, err := math.LegacyNewDecFromStr(rateStr) if err != nil { return commission, err } - maxRate, err := sdk.NewDecFromStr(maxRateStr) + maxRate, err := math.LegacyNewDecFromStr(maxRateStr) if err != nil { return commission, err } - maxChangeRate, err := sdk.NewDecFromStr(maxChangeRateStr) + maxChangeRate, err := math.LegacyNewDecFromStr(maxChangeRateStr) if err != nil { return commission, err } diff --git a/x/staking/keeper/delegation.go b/x/staking/keeper/delegation.go index 7157d92d8646..49968aff99fd 100644 --- a/x/staking/keeper/delegation.go +++ b/x/staking/keeper/delegation.go @@ -525,7 +525,7 @@ func (k Keeper) SetRedelegationEntry(ctx sdk.Context, delegatorAddr sdk.AccAddress, validatorSrcAddr, validatorDstAddr sdk.ValAddress, creationHeight int64, minTime time.Time, balance math.Int, - sharesSrc, sharesDst sdk.Dec, + sharesSrc, sharesDst math.LegacyDec, ) types.Redelegation { red, found := k.GetRedelegation(ctx, delegatorAddr, validatorSrcAddr, validatorDstAddr) id := k.IncrementUnbondingID(ctx) @@ -665,7 +665,7 @@ func (k Keeper) DequeueAllMatureRedelegationQueue(ctx sdk.Context, currTime time func (k Keeper) Delegate( ctx sdk.Context, delAddr sdk.AccAddress, bondAmt math.Int, tokenSrc types.BondStatus, validator types.Validator, subtractAccount bool, -) (newShares sdk.Dec, err error) { +) (newShares math.LegacyDec, err error) { // In some situations, the exchange rate becomes invalid, e.g. if // Validator loses all tokens due to slashing. In this case, // make all future delegations invalid. @@ -716,7 +716,7 @@ func (k Keeper) Delegate( coins := sdk.NewCoins(sdk.NewCoin(k.BondDenom(ctx), bondAmt)) if err := k.bankKeeper.DelegateCoinsFromAccountToModule(ctx, delegatorAddress, sendName, coins); err != nil { - return sdk.Dec{}, err + return math.LegacyDec{}, err } } else { // potentially transfer tokens between pools, if @@ -752,7 +752,7 @@ func (k Keeper) Delegate( // Unbond unbonds a particular delegation and perform associated store operations. func (k Keeper) Unbond( - ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, shares sdk.Dec, + ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, shares math.LegacyDec, ) (amount math.Int, err error) { // check if a delegation object exists in the store delegation, found := k.GetDelegation(ctx, delAddr, valAddr) @@ -851,7 +851,7 @@ func (k Keeper) getBeginInfo( // an unbonding object and inserting it into the unbonding queue which will be // processed during the staking EndBlocker. func (k Keeper) Undelegate( - ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, sharesAmount sdk.Dec, + ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, sharesAmount math.LegacyDec, ) (time.Time, math.Int, error) { validator, found := k.GetValidator(ctx, valAddr) if !found { @@ -932,7 +932,7 @@ func (k Keeper) CompleteUnbonding(ctx sdk.Context, delAddr sdk.AccAddress, valAd // BeginRedelegation begins unbonding / redelegation and creates a redelegation // record. func (k Keeper) BeginRedelegation( - ctx sdk.Context, delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress, sharesAmount sdk.Dec, + ctx sdk.Context, delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress, sharesAmount math.LegacyDec, ) (completionTime time.Time, err error) { if bytes.Equal(valSrcAddr, valDstAddr) { return time.Time{}, types.ErrSelfRedelegation @@ -1031,7 +1031,7 @@ func (k Keeper) CompleteRedelegation( // amount of respective shares is returned, otherwise an error is returned. func (k Keeper) ValidateUnbondAmount( ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, amt math.Int, -) (shares sdk.Dec, err error) { +) (shares math.LegacyDec, err error) { validator, found := k.GetValidator(ctx, valAddr) if !found { return shares, types.ErrNoValidatorFound diff --git a/x/staking/keeper/delegation_test.go b/x/staking/keeper/delegation_test.go index 1eba4d8a0bc3..24e34de22b2b 100644 --- a/x/staking/keeper/delegation_test.go +++ b/x/staking/keeper/delegation_test.go @@ -33,7 +33,7 @@ func (s *KeeperTestSuite) TestDelegation() { } // construct the validators - amts := []math.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)} + amts := []math.Int{math.NewInt(9), math.NewInt(8), math.NewInt(7)} var validators [3]stakingtypes.Validator for i, amt := range amts { validators[i] = testutil.NewValidator(s.T(), valAddrs[i], PKs[i]) @@ -119,7 +119,7 @@ func (s *KeeperTestSuite) TestDelegation() { // test total bonded for single delegator expBonded := bond1to1.Shares.Add(bond2to1.Shares).Add(bond1to3.Shares) resDelBond := keeper.GetDelegatorBonded(ctx, addrDels[0]) - require.Equal(expBonded, sdk.NewDecFromInt(resDelBond)) + require.Equal(expBonded, math.LegacyNewDecFromInt(resDelBond)) // delete a record keeper.RemoveDelegation(ctx, bond2to3) @@ -238,7 +238,7 @@ func (s *KeeperTestSuite) TestUnbondingDelegation() { valAddrs[0], 0, time.Unix(0, 0).UTC(), - sdk.NewInt(5), + math.NewInt(5), 0, ) @@ -249,7 +249,7 @@ func (s *KeeperTestSuite) TestUnbondingDelegation() { require.Equal(ubd, resUnbond) // modify a records, save, and retrieve - expUnbond := sdk.NewInt(21) + expUnbond := math.NewInt(21) ubd.Entries[0].Balance = expUnbond keeper.SetUnbondingDelegation(ctx, ubd) @@ -301,7 +301,7 @@ func (s *KeeperTestSuite) TestUnbondDelegation() { keeper.SetDelegation(ctx, delegation) bondTokens := keeper.TokensFromConsensusPower(ctx, 6) - amount, err := keeper.Unbond(ctx, delAddrs[0], valAddrs[0], sdk.NewDecFromInt(bondTokens)) + amount, err := keeper.Unbond(ctx, delAddrs[0], valAddrs[0], math.LegacyNewDecFromInt(bondTokens)) require.NoError(err) require.Equal(bondTokens, amount) // shares to be added to an unbonding delegation @@ -356,7 +356,7 @@ func (s *KeeperTestSuite) TestUndelegateSelfDelegationBelowMinSelfDelegation() { val0AccAddr := sdk.AccAddress(addrVals[0].Bytes()) s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any()) - _, _, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(keeper.TokensFromConsensusPower(ctx, 6))) + _, _, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], math.LegacyNewDecFromInt(keeper.TokensFromConsensusPower(ctx, 6))) require.NoError(err) // end block @@ -415,7 +415,7 @@ func (s *KeeperTestSuite) TestUndelegateFromUnbondingValidator() { // unbond the all self-delegation to put validator in unbonding state val0AccAddr := sdk.AccAddress(addrVals[0]) s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any()) - _, amount, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(delTokens)) + _, amount, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], math.LegacyNewDecFromInt(delTokens)) require.NoError(err) require.Equal(amount, delTokens) @@ -444,7 +444,7 @@ func (s *KeeperTestSuite) TestUndelegateFromUnbondingValidator() { ubd, found := keeper.GetUnbondingDelegation(ctx, addrDels[1], addrVals[0]) require.True(found) require.Len(ubd.Entries, 1) - require.True(ubd.Entries[0].Balance.Equal(sdk.NewInt(6))) + require.True(ubd.Entries[0].Balance.Equal(math.NewInt(6))) require.Equal(blockHeight2, ubd.Entries[0].CreationHeight) require.True(blockTime2.Add(params.UnbondingTime).Equal(ubd.Entries[0].CompletionTime)) } @@ -489,7 +489,7 @@ func (s *KeeperTestSuite) TestUndelegateFromUnbondedValidator() { // unbond the all self-delegation to put validator in unbonding state s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any()) - _, amount, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens)) + _, amount, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], math.LegacyNewDecFromInt(valTokens)) require.NoError(err) require.Equal(amount, valTokens) @@ -514,13 +514,13 @@ func (s *KeeperTestSuite) TestUndelegateFromUnbondedValidator() { // unbond some of the other delegation's shares unbondTokens := keeper.TokensFromConsensusPower(ctx, 6) - _, amount2, err := keeper.Undelegate(ctx, addrDels[1], addrVals[0], sdk.NewDecFromInt(unbondTokens)) + _, amount2, err := keeper.Undelegate(ctx, addrDels[1], addrVals[0], math.LegacyNewDecFromInt(unbondTokens)) require.NoError(err) require.Equal(amount2, unbondTokens) // unbond rest of the other delegation's shares remainingTokens := delTokens.Sub(unbondTokens) - _, amount3, err := keeper.Undelegate(ctx, addrDels[1], addrVals[0], sdk.NewDecFromInt(remainingTokens)) + _, amount3, err := keeper.Undelegate(ctx, addrDels[1], addrVals[0], math.LegacyNewDecFromInt(remainingTokens)) require.NoError(err) require.Equal(amount3, remainingTokens) @@ -572,7 +572,7 @@ func (s *KeeperTestSuite) TestUnbondingAllDelegationFromValidator() { // unbond the all self-delegation to put validator in unbonding state s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any()) - _, amount, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(valTokens)) + _, amount, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], math.LegacyNewDecFromInt(valTokens)) require.NoError(err) require.Equal(amount, valTokens) @@ -581,7 +581,7 @@ func (s *KeeperTestSuite) TestUnbondingAllDelegationFromValidator() { s.applyValidatorSetUpdates(ctx, keeper, 1) // unbond all the remaining delegation - _, amount2, err := keeper.Undelegate(ctx, addrDels[1], addrVals[0], sdk.NewDecFromInt(delTokens)) + _, amount2, err := keeper.Undelegate(ctx, addrDels[1], addrVals[0], math.LegacyNewDecFromInt(delTokens)) require.NoError(err) require.Equal(amount2, delTokens) @@ -612,7 +612,7 @@ func (s *KeeperTestSuite) TestGetRedelegationsFromSrcValidator() { } rd := stakingtypes.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0, - time.Unix(0, 0), sdk.NewInt(5), + time.Unix(0, 0), math.NewInt(5), math.LegacyNewDec(5), 0) // set and retrieve a record @@ -643,7 +643,7 @@ func (s *KeeperTestSuite) TestRedelegation() { } rd := stakingtypes.NewRedelegation(addrDels[0], addrVals[0], addrVals[1], 0, - time.Unix(0, 0).UTC(), sdk.NewInt(5), + time.Unix(0, 0).UTC(), math.NewInt(5), math.LegacyNewDec(5), 0) // test shouldn't have and redelegations @@ -827,7 +827,7 @@ func (s *KeeperTestSuite) TestRedelegateSelfDelegation() { delegation := stakingtypes.NewDelegation(addrDels[0], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) - _, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], sdk.NewDecFromInt(delTokens)) + _, err := keeper.BeginRedelegation(ctx, val0AccAddr, addrVals[0], addrVals[1], math.LegacyNewDecFromInt(delTokens)) require.NoError(err) // end block @@ -888,7 +888,7 @@ func (s *KeeperTestSuite) TestRedelegateFromUnbondingValidator() { // unbond the all self-delegation to put validator in unbonding state s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any()) - _, amount, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(delTokens)) + _, amount, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], math.LegacyNewDecFromInt(delTokens)) require.NoError(err) require.Equal(amount, delTokens) @@ -913,7 +913,7 @@ func (s *KeeperTestSuite) TestRedelegateFromUnbondingValidator() { // unbond some of the other delegation's shares redelegateTokens := keeper.TokensFromConsensusPower(ctx, 6) s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any()) - _, err = keeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], sdk.NewDecFromInt(redelegateTokens)) + _, err = keeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], math.LegacyNewDecFromInt(redelegateTokens)) require.NoError(err) // retrieve the unbonding delegation @@ -974,7 +974,7 @@ func (s *KeeperTestSuite) TestRedelegateFromUnbondedValidator() { // unbond the all self-delegation to put validator in unbonding state s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, gomock.Any()) - _, amount, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], sdk.NewDecFromInt(delTokens)) + _, amount, err := keeper.Undelegate(ctx, val0AccAddr, addrVals[0], math.LegacyNewDecFromInt(delTokens)) require.NoError(err) require.Equal(amount, delTokens) @@ -994,7 +994,7 @@ func (s *KeeperTestSuite) TestRedelegateFromUnbondedValidator() { // redelegate some of the delegation's shares redelegationTokens := keeper.TokensFromConsensusPower(ctx, 6) s.bankKeeper.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), stakingtypes.NotBondedPoolName, stakingtypes.BondedPoolName, gomock.Any()) - _, err = keeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], sdk.NewDecFromInt(redelegationTokens)) + _, err = keeper.BeginRedelegation(ctx, addrDels[1], addrVals[0], addrVals[1], math.LegacyNewDecFromInt(redelegationTokens)) require.NoError(err) // no red should have been found diff --git a/x/staking/keeper/invariants.go b/x/staking/keeper/invariants.go index ed325a9f19e8..975ccc673020 100644 --- a/x/staking/keeper/invariants.go +++ b/x/staking/keeper/invariants.go @@ -165,7 +165,7 @@ func DelegatorSharesInvariant(k *Keeper) sdk.Invariant { ) validators := k.GetAllValidators(ctx) - validatorsDelegationShares := map[string]sdk.Dec{} + validatorsDelegationShares := map[string]math.LegacyDec{} // initialize a map: validator -> its delegation shares for _, validator := range validators { diff --git a/x/staking/keeper/pool.go b/x/staking/keeper/pool.go index 722f6690d0f2..1d0bed38d255 100644 --- a/x/staking/keeper/pool.go +++ b/x/staking/keeper/pool.go @@ -72,7 +72,7 @@ func (k Keeper) StakingTokenSupply(ctx sdk.Context) math.Int { func (k Keeper) BondedRatio(ctx sdk.Context) math.LegacyDec { stakeSupply := k.StakingTokenSupply(ctx) if stakeSupply.IsPositive() { - return sdk.NewDecFromInt(k.TotalBondedTokens(ctx)).QuoInt(stakeSupply) + return math.LegacyNewDecFromInt(k.TotalBondedTokens(ctx)).QuoInt(stakeSupply) } return math.LegacyZeroDec() diff --git a/x/staking/keeper/power_reduction_test.go b/x/staking/keeper/power_reduction_test.go index 1d777ebd64ff..0817622b8302 100644 --- a/x/staking/keeper/power_reduction_test.go +++ b/x/staking/keeper/power_reduction_test.go @@ -1,15 +1,16 @@ package keeper_test import ( + sdkmath "cosmossdk.io/math" sdk "github.com/cosmos/cosmos-sdk/types" ) func (s *KeeperTestSuite) TestTokensToConsensusPower() { - s.Require().Equal(int64(0), s.stakingKeeper.TokensToConsensusPower(s.ctx, sdk.DefaultPowerReduction.Sub(sdk.NewInt(1)))) + s.Require().Equal(int64(0), s.stakingKeeper.TokensToConsensusPower(s.ctx, sdk.DefaultPowerReduction.Sub(sdkmath.NewInt(1)))) s.Require().Equal(int64(1), s.stakingKeeper.TokensToConsensusPower(s.ctx, sdk.DefaultPowerReduction)) } func (s *KeeperTestSuite) TestTokensFromConsensusPower() { - s.Require().Equal(sdk.NewInt(0), s.stakingKeeper.TokensFromConsensusPower(s.ctx, 0)) + s.Require().Equal(sdkmath.NewInt(0), s.stakingKeeper.TokensFromConsensusPower(s.ctx, 0)) s.Require().Equal(sdk.DefaultPowerReduction, s.stakingKeeper.TokensFromConsensusPower(s.ctx, 1)) } diff --git a/x/staking/keeper/slash.go b/x/staking/keeper/slash.go index 3d9dc3e00d08..036e62871c4e 100644 --- a/x/staking/keeper/slash.go +++ b/x/staking/keeper/slash.go @@ -30,7 +30,7 @@ import ( // // Infraction was committed at the current height or at a past height, // not at a height in the future -func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeight, power int64, slashFactor sdk.Dec) math.Int { +func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeight, power int64, slashFactor math.LegacyDec) math.Int { logger := k.Logger(ctx) if slashFactor.IsNegative() { @@ -39,7 +39,7 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh // Amount of slashing = slash slashFactor * power at time of infraction amount := k.TokensFromConsensusPower(ctx, power) - slashAmountDec := sdk.NewDecFromInt(amount).Mul(slashFactor) + slashAmountDec := math.LegacyNewDecFromInt(amount).Mul(slashFactor) slashAmount := slashAmountDec.TruncateInt() // ref https://github.com/cosmos/cosmos-sdk/issues/1348 @@ -54,7 +54,7 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh "WARNING: ignored attempt to slash a nonexistent validator; we recommend you investigate immediately", "validator", consAddr.String(), ) - return sdk.NewInt(0) + return math.NewInt(0) } // should not be slashing an unbonded validator @@ -114,12 +114,12 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh } // cannot decrease balance below zero - tokensToBurn := sdk.MinInt(remainingSlashAmount, validator.Tokens) - tokensToBurn = sdk.MaxInt(tokensToBurn, math.ZeroInt()) // defensive. + tokensToBurn := math.MinInt(remainingSlashAmount, 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() @@ -157,7 +157,7 @@ func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeigh } // SlashWithInfractionReason implementation doesn't require the infraction (types.Infraction) to work but is required by Interchain Security. -func (k Keeper) SlashWithInfractionReason(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeight, power int64, slashFactor sdk.Dec, _ types.Infraction) math.Int { +func (k Keeper) SlashWithInfractionReason(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeight, power int64, slashFactor math.LegacyDec, _ types.Infraction) math.Int { return k.Slash(ctx, consAddr, infractionHeight, power, slashFactor) } @@ -183,7 +183,7 @@ func (k Keeper) Unjail(ctx sdk.Context, consAddr sdk.ConsAddress) { // (the amount actually slashed may be less if there's // insufficient stake remaining) func (k Keeper) SlashUnbondingDelegation(ctx sdk.Context, unbondingDelegation types.UnbondingDelegation, - infractionHeight int64, slashFactor sdk.Dec, + infractionHeight int64, slashFactor math.LegacyDec, ) (totalSlashAmount math.Int) { now := ctx.BlockHeader().Time totalSlashAmount = math.ZeroInt() @@ -210,7 +210,7 @@ func (k Keeper) SlashUnbondingDelegation(ctx sdk.Context, unbondingDelegation ty // Possible since the unbonding delegation may already // have been slashed, and slash amounts are calculated // according to stake held at time of infraction - unbondingSlashAmount := sdk.MinInt(slashAmount, entry.Balance) + unbondingSlashAmount := math.MinInt(slashAmount, entry.Balance) // Update unbonding delegation if necessary if unbondingSlashAmount.IsZero() { @@ -237,7 +237,7 @@ func (k Keeper) SlashUnbondingDelegation(ctx sdk.Context, unbondingDelegation ty // insufficient stake remaining) // NOTE this is only slashing for prior infractions from the source validator func (k Keeper) SlashRedelegation(ctx sdk.Context, srcValidator types.Validator, redelegation types.Redelegation, - infractionHeight int64, slashFactor sdk.Dec, + infractionHeight int64, slashFactor math.LegacyDec, ) (totalSlashAmount math.Int) { now := ctx.BlockHeader().Time totalSlashAmount = math.ZeroInt() diff --git a/x/staking/keeper/val_state_change.go b/x/staking/keeper/val_state_change.go index da6d1a520833..01557f7627a5 100644 --- a/x/staking/keeper/val_state_change.go +++ b/x/staking/keeper/val_state_change.go @@ -187,7 +187,7 @@ func (k Keeper) ApplyAndReturnValidatorSetUpdates(ctx sdk.Context) (updates []ab delete(last, valAddrStr) count++ - totalPower = totalPower.Add(sdk.NewInt(newPower)) + totalPower = totalPower.Add(math.NewInt(newPower)) } noLongerBonded, err := sortNoLongerBonded(last) diff --git a/x/staking/keeper/validator.go b/x/staking/keeper/validator.go index e7d1dc44bbd5..a9dd09d3c311 100644 --- a/x/staking/keeper/validator.go +++ b/x/staking/keeper/validator.go @@ -100,7 +100,7 @@ func (k Keeper) SetNewValidatorByPowerIndex(ctx sdk.Context, validator types.Val // Update the tokens of an existing validator, update the validators power index key func (k Keeper) AddValidatorTokensAndShares(ctx sdk.Context, validator types.Validator, tokensToAdd math.Int, -) (valOut types.Validator, addedShares sdk.Dec) { +) (valOut types.Validator, addedShares math.LegacyDec) { k.DeleteValidatorByPowerIndex(ctx, validator) validator, addedShares = validator.AddTokensFromDel(tokensToAdd) k.SetValidator(ctx, validator) @@ -111,7 +111,7 @@ func (k Keeper) AddValidatorTokensAndShares(ctx sdk.Context, validator types.Val // Update the tokens of an existing validator, update the validators power index key func (k Keeper) RemoveValidatorTokensAndShares(ctx sdk.Context, validator types.Validator, - sharesToRemove sdk.Dec, + sharesToRemove math.LegacyDec, ) (valOut types.Validator, removedTokens math.Int) { k.DeleteValidatorByPowerIndex(ctx, validator) validator, removedTokens = validator.RemoveDelShares(sharesToRemove) @@ -136,7 +136,7 @@ func (k Keeper) RemoveValidatorTokens(ctx sdk.Context, // UpdateValidatorCommission attempts to update a validator's commission rate. // An error is returned if the new commission rate is invalid. func (k Keeper) UpdateValidatorCommission(ctx sdk.Context, - validator types.Validator, newRate sdk.Dec, + validator types.Validator, newRate math.LegacyDec, ) (types.Commission, error) { commission := validator.Commission blockTime := ctx.BlockHeader().Time diff --git a/x/staking/keeper/validator_test.go b/x/staking/keeper/validator_test.go index c820de0595e1..363378d96503 100644 --- a/x/staking/keeper/validator_test.go +++ b/x/staking/keeper/validator_test.go @@ -136,7 +136,7 @@ func (s *KeeperTestSuite) TestValidatorBasics() { // modify a records, save, and retrieve validators[0].Status = stakingtypes.Bonded validators[0].Tokens = keeper.TokensFromConsensusPower(ctx, 10) - validators[0].DelegatorShares = sdk.NewDecFromInt(validators[0].Tokens) + validators[0].DelegatorShares = math.LegacyNewDecFromInt(validators[0].Tokens) validators[0] = stakingkeeper.TestingUpdateValidator(keeper, ctx, validators[0], true) resVal, found = keeper.GetValidator(ctx, sdk.ValAddress(PKs[0].Address().Bytes())) require.True(found) @@ -252,8 +252,8 @@ func (s *KeeperTestSuite) TestApplyAndReturnValidatorSetUpdatesPowerDecrease() { // tendermintUpdate set: {c1, c3} -> {c1', c3'} delTokens1 := keeper.TokensFromConsensusPower(ctx, 20) delTokens2 := keeper.TokensFromConsensusPower(ctx, 30) - validators[0], _ = validators[0].RemoveDelShares(sdk.NewDecFromInt(delTokens1)) - validators[1], _ = validators[1].RemoveDelShares(sdk.NewDecFromInt(delTokens2)) + validators[0], _ = validators[0].RemoveDelShares(math.LegacyNewDecFromInt(delTokens1)) + validators[1], _ = validators[1].RemoveDelShares(math.LegacyNewDecFromInt(delTokens2)) validators[0] = stakingkeeper.TestingUpdateValidator(keeper, ctx, validators[0], false) validators[1] = stakingkeeper.TestingUpdateValidator(keeper, ctx, validators[1], false) @@ -273,14 +273,14 @@ func (s *KeeperTestSuite) TestUpdateValidatorCommission() { // Set MinCommissionRate to 0.05 params := keeper.GetParams(ctx) - params.MinCommissionRate = sdk.NewDecWithPrec(5, 2) + params.MinCommissionRate = math.LegacyNewDecWithPrec(5, 2) keeper.SetParams(ctx, params) commission1 := stakingtypes.NewCommissionWithTime( - sdk.NewDecWithPrec(1, 1), sdk.NewDecWithPrec(3, 1), - sdk.NewDecWithPrec(1, 1), time.Now().UTC().Add(time.Duration(-1)*time.Hour), + math.LegacyNewDecWithPrec(1, 1), math.LegacyNewDecWithPrec(3, 1), + math.LegacyNewDecWithPrec(1, 1), time.Now().UTC().Add(time.Duration(-1)*time.Hour), ) - commission2 := stakingtypes.NewCommission(sdk.NewDecWithPrec(1, 1), sdk.NewDecWithPrec(3, 1), sdk.NewDecWithPrec(1, 1)) + commission2 := stakingtypes.NewCommission(math.LegacyNewDecWithPrec(1, 1), math.LegacyNewDecWithPrec(3, 1), math.LegacyNewDecWithPrec(1, 1)) val1 := testutil.NewValidator(s.T(), sdk.ValAddress(PKs[0].Address().Bytes()), PKs[0]) val2 := testutil.NewValidator(s.T(), sdk.ValAddress(PKs[1].Address().Bytes()), PKs[1]) @@ -293,15 +293,15 @@ func (s *KeeperTestSuite) TestUpdateValidatorCommission() { testCases := []struct { validator stakingtypes.Validator - newRate sdk.Dec + newRate math.LegacyDec expectedErr bool }{ {val1, math.LegacyZeroDec(), true}, - {val2, sdk.NewDecWithPrec(-1, 1), true}, - {val2, sdk.NewDecWithPrec(4, 1), true}, - {val2, sdk.NewDecWithPrec(3, 1), true}, - {val2, sdk.NewDecWithPrec(1, 2), true}, - {val2, sdk.NewDecWithPrec(2, 1), false}, + {val2, math.LegacyNewDecWithPrec(-1, 1), true}, + {val2, math.LegacyNewDecWithPrec(4, 1), true}, + {val2, math.LegacyNewDecWithPrec(3, 1), true}, + {val2, math.LegacyNewDecWithPrec(1, 2), true}, + {val2, math.LegacyNewDecWithPrec(2, 1), false}, } for i, tc := range testCases { @@ -343,12 +343,12 @@ func (s *KeeperTestSuite) TestValidatorToken() { validator, _ = keeper.AddValidatorTokensAndShares(ctx, validator, addTokens) require.Equal(addTokens, validator.Tokens) validator, _ = keeper.GetValidator(ctx, valAddr) - require.Equal(sdk.NewDecFromInt(addTokens), validator.DelegatorShares) + require.Equal(math.LegacyNewDecFromInt(addTokens), validator.DelegatorShares) - keeper.RemoveValidatorTokensAndShares(ctx, validator, sdk.NewDecFromInt(delTokens)) + keeper.RemoveValidatorTokensAndShares(ctx, validator, math.LegacyNewDecFromInt(delTokens)) validator, _ = keeper.GetValidator(ctx, valAddr) require.Equal(delTokens, validator.Tokens) - require.True(validator.DelegatorShares.Equal(sdk.NewDecFromInt(delTokens))) + require.True(validator.DelegatorShares.Equal(math.LegacyNewDecFromInt(delTokens))) keeper.RemoveValidatorTokens(ctx, validator, delTokens) validator, _ = keeper.GetValidator(ctx, valAddr) diff --git a/x/staking/simulation/common_test.go b/x/staking/simulation/common_test.go index e22ecd15aa2c..691dede87958 100644 --- a/x/staking/simulation/common_test.go +++ b/x/staking/simulation/common_test.go @@ -3,9 +3,11 @@ package simulation_test import ( "math/big" + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" ) func init() { - sdk.DefaultPowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)) + sdk.DefaultPowerReduction = sdkmath.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)) } diff --git a/x/staking/simulation/genesis.go b/x/staking/simulation/genesis.go index c23cbb1135d2..19d25de7526a 100644 --- a/x/staking/simulation/genesis.go +++ b/x/staking/simulation/genesis.go @@ -6,6 +6,8 @@ import ( "math/rand" "time" + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" "github.com/cosmos/cosmos-sdk/types/simulation" @@ -41,7 +43,7 @@ func RandomizedGenState(simState *module.SimulationState) { unbondTime time.Duration maxVals uint32 histEntries uint32 - minCommissionRate sdk.Dec + minCommissionRate sdkmath.LegacyDec ) simState.AppParams.GetOrGenerate( @@ -76,7 +78,7 @@ func RandomizedGenState(simState *module.SimulationState) { valAddr := sdk.ValAddress(simState.Accounts[i].Address) valAddrs[i] = valAddr - maxCommission := sdk.NewDecWithPrec(int64(simulation.RandIntBetween(simState.Rand, 1, 100)), 2) + maxCommission := sdkmath.LegacyNewDecWithPrec(int64(simulation.RandIntBetween(simState.Rand, 1, 100)), 2) commission := types.NewCommission( simulation.RandomDecAmount(simState.Rand, maxCommission), maxCommission, @@ -88,10 +90,10 @@ func RandomizedGenState(simState *module.SimulationState) { panic(err) } validator.Tokens = simState.InitialStake - validator.DelegatorShares = sdk.NewDecFromInt(simState.InitialStake) + validator.DelegatorShares = sdkmath.LegacyNewDecFromInt(simState.InitialStake) validator.Commission = commission - delegation := types.NewDelegation(simState.Accounts[i].Address, valAddr, sdk.NewDecFromInt(simState.InitialStake)) + delegation := types.NewDelegation(simState.Accounts[i].Address, valAddr, sdkmath.LegacyNewDecFromInt(simState.InitialStake)) validators = append(validators, validator) delegations = append(delegations, delegation) diff --git a/x/staking/simulation/operations_test.go b/x/staking/simulation/operations_test.go index ac3fe9874020..d46c3409f3fa 100644 --- a/x/staking/simulation/operations_test.go +++ b/x/staking/simulation/operations_test.go @@ -59,7 +59,7 @@ type SimTestSuite struct { } func (s *SimTestSuite) SetupTest() { - sdk.DefaultPowerReduction = sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)) + sdk.DefaultPowerReduction = math.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)) s.r = rand.New(rand.NewSource(1)) accounts := simtypes.RandomAccounts(s.r, 4) diff --git a/x/staking/simulation/proposals.go b/x/staking/simulation/proposals.go index 5ef5fc7a13bc..ca9bf09ee3b2 100644 --- a/x/staking/simulation/proposals.go +++ b/x/staking/simulation/proposals.go @@ -4,6 +4,8 @@ import ( "math/rand" "time" + 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" @@ -40,7 +42,7 @@ func SimulateMsgUpdateParams(r *rand.Rand, _ sdk.Context, _ []simtypes.Account) params.MaxEntries = uint32(simtypes.RandIntBetween(r, 1, 1000)) params.MaxValidators = uint32(simtypes.RandIntBetween(r, 1, 1000)) params.UnbondingTime = time.Duration(simtypes.RandTimestamp(r).UnixNano()) - params.MinCommissionRate = simtypes.RandomDecAmount(r, sdk.NewDec(1)) + params.MinCommissionRate = simtypes.RandomDecAmount(r, sdkmath.LegacyNewDec(1)) return &types.MsgUpdateParams{ Authority: authority.String(), diff --git a/x/staking/simulation/proposals_test.go b/x/staking/simulation/proposals_test.go index adbafa4ea33a..c12db5bbb3fe 100644 --- a/x/staking/simulation/proposals_test.go +++ b/x/staking/simulation/proposals_test.go @@ -5,6 +5,7 @@ import ( "testing" "time" + sdkmath "cosmossdk.io/math" cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" "gotest.tools/v3/assert" @@ -43,5 +44,5 @@ func TestProposalMsgs(t *testing.T) { assert.Equal(t, uint32(300), msgUpdateParams.Params.HistoricalEntries) assert.Equal(t, uint32(539), msgUpdateParams.Params.MaxValidators) assert.Equal(t, 8898194435*time.Second, msgUpdateParams.Params.UnbondingTime) - assert.DeepEqual(t, sdk.NewDecWithPrec(579040435581502128, 18), msgUpdateParams.Params.MinCommissionRate) + assert.DeepEqual(t, sdkmath.LegacyNewDecWithPrec(579040435581502128, 18), msgUpdateParams.Params.MinCommissionRate) } diff --git a/x/staking/types/commission.go b/x/staking/types/commission.go index 828a83fa8c03..4f5d12de5bf1 100644 --- a/x/staking/types/commission.go +++ b/x/staking/types/commission.go @@ -4,12 +4,10 @@ import ( "time" "cosmossdk.io/math" - - sdk "github.com/cosmos/cosmos-sdk/types" ) // NewCommissionRates returns an initialized validator commission rates. -func NewCommissionRates(rate, maxRate, maxChangeRate sdk.Dec) CommissionRates { +func NewCommissionRates(rate, maxRate, maxChangeRate math.LegacyDec) CommissionRates { return CommissionRates{ Rate: rate, MaxRate: maxRate, @@ -18,7 +16,7 @@ func NewCommissionRates(rate, maxRate, maxChangeRate sdk.Dec) CommissionRates { } // NewCommission returns an initialized validator commission. -func NewCommission(rate, maxRate, maxChangeRate sdk.Dec) Commission { +func NewCommission(rate, maxRate, maxChangeRate math.LegacyDec) Commission { return Commission{ CommissionRates: NewCommissionRates(rate, maxRate, maxChangeRate), UpdateTime: time.Unix(0, 0).UTC(), @@ -27,7 +25,7 @@ func NewCommission(rate, maxRate, maxChangeRate sdk.Dec) Commission { // NewCommissionWithTime returns an initialized validator commission with a specified // update time which should be the current block BFT time. -func NewCommissionWithTime(rate, maxRate, maxChangeRate sdk.Dec, updatedAt time.Time) Commission { +func NewCommissionWithTime(rate, maxRate, maxChangeRate math.LegacyDec, updatedAt time.Time) Commission { return Commission{ CommissionRates: NewCommissionRates(rate, maxRate, maxChangeRate), UpdateTime: updatedAt, @@ -68,7 +66,7 @@ func (cr CommissionRates) Validate() error { // ValidateNewRate performs basic sanity validation checks of a new commission // rate. If validation fails, an SDK error is returned. -func (c Commission) ValidateNewRate(newRate sdk.Dec, blockTime time.Time) error { +func (c Commission) ValidateNewRate(newRate math.LegacyDec, blockTime time.Time) error { switch { case blockTime.Sub(c.UpdateTime).Hours() < 24: // new rate cannot be changed more than once within 24 hours diff --git a/x/staking/types/commission_test.go b/x/staking/types/commission_test.go index 99501f912e62..17fa202fdf46 100644 --- a/x/staking/types/commission_test.go +++ b/x/staking/types/commission_test.go @@ -45,7 +45,7 @@ func TestCommissionValidateNewRate(t *testing.T) { testCases := []struct { input types.Commission - newRate sdk.Dec + newRate math.LegacyDec blockTime time.Time expectErr bool }{ diff --git a/x/staking/types/delegation.go b/x/staking/types/delegation.go index 3fd63b261648..746d33a38261 100644 --- a/x/staking/types/delegation.go +++ b/x/staking/types/delegation.go @@ -14,7 +14,7 @@ import ( var _ DelegationI = Delegation{} // NewDelegation creates a new delegation object -func NewDelegation(delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress, shares sdk.Dec) Delegation { +func NewDelegation(delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress, shares math.LegacyDec) Delegation { return Delegation{ DelegatorAddress: delegatorAddr.String(), ValidatorAddress: validatorAddr.String(), @@ -188,7 +188,7 @@ func (ubds UnbondingDelegations) String() (out string) { return strings.TrimSpace(out) } -func NewRedelegationEntry(creationHeight int64, completionTime time.Time, balance math.Int, sharesDst sdk.Dec, id uint64) RedelegationEntry { +func NewRedelegationEntry(creationHeight int64, completionTime time.Time, balance math.Int, sharesDst math.LegacyDec, id uint64) RedelegationEntry { return RedelegationEntry{ CreationHeight: creationHeight, CompletionTime: completionTime, @@ -211,7 +211,7 @@ func (e RedelegationEntry) OnHold() bool { func NewRedelegation( delegatorAddr sdk.AccAddress, validatorSrcAddr, validatorDstAddr sdk.ValAddress, - creationHeight int64, minTime time.Time, balance math.Int, sharesDst sdk.Dec, id uint64, + creationHeight int64, minTime time.Time, balance math.Int, sharesDst math.LegacyDec, id uint64, ) Redelegation { return Redelegation{ DelegatorAddress: delegatorAddr.String(), @@ -224,7 +224,7 @@ func NewRedelegation( } // AddEntry - append entry to the unbonding delegation -func (red *Redelegation) AddEntry(creationHeight int64, minTime time.Time, balance math.Int, sharesDst sdk.Dec, id uint64) { +func (red *Redelegation) AddEntry(creationHeight int64, minTime time.Time, balance math.Int, sharesDst math.LegacyDec, id uint64) { entry := NewRedelegationEntry(creationHeight, minTime, balance, sharesDst, id) red.Entries = append(red.Entries, entry) } @@ -271,7 +271,7 @@ func (d Redelegations) String() (out string) { // NewDelegationResp creates a new DelegationResponse instance func NewDelegationResp( - delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress, shares sdk.Dec, balance sdk.Coin, + delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress, shares math.LegacyDec, balance sdk.Coin, ) DelegationResponse { return DelegationResponse{ Delegation: NewDelegation(delegatorAddr, validatorAddr, shares), @@ -321,7 +321,7 @@ func NewRedelegationResponse( // NewRedelegationEntryResponse creates a new RedelegationEntryResponse instance. func NewRedelegationEntryResponse( - creationHeight int64, completionTime time.Time, sharesDst sdk.Dec, initialBalance, balance math.Int, unbondingID uint64, + creationHeight int64, completionTime time.Time, sharesDst math.LegacyDec, initialBalance, balance math.Int, unbondingID uint64, ) RedelegationEntryResponse { return RedelegationEntryResponse{ RedelegationEntry: NewRedelegationEntry(creationHeight, completionTime, initialBalance, sharesDst, unbondingID), diff --git a/x/staking/types/delegation_test.go b/x/staking/types/delegation_test.go index f94bfb362d1a..6635cc179e87 100644 --- a/x/staking/types/delegation_test.go +++ b/x/staking/types/delegation_test.go @@ -35,7 +35,7 @@ func TestDelegationString(t *testing.T) { func TestUnbondingDelegationEqual(t *testing.T) { ubd1 := types.NewUnbondingDelegation(sdk.AccAddress(valAddr1), valAddr2, 0, - time.Unix(0, 0), sdk.NewInt(0), 1) + time.Unix(0, 0), math.NewInt(0), 1) ubd2 := ubd1 ok := ubd1.String() == ubd2.String() @@ -50,17 +50,17 @@ func TestUnbondingDelegationEqual(t *testing.T) { func TestUnbondingDelegationString(t *testing.T) { ubd := types.NewUnbondingDelegation(sdk.AccAddress(valAddr1), valAddr2, 0, - time.Unix(0, 0), sdk.NewInt(0), 1) + time.Unix(0, 0), math.NewInt(0), 1) require.NotEmpty(t, ubd.String()) } func TestRedelegationEqual(t *testing.T) { r1 := types.NewRedelegation(sdk.AccAddress(valAddr1), valAddr2, valAddr3, 0, - time.Unix(0, 0), sdk.NewInt(0), + time.Unix(0, 0), math.NewInt(0), math.LegacyNewDec(0), 1) r2 := types.NewRedelegation(sdk.AccAddress(valAddr1), valAddr2, valAddr3, 0, - time.Unix(0, 0), sdk.NewInt(0), + time.Unix(0, 0), math.NewInt(0), math.LegacyNewDec(0), 1) require.True(t, proto.Equal(&r1, &r2)) @@ -71,7 +71,7 @@ func TestRedelegationEqual(t *testing.T) { func TestRedelegationString(t *testing.T) { r := types.NewRedelegation(sdk.AccAddress(valAddr1), valAddr2, valAddr3, 0, - time.Unix(0, 0), sdk.NewInt(0), + time.Unix(0, 0), math.NewInt(0), math.LegacyNewDec(10), 1) require.NotEmpty(t, r.String()) @@ -80,9 +80,9 @@ func TestRedelegationString(t *testing.T) { func TestDelegationResponses(t *testing.T) { cdc := codec.NewLegacyAmino() dr1 := types.NewDelegationResp(sdk.AccAddress(valAddr1), valAddr2, math.LegacyNewDec(5), - sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(5))) + sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(5))) dr2 := types.NewDelegationResp(sdk.AccAddress(valAddr1), valAddr3, math.LegacyNewDec(5), - sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(5))) + sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(5))) drs := types.DelegationResponses{dr1, dr2} bz1, err := json.Marshal(dr1) @@ -109,8 +109,8 @@ func TestDelegationResponses(t *testing.T) { func TestRedelegationResponses(t *testing.T) { cdc := codec.NewLegacyAmino() entries := []types.RedelegationEntryResponse{ - types.NewRedelegationEntryResponse(0, time.Unix(0, 0), math.LegacyNewDec(5), sdk.NewInt(5), sdk.NewInt(5), 0), - types.NewRedelegationEntryResponse(0, time.Unix(0, 0), math.LegacyNewDec(5), sdk.NewInt(5), sdk.NewInt(5), 0), + types.NewRedelegationEntryResponse(0, time.Unix(0, 0), math.LegacyNewDec(5), math.NewInt(5), math.NewInt(5), 0), + types.NewRedelegationEntryResponse(0, time.Unix(0, 0), math.LegacyNewDec(5), math.NewInt(5), math.NewInt(5), 0), } rdr1 := types.NewRedelegationResponse(sdk.AccAddress(valAddr1), valAddr2, valAddr3, entries) rdr2 := types.NewRedelegationResponse(sdk.AccAddress(valAddr2), valAddr1, valAddr3, entries) diff --git a/x/staking/types/expected_keepers.go b/x/staking/types/expected_keepers.go index b70505d0ec30..9a23bb544147 100644 --- a/x/staking/types/expected_keepers.go +++ b/x/staking/types/expected_keepers.go @@ -65,8 +65,8 @@ type ValidatorSet interface { StakingTokenSupply(sdk.Context) math.Int // total staking token supply // slash the validator and delegators of the validator, specifying offense height, offense power, and slash fraction - Slash(sdk.Context, sdk.ConsAddress, int64, int64, sdk.Dec) math.Int - SlashWithInfractionReason(sdk.Context, sdk.ConsAddress, int64, int64, sdk.Dec, Infraction) math.Int + Slash(sdk.Context, sdk.ConsAddress, int64, int64, math.LegacyDec) math.Int + SlashWithInfractionReason(sdk.Context, sdk.ConsAddress, int64, int64, math.LegacyDec, Infraction) math.Int Jail(sdk.Context, sdk.ConsAddress) // jail a validator Unjail(sdk.Context, sdk.ConsAddress) // unjail a validator @@ -107,7 +107,7 @@ type StakingHooks interface { BeforeDelegationSharesModified(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) error // Must be called when a delegation's shares are modified BeforeDelegationRemoved(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) error // Must be called when a delegation is removed AfterDelegationModified(ctx sdk.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) error - BeforeValidatorSlashed(ctx sdk.Context, valAddr sdk.ValAddress, fraction sdk.Dec) error + BeforeValidatorSlashed(ctx sdk.Context, valAddr sdk.ValAddress, fraction math.LegacyDec) error AfterUnbondingInitiated(ctx sdk.Context, id uint64) error } diff --git a/x/staking/types/exported.go b/x/staking/types/exported.go index 79f7f23ce085..a1f73d409430 100644 --- a/x/staking/types/exported.go +++ b/x/staking/types/exported.go @@ -17,25 +17,25 @@ type DelegationI interface { // ValidatorI expected validator functions type ValidatorI interface { - IsJailed() bool // whether the validator is jailed - GetMoniker() string // moniker of the validator - GetStatus() BondStatus // status of the validator - IsBonded() bool // check if has a bonded status - IsUnbonded() bool // check if has status unbonded - IsUnbonding() bool // check if has status unbonding - GetOperator() sdk.ValAddress // operator address to receive/return validators coins - ConsPubKey() (cryptotypes.PubKey, error) // validation consensus pubkey (cryptotypes.PubKey) - TmConsPublicKey() (cmtprotocrypto.PublicKey, error) // validation consensus pubkey (CometBFT) - GetConsAddr() (sdk.ConsAddress, error) // validation consensus address - GetTokens() math.Int // validation tokens - GetBondedTokens() math.Int // validator bonded tokens - GetConsensusPower(math.Int) int64 // validation power in CometBFT - GetCommission() math.LegacyDec // validator commission rate - GetMinSelfDelegation() math.Int // validator minimum self delegation - GetDelegatorShares() math.LegacyDec // total outstanding delegator shares - TokensFromShares(sdk.Dec) math.LegacyDec // token worth of provided delegator shares - TokensFromSharesTruncated(sdk.Dec) math.LegacyDec // token worth of provided delegator shares, truncated - TokensFromSharesRoundUp(sdk.Dec) math.LegacyDec // token worth of provided delegator shares, rounded up - SharesFromTokens(amt math.Int) (sdk.Dec, error) // shares worth of delegator's bond - SharesFromTokensTruncated(amt math.Int) (sdk.Dec, error) // truncated shares worth of delegator's bond + IsJailed() bool // whether the validator is jailed + GetMoniker() string // moniker of the validator + GetStatus() BondStatus // status of the validator + IsBonded() bool // check if has a bonded status + IsUnbonded() bool // check if has status unbonded + IsUnbonding() bool // check if has status unbonding + GetOperator() sdk.ValAddress // operator address to receive/return validators coins + ConsPubKey() (cryptotypes.PubKey, error) // validation consensus pubkey (cryptotypes.PubKey) + TmConsPublicKey() (cmtprotocrypto.PublicKey, error) // validation consensus pubkey (CometBFT) + GetConsAddr() (sdk.ConsAddress, error) // validation consensus address + GetTokens() math.Int // validation tokens + GetBondedTokens() math.Int // validator bonded tokens + GetConsensusPower(math.Int) int64 // validation power in CometBFT + GetCommission() math.LegacyDec // validator commission rate + GetMinSelfDelegation() math.Int // validator minimum self delegation + GetDelegatorShares() math.LegacyDec // total outstanding delegator shares + TokensFromShares(math.LegacyDec) math.LegacyDec // token worth of provided delegator shares + TokensFromSharesTruncated(math.LegacyDec) math.LegacyDec // token worth of provided delegator shares, truncated + TokensFromSharesRoundUp(math.LegacyDec) math.LegacyDec // token worth of provided delegator shares, rounded up + SharesFromTokens(amt math.Int) (math.LegacyDec, error) // shares worth of delegator's bond + SharesFromTokensTruncated(amt math.Int) (math.LegacyDec, error) // truncated shares worth of delegator's bond } diff --git a/x/staking/types/hooks.go b/x/staking/types/hooks.go index 6fad1df77d6b..bdc1ffd7776c 100644 --- a/x/staking/types/hooks.go +++ b/x/staking/types/hooks.go @@ -1,6 +1,8 @@ package types import ( + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" ) @@ -95,7 +97,7 @@ func (h MultiStakingHooks) AfterDelegationModified(ctx sdk.Context, delAddr sdk. return nil } -func (h MultiStakingHooks) BeforeValidatorSlashed(ctx sdk.Context, valAddr sdk.ValAddress, fraction sdk.Dec) error { +func (h MultiStakingHooks) BeforeValidatorSlashed(ctx sdk.Context, valAddr sdk.ValAddress, fraction sdkmath.LegacyDec) error { for i := range h { if err := h[i].BeforeValidatorSlashed(ctx, valAddr, fraction); err != nil { return err diff --git a/x/staking/types/msg.go b/x/staking/types/msg.go index 6899e5e35f95..8b41c5bf6c17 100644 --- a/x/staking/types/msg.go +++ b/x/staking/types/msg.go @@ -120,7 +120,7 @@ func (msg MsgCreateValidator) UnpackInterfaces(unpacker codectypes.AnyUnpacker) } // NewMsgEditValidator creates a new MsgEditValidator instance -func NewMsgEditValidator(valAddr sdk.ValAddress, description Description, newRate *sdk.Dec, newMinSelfDelegation *math.Int) *MsgEditValidator { +func NewMsgEditValidator(valAddr sdk.ValAddress, description Description, newRate *math.LegacyDec, newMinSelfDelegation *math.Int) *MsgEditValidator { return &MsgEditValidator{ Description: description, CommissionRate: newRate, diff --git a/x/staking/types/params.go b/x/staking/types/params.go index 9211cf9f5206..9687b206485c 100644 --- a/x/staking/types/params.go +++ b/x/staking/types/params.go @@ -35,7 +35,7 @@ const ( var DefaultMinCommissionRate = math.LegacyZeroDec() // NewParams creates a new Params instance -func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historicalEntries uint32, bondDenom string, minCommissionRate sdk.Dec) Params { +func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historicalEntries uint32, bondDenom string, minCommissionRate math.LegacyDec) Params { return Params{ UnbondingTime: unbondingTime, MaxValidators: maxValidators, @@ -178,7 +178,7 @@ func ValidatePowerReduction(i interface{}) error { return fmt.Errorf("invalid parameter type: %T", i) } - if v.LT(sdk.NewInt(1)) { + if v.LT(math.NewInt(1)) { return fmt.Errorf("power reduction cannot be lower than 1") } @@ -186,7 +186,7 @@ func ValidatePowerReduction(i interface{}) error { } func validateMinCommissionRate(i interface{}) error { - v, ok := i.(sdk.Dec) + v, ok := i.(math.LegacyDec) if !ok { return fmt.Errorf("invalid parameter type: %T", i) } diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go index 1b55f7120cf2..15aabd7d847c 100644 --- a/x/staking/types/validator.go +++ b/x/staking/types/validator.go @@ -290,24 +290,24 @@ func (v Validator) InvalidExRate() bool { } // calculate the token worth of provided shares -func (v Validator) TokensFromShares(shares sdk.Dec) math.LegacyDec { +func (v Validator) TokensFromShares(shares math.LegacyDec) math.LegacyDec { return (shares.MulInt(v.Tokens)).Quo(v.DelegatorShares) } // calculate the token worth of provided shares, truncated -func (v Validator) TokensFromSharesTruncated(shares sdk.Dec) math.LegacyDec { +func (v Validator) TokensFromSharesTruncated(shares math.LegacyDec) math.LegacyDec { return (shares.MulInt(v.Tokens)).QuoTruncate(v.DelegatorShares) } // TokensFromSharesRoundUp returns the token worth of provided shares, rounded // up. -func (v Validator) TokensFromSharesRoundUp(shares sdk.Dec) math.LegacyDec { +func (v Validator) TokensFromSharesRoundUp(shares math.LegacyDec) math.LegacyDec { return (shares.MulInt(v.Tokens)).QuoRoundUp(v.DelegatorShares) } // SharesFromTokens returns the shares of a delegation given a bond amount. It // returns an error if the validator has no tokens. -func (v Validator) SharesFromTokens(amt math.Int) (sdk.Dec, error) { +func (v Validator) SharesFromTokens(amt math.Int) (math.LegacyDec, error) { if v.Tokens.IsZero() { return math.LegacyZeroDec(), ErrInsufficientShares } @@ -317,12 +317,12 @@ func (v Validator) SharesFromTokens(amt math.Int) (sdk.Dec, error) { // SharesFromTokensTruncated returns the truncated shares of a delegation given // a bond amount. It returns an error if the validator has no tokens. -func (v Validator) SharesFromTokensTruncated(amt math.Int) (sdk.Dec, error) { +func (v Validator) SharesFromTokensTruncated(amt math.Int) (math.LegacyDec, error) { if v.Tokens.IsZero() { return math.LegacyZeroDec(), ErrInsufficientShares } - return v.GetDelegatorShares().MulInt(amt).QuoTruncate(sdk.NewDecFromInt(v.GetTokens())), nil + return v.GetDelegatorShares().MulInt(amt).QuoTruncate(math.LegacyNewDecFromInt(v.GetTokens())), nil } // get the bonded tokens which the validator holds @@ -357,12 +357,12 @@ func (v Validator) UpdateStatus(newStatus BondStatus) Validator { } // AddTokensFromDel adds tokens to a validator -func (v Validator) AddTokensFromDel(amount math.Int) (Validator, sdk.Dec) { +func (v Validator) AddTokensFromDel(amount math.Int) (Validator, math.LegacyDec) { // calculate the shares to issue - var issuedShares sdk.Dec + var issuedShares math.LegacyDec if v.DelegatorShares.IsZero() { // the first delegation to a validator sets the exchange rate to one - issuedShares = sdk.NewDecFromInt(amount) + issuedShares = math.LegacyNewDecFromInt(amount) } else { shares, err := v.SharesFromTokens(amount) if err != nil { @@ -397,7 +397,7 @@ func (v Validator) RemoveTokens(tokens math.Int) Validator { // NOTE: because token fractions are left in the valiadator, // // the exchange rate of future shares of this validator can increase. -func (v Validator) RemoveDelShares(delShares sdk.Dec) (Validator, math.Int) { +func (v Validator) RemoveDelShares(delShares math.LegacyDec) (Validator, math.Int) { remainingShares := v.DelegatorShares.Sub(delShares) var issuedTokens math.Int diff --git a/x/staking/types/validator_test.go b/x/staking/types/validator_test.go index 1150fbed6146..441cd99ab1f0 100644 --- a/x/staking/types/validator_test.go +++ b/x/staking/types/validator_test.go @@ -77,59 +77,59 @@ func TestABCIValidatorUpdateZero(t *testing.T) { func TestShareTokens(t *testing.T) { validator := mkValidator(100, math.LegacyNewDec(100)) - assert.True(sdk.DecEq(t, math.LegacyNewDec(50), validator.TokensFromShares(math.LegacyNewDec(50)))) + assert.True(math.LegacyDecEq(t, math.LegacyNewDec(50), validator.TokensFromShares(math.LegacyNewDec(50)))) - validator.Tokens = sdk.NewInt(50) - assert.True(sdk.DecEq(t, math.LegacyNewDec(25), validator.TokensFromShares(math.LegacyNewDec(50)))) - assert.True(sdk.DecEq(t, math.LegacyNewDec(5), validator.TokensFromShares(math.LegacyNewDec(10)))) + validator.Tokens = math.NewInt(50) + assert.True(math.LegacyDecEq(t, math.LegacyNewDec(25), validator.TokensFromShares(math.LegacyNewDec(50)))) + assert.True(math.LegacyDecEq(t, math.LegacyNewDec(5), validator.TokensFromShares(math.LegacyNewDec(10)))) } func TestRemoveTokens(t *testing.T) { validator := mkValidator(100, math.LegacyNewDec(100)) // remove tokens and test check everything - validator = validator.RemoveTokens(sdk.NewInt(10)) + validator = validator.RemoveTokens(math.NewInt(10)) require.Equal(t, int64(90), validator.Tokens.Int64()) // update validator to from bonded -> unbonded validator = validator.UpdateStatus(types.Unbonded) require.Equal(t, types.Unbonded, validator.Status) - validator = validator.RemoveTokens(sdk.NewInt(10)) - require.Panics(t, func() { validator.RemoveTokens(sdk.NewInt(-1)) }) - require.Panics(t, func() { validator.RemoveTokens(sdk.NewInt(100)) }) + validator = validator.RemoveTokens(math.NewInt(10)) + require.Panics(t, func() { validator.RemoveTokens(math.NewInt(-1)) }) + require.Panics(t, func() { validator.RemoveTokens(math.NewInt(100)) }) } func TestAddTokensValidatorBonded(t *testing.T) { validator := newValidator(t, valAddr1, pk1) validator = validator.UpdateStatus(types.Bonded) - validator, delShares := validator.AddTokensFromDel(sdk.NewInt(10)) + validator, delShares := validator.AddTokensFromDel(math.NewInt(10)) - assert.True(sdk.DecEq(t, math.LegacyNewDec(10), delShares)) - assert.True(math.IntEq(t, sdk.NewInt(10), validator.BondedTokens())) - assert.True(sdk.DecEq(t, math.LegacyNewDec(10), validator.DelegatorShares)) + assert.True(math.LegacyDecEq(t, math.LegacyNewDec(10), delShares)) + assert.True(math.IntEq(t, math.NewInt(10), validator.BondedTokens())) + assert.True(math.LegacyDecEq(t, math.LegacyNewDec(10), validator.DelegatorShares)) } func TestAddTokensValidatorUnbonding(t *testing.T) { validator := newValidator(t, valAddr1, pk1) validator = validator.UpdateStatus(types.Unbonding) - validator, delShares := validator.AddTokensFromDel(sdk.NewInt(10)) + validator, delShares := validator.AddTokensFromDel(math.NewInt(10)) - assert.True(sdk.DecEq(t, math.LegacyNewDec(10), delShares)) + assert.True(math.LegacyDecEq(t, math.LegacyNewDec(10), delShares)) assert.Equal(t, types.Unbonding, validator.Status) - assert.True(math.IntEq(t, sdk.NewInt(10), validator.Tokens)) - assert.True(sdk.DecEq(t, math.LegacyNewDec(10), validator.DelegatorShares)) + assert.True(math.IntEq(t, math.NewInt(10), validator.Tokens)) + assert.True(math.LegacyDecEq(t, math.LegacyNewDec(10), validator.DelegatorShares)) } func TestAddTokensValidatorUnbonded(t *testing.T) { validator := newValidator(t, valAddr1, pk1) validator = validator.UpdateStatus(types.Unbonded) - validator, delShares := validator.AddTokensFromDel(sdk.NewInt(10)) + validator, delShares := validator.AddTokensFromDel(math.NewInt(10)) - assert.True(sdk.DecEq(t, math.LegacyNewDec(10), delShares)) + assert.True(math.LegacyDecEq(t, math.LegacyNewDec(10), delShares)) assert.Equal(t, types.Unbonded, validator.Status) - assert.True(math.IntEq(t, sdk.NewInt(10), validator.Tokens)) - assert.True(sdk.DecEq(t, math.LegacyNewDec(10), validator.DelegatorShares)) + assert.True(math.IntEq(t, math.NewInt(10), validator.Tokens)) + assert.True(math.LegacyDecEq(t, math.LegacyNewDec(10), validator.DelegatorShares)) } // TODO refactor to make simpler like the AddToken tests above @@ -138,7 +138,7 @@ func TestRemoveDelShares(t *testing.T) { OperatorAddress: valAddr1.String(), ConsensusPubkey: pk1Any, Status: types.Bonded, - Tokens: sdk.NewInt(100), + Tokens: math.NewInt(100), DelegatorShares: math.LegacyNewDec(100), } @@ -152,26 +152,26 @@ func TestRemoveDelShares(t *testing.T) { validator := mkValidator(5102, math.LegacyNewDec(115)) _, tokens := validator.RemoveDelShares(math.LegacyNewDec(29)) - require.True(math.IntEq(t, sdk.NewInt(1286), tokens)) + require.True(math.IntEq(t, math.NewInt(1286), tokens)) } func TestAddTokensFromDel(t *testing.T) { validator := newValidator(t, valAddr1, pk1) - validator, shares := validator.AddTokensFromDel(sdk.NewInt(6)) - require.True(sdk.DecEq(t, math.LegacyNewDec(6), shares)) - require.True(sdk.DecEq(t, math.LegacyNewDec(6), validator.DelegatorShares)) - require.True(math.IntEq(t, sdk.NewInt(6), validator.Tokens)) + validator, shares := validator.AddTokensFromDel(math.NewInt(6)) + require.True(math.LegacyDecEq(t, math.LegacyNewDec(6), shares)) + require.True(math.LegacyDecEq(t, math.LegacyNewDec(6), validator.DelegatorShares)) + require.True(math.IntEq(t, math.NewInt(6), validator.Tokens)) - validator, shares = validator.AddTokensFromDel(sdk.NewInt(3)) - require.True(sdk.DecEq(t, math.LegacyNewDec(3), shares)) - require.True(sdk.DecEq(t, math.LegacyNewDec(9), validator.DelegatorShares)) - require.True(math.IntEq(t, sdk.NewInt(9), validator.Tokens)) + validator, shares = validator.AddTokensFromDel(math.NewInt(3)) + require.True(math.LegacyDecEq(t, math.LegacyNewDec(3), shares)) + require.True(math.LegacyDecEq(t, math.LegacyNewDec(9), validator.DelegatorShares)) + require.True(math.IntEq(t, math.NewInt(9), validator.Tokens)) } func TestUpdateStatus(t *testing.T) { validator := newValidator(t, valAddr1, pk1) - validator, _ = validator.AddTokensFromDel(sdk.NewInt(100)) + validator, _ = validator.AddTokensFromDel(math.NewInt(100)) require.Equal(t, types.Unbonded, validator.Status) require.Equal(t, int64(100), validator.Tokens.Int64()) @@ -191,7 +191,7 @@ func TestUpdateStatus(t *testing.T) { func TestPossibleOverflow(t *testing.T) { delShares := math.LegacyNewDec(391432570689183511).Quo(math.LegacyNewDec(40113011844664)) validator := mkValidator(2159, delShares) - newValidator, _ := validator.AddTokensFromDel(sdk.NewInt(71)) + newValidator, _ := validator.AddTokensFromDel(math.NewInt(71)) require.False(t, newValidator.DelegatorShares.IsNegative()) require.False(t, newValidator.Tokens.IsNegative()) @@ -217,12 +217,12 @@ func TestValidatorSetInitialCommission(t *testing.T) { expectedErr bool }{ {val, types.NewCommission(math.LegacyZeroDec(), math.LegacyZeroDec(), math.LegacyZeroDec()), false}, - {val, types.NewCommission(math.LegacyZeroDec(), sdk.NewDecWithPrec(-1, 1), math.LegacyZeroDec()), true}, + {val, types.NewCommission(math.LegacyZeroDec(), math.LegacyNewDecWithPrec(-1, 1), math.LegacyZeroDec()), true}, {val, types.NewCommission(math.LegacyZeroDec(), math.LegacyNewDec(15000000000), math.LegacyZeroDec()), true}, - {val, types.NewCommission(sdk.NewDecWithPrec(-1, 1), math.LegacyZeroDec(), math.LegacyZeroDec()), true}, - {val, types.NewCommission(sdk.NewDecWithPrec(2, 1), sdk.NewDecWithPrec(1, 1), math.LegacyZeroDec()), true}, - {val, types.NewCommission(math.LegacyZeroDec(), math.LegacyZeroDec(), sdk.NewDecWithPrec(-1, 1)), true}, - {val, types.NewCommission(math.LegacyZeroDec(), sdk.NewDecWithPrec(1, 1), sdk.NewDecWithPrec(2, 1)), true}, + {val, types.NewCommission(math.LegacyNewDecWithPrec(-1, 1), math.LegacyZeroDec(), math.LegacyZeroDec()), true}, + {val, types.NewCommission(math.LegacyNewDecWithPrec(2, 1), math.LegacyNewDecWithPrec(1, 1), math.LegacyZeroDec()), true}, + {val, types.NewCommission(math.LegacyZeroDec(), math.LegacyZeroDec(), math.LegacyNewDecWithPrec(-1, 1)), true}, + {val, types.NewCommission(math.LegacyZeroDec(), math.LegacyNewDecWithPrec(1, 1), math.LegacyNewDecWithPrec(2, 1)), true}, } for i, tc := range testCases { @@ -278,11 +278,11 @@ func TestValidatorsSortCometBFT(t *testing.T) { pk2 := ed25519.GenPrivKey().PubKey() vals[i] = newValidator(t, sdk.ValAddress(pk2.Address()), pk) vals[i].Status = types.Bonded - vals[i].Tokens = sdk.NewInt(rand.Int63()) + vals[i].Tokens = math.NewInt(rand.Int63()) } // create some validators with the same power for i := 0; i < 10; i++ { - vals[i].Tokens = sdk.NewInt(1000000) + vals[i].Tokens = math.NewInt(1000000) } valz := types.Validators(vals) @@ -310,7 +310,7 @@ func TestValidatorToCmt(t *testing.T) { pk := ed25519.GenPrivKey().PubKey() val := newValidator(t, sdk.ValAddress(pk.Address()), pk) val.Status = types.Bonded - val.Tokens = sdk.NewInt(rand.Int63()) + val.Tokens = math.NewInt(rand.Int63()) vals[i] = val cmtPk, err := cryptocodec.ToCmtPubKeyInterface(pk) require.NoError(t, err) @@ -332,12 +332,12 @@ func TestBondStatus(t *testing.T) { require.Equal(t, types.BondStatusUnbonding, types.Unbonding.String()) } -func mkValidator(tokens int64, shares sdk.Dec) types.Validator { +func mkValidator(tokens int64, shares math.LegacyDec) types.Validator { return types.Validator{ OperatorAddress: valAddr1.String(), ConsensusPubkey: pk1Any, Status: types.Bonded, - Tokens: sdk.NewInt(tokens), + Tokens: math.NewInt(tokens), DelegatorShares: shares, } } diff --git a/x/tx/signing/textual/dec.go b/x/tx/signing/textual/dec.go index d1c175c4e14a..87d694158976 100644 --- a/x/tx/signing/textual/dec.go +++ b/x/tx/signing/textual/dec.go @@ -11,7 +11,7 @@ import ( "cosmossdk.io/math" ) -// NewDecValueRenderer returns a ValueRenderer for encoding sdk.Dec cosmos +// NewDecValueRenderer returns a ValueRenderer for encoding math.Dec cosmos // scalars. func NewDecValueRenderer() ValueRenderer { return decValueRenderer{} @@ -23,7 +23,7 @@ func (vr decValueRenderer) Format(_ context.Context, v protoreflect.Value) ([]Sc decStr := v.String() // If the decimal doesn't contain a point, we assume it's a value formatted using the legacy - // `sdk.Dec`. So we try to parse it as an integer and then convert it to a + // `math.Dec`. So we try to parse it as an integer and then convert it to a // decimal. if !strings.Contains(decStr, ".") { parsedInt, ok := new(big.Int).SetString(decStr, 10)