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

refactor(staking, slashing, signing, misc): remove aliases from types/math.go (#15902)

Browse Source
This commit is contained in:
samricotta
2023-04-25 08:55:17 +00:00
committed by GitHub
parent 91872abdc0
commit e77156858f
50 changed files with 374 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/grpc/gogoreflection/fix_registration.go
+1 -1
View File
@@ -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,
types/bench_test.go
+4 -2
View File
@@ -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)
types/coin_test.go
+77 -77
View File
@@ -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{}))
types/dec_coin_test.go
+24 -24
View File
@@ -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",
},
x/gov/keeper/deposit_test.go
+1 -1
View File
@@ -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()
x/gov/keeper/tally.go
+1 -1
View File
@@ -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()
x/gov/simulation/genesis.go
+11 -11
View File
@@ -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) },
x/params/keeper/keeper_test.go
+1 -1
View File
@@ -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),
)
x/slashing/client/cli/tx_test.go
+3 -1
View File
@@ -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()),
},
"",
},
x/slashing/keeper/hooks.go
+2 -1
View File
@@ -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
}
x/slashing/keeper/keeper.go
+3 -2
View File
@@ -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(
x/slashing/keeper/keeper_test.go
+7 -6
View File
@@ -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,
)
x/slashing/keeper/msg_server_test.go
+18 -16
View File
@@ -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()
x/slashing/keeper/params.go
+4 -2
View File
@@ -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
}
x/slashing/simulation/genesis.go
+4 -5
View File
@@ -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) },
x/slashing/simulation/genesis_test.go
+3 -4
View File
@@ -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)
x/slashing/simulation/operations_test.go
+1 -1
View File
@@ -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)
x/slashing/simulation/proposals.go
+5 -3
View File
@@ -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(),
x/slashing/simulation/proposals_test.go
+4 -3
View File
@@ -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)
}
x/slashing/types/expected_keepers.go
+3 -3
View File
@@ -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
}
x/slashing/types/params.go
+6 -8
View File
@@ -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)
}
x/staking/bench_test.go
+1 -1
View File
@@ -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)
}
x/staking/client/cli/tx.go
+4 -4
View File
@@ -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")
x/staking/client/cli/utils.go
+4 -4
View File
@@ -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
}
x/staking/keeper/delegation.go
+7 -7
View File
@@ -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
x/staking/keeper/delegation_test.go
+20 -20
View File
@@ -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
x/staking/keeper/invariants.go
+1 -1
View File
@@ -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 {
x/staking/keeper/pool.go
+1 -1
View File
@@ -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()
x/staking/keeper/power_reduction_test.go
+3 -2
View File
@@ -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))
}
x/staking/keeper/slash.go
+10 -10
View File
@@ -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()
x/staking/keeper/val_state_change.go
+1 -1
View File
@@ -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)
x/staking/keeper/validator.go
+3 -3
View File
@@ -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
x/staking/keeper/validator_test.go
+16 -16
View File
@@ -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)
x/staking/simulation/common_test.go
+3 -1
View File
@@ -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))
}
x/staking/simulation/genesis.go
+6 -4
View File
@@ -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)
x/staking/simulation/operations_test.go
+1 -1
View File
@@ -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)
x/staking/simulation/proposals.go
+3 -1
View File
@@ -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(),
x/staking/simulation/proposals_test.go
+2 -1
View File
@@ -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)
}
x/staking/types/commission.go
+4 -6
View File
@@ -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
x/staking/types/commission_test.go
+1 -1
View File
@@ -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
}{
x/staking/types/delegation.go
+6 -6
View File
@@ -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),
x/staking/types/delegation_test.go
+9 -9
View File
@@ -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)
x/staking/types/expected_keepers.go
+3 -3
View File
@@ -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
}
x/staking/types/exported.go
+21 -21
View File
@@ -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
}
x/staking/types/hooks.go
+3 -1
View File
@@ -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
x/staking/types/msg.go
+1 -1
View File
@@ -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,
x/staking/types/params.go
+3 -3
View File
@@ -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)
}
x/staking/types/validator.go
+10 -10
View File
@@ -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
x/staking/types/validator_test.go
+42 -42
View File
@@ -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,
}
}
x/tx/signing/textual/dec.go
+2 -2
View File
@@ -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)