From 9393eb267a93416f4648083a553a0264ff0479e6 Mon Sep 17 00:00:00 2001
From: Lockwarr <denislav66@gmail.com>
Date: Fri, 27 Sep 2024 16:23:33 +0300
Subject: [PATCH] fix: tests, comments and refactor
---
x/mint/abci.go | 66 +-------
x/mint/abci_test.go | 246 +++++-------------------------
x/mint/client/testutil/suite.go | 4 +-
x/mint/simulation/genesis_test.go | 2 +-
x/mint/types/minter.go | 39 ++---
x/mint/types/minter_test.go | 26 ++--
6 files changed, 66 insertions(+), 317 deletions(-)
diff --git a/x/mint/abci.go b/x/mint/abci.go
index 4984f9cc..69879585 100644
--- a/x/mint/abci.go
+++ b/x/mint/abci.go
@@ -47,10 +47,6 @@ func calcTimeDifference(blockTime, prevBlockTime, maxMintableSeconds sdkmath.Uin
}
func calcTokens(blockTime sdkmath.Uint, minter *types.Minter, maxMintableSeconds sdkmath.Uint) sdkmath.Uint {
- // if minter.TotalMinted.GTE(types.MintingCap) {
- // return sdkmath.ZeroUint()
- // }
-
if minter.PrevBlockTimestamp.IsZero() {
// we do not know how much time has passed since the previous block, thus nothing will be mined
minter.PrevBlockTimestamp = blockTime
@@ -71,29 +67,6 @@ func calcTokens(blockTime sdkmath.Uint, minter *types.Minter, maxMintableSeconds
} else {
return sdkmath.ZeroUint()
}
-
- // if minter.NormTimePassed.LT(types.MonthsInFormula) {
- // // First 96 months follow the minting formula
- // // As the integral starts from NormOffset (ie > 0), previous total needs to be incremented by predetermined amount
- // previousTotal := minter.TotalMinted.Add(normInitialTotal)
- // newNormTime := minter.NormTimePassed.Add(calcFunctionIncrement(nsecPassed))
- // nextTotal := types.CalcTokensByIntegral(newNormTime)
-
- // delta := nextTotal.Sub(previousTotal)
-
- // return updateMinter(minter, blockTime, newNormTime, delta)
- // } else {
- // // After reaching 96 normalized time, mint fixed amount of tokens per month until we reach the minting cap
- // normIncrement := calcFixedIncrement(nsecPassed)
- // delta := sdkmath.NewUint((normIncrement.Mul(types.DecFromUint(types.FixedMintedAmount))).TruncateInt().Uint64())
-
- // // if minter.TotalMinted.Add(delta).GT(types.MintingCap) {
- // // Trim off excess tokens if the cap is reached
- // // delta = types.MintingCap.Sub(minter.TotalMinted)
- // // }
-
- // return updateMinter(minter, blockTime, minter.NormTimePassed.Add(normIncrement), delta)
- // }
}
func updateMinter(minter *types.Minter, blockTime sdkmath.Uint, newNormTime sdkmath.LegacyDec, newlyMinted sdkmath.Uint) sdkmath.Uint {
@@ -122,7 +95,7 @@ func predictMintedByIntegral(totalMinted sdkmath.Uint, normTimePassed, timeAhead
return sdkmath.ZeroUint(), nil
}
- // integral minting is caped to the 96th month
+ // integral minting is caped to the 120th month
if normTimeInFuture.GT(types.MonthsInFormula) {
normTimeInFuture = types.MonthsInFormula
}
@@ -130,33 +103,6 @@ func predictMintedByIntegral(totalMinted sdkmath.Uint, normTimePassed, timeAhead
return types.CalcTokensByIntegral(normTimeInFuture).Sub(normInitialTotal).Sub(totalMinted), nil
}
-// Returns the amount of tokens that should be minted during the fixed amount period
-// for the period between NormTimePassed and the timeInFuture.
-func predictMintedByFixedAmount(totalMinted sdkmath.Uint, normTimePassed, timeAhead sdkmath.LegacyDec) (sdkmath.Uint, error) {
- timeAheadNs := timeAhead.Mul(nanoSecondsInMonth).TruncateInt()
-
- normTimeInFuture := normTimePassed.Add(calcFunctionIncrement(sdkmath.Uint(timeAheadNs)))
- if normTimePassed.GT(normTimeInFuture) {
- return sdkmath.ZeroUint(), errTimeInFutureBeforeTimePassed
- }
-
- normFixedPeriod := normTimeInFuture.Sub(calcFunctionIncrement(sdkmath.Uint(nanoSecondsInFormula.TruncateInt())))
- if normFixedPeriod.LTE(sdkmath.LegacyZeroDec()) {
- return sdkmath.ZeroUint(), nil
- }
-
- // convert norm time to non norm time
- fixedPeriod := normFixedPeriod.Sub(types.NormOffset).Quo(types.NormMonthsRange)
-
- newlyMinted := fixedPeriod.MulInt(sdkmath.Int(types.FixedMintedAmount))
- // Trim off excess tokens if the cap is reached
- // if totalMinted.Add(sdkmath.Uint(newlyMinted.TruncateInt())).GT(types.MintingCap) {
- // return types.MintingCap.Sub(totalMinted), nil
- // }
-
- return sdkmath.Uint(newlyMinted.TruncateInt()), nil
-}
-
// Returns the amount of tokens that should be minted
// between the NormTimePassed and the timeAhead
// timeAhead expects months represented in decimal form.
@@ -166,21 +112,13 @@ func predictTotalMinted(totalMinted sdkmath.Uint, normTimePassed, timeAhead sdkm
return sdkmath.ZeroUint()
}
- fixedAmount, err := predictMintedByFixedAmount(totalMinted, normTimePassed, timeAhead)
- if err != nil {
- return sdkmath.ZeroUint()
- }
-
- return fixedAmount.Add(integralAmount)
+ return integralAmount
}
// BeginBlocker mints new tokens for the previous block.
func BeginBlocker(ctx context.Context, k keeper.Keeper) error {
c := sdk.UnwrapSDKContext(ctx)
minter := k.GetMinter(ctx)
- // if minter.TotalMinted.GTE(types.MintingCap) {
- // return errors.New("minting cap has been reached")
- // }
defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyBeginBlocker)
diff --git a/x/mint/abci_test.go b/x/mint/abci_test.go
index 378fe350..79dbf962 100644
--- a/x/mint/abci_test.go
+++ b/x/mint/abci_test.go
@@ -16,28 +16,32 @@ import (
)
var (
- expectedCoins60Sec = sdkmath.NewUint(147535251163101)
- expectedNormTime20Sec = sdkmath.LegacyMustNewDecFromStr("95.999976965179227961")
+ expectedCoins60Sec = sdkmath.NewUint(110671242932283)
+ expectedNormTime20Sec = sdkmath.LegacyMustNewDecFromStr("119.999976884641925729")
normTimeThreshold = sdkmath.LegacyMustNewDecFromStr("0.0001")
fiveMinutesInNano = sdkmath.NewUint(uint64(time.Minute.Nanoseconds() * 5))
expectedTokensInFormula = []int64{
- 3759989678764, 3675042190671, 3591959455921, 3510492761731,
- 3430894735556, 3352957640645, 3276743829430, 3202299947048, 3129456689610, 3058269447752,
- 2988635387331, 2920578426197, 2854081215478, 2789206352970, 2725694534821, 2663751456612,
- 2603392455686, 2544229951801, 2486586312604, 2430266441855, 2375370186150, 2321790458408,
- 2269471441070, 2218404771718, 2168676312642, 2120106446370, 2072730033868, 2026569326236,
- 1981502209633, 1937662505273, 1894776317892, 1853047004297, 1812400331621, 1772672353478,
- 1734048861880, 1696309269859, 1659581717535, 1623727160904, 1588788875111, 1554677158679,
- 1521456570881, 1489014024628, 1457399071357, 1426569077784, 1396420182708, 1367035157098,
- 1338295086558, 1310242203296, 1282828095325, 1256078098440, 1229806138168, 1204170896528,
- 1179101215073, 1154454133557, 1130346086275, 1106674161508, 1083471952854, 1060674232689,
- 1038228517507, 1016164727286, 994432638055, 972990871407, 951827390485, 930951168170,
- 910275692536, 889867731221, 869554578094, 849428221672, 829451772393, 809554555703,
- 789741963552, 769980269406, 750255593001, 730519445685, 710773940732, 690976498669,
- 671085262062, 651131377798, 631008346988, 610747683954, 590316688226, 569699591966,
- 548832098993, 527723637864, 506308309490, 484613046274, 462585855489, 440201215001,
- 417441533390, 394262128601, 370667272533, 346593248698, 322056063563, 297009874733,
- 271424507593, 245276309734,
+ 831471167387, 829820863761, 828281868588, 826839730229,
+ 825478208594, 824245045239, 823079423313, 822040420023, 821068654579, 820213875087,
+ 819440568386, 818769585963, 818188244433, 817710710496, 817307924485, 816997527407,
+ 816801218448, 816665071819, 816653649327, 816687516174, 816829020601, 817076870515,
+ 817381227849, 817797546633, 818285112383, 818851440472, 819521147414, 820244244256,
+ 821076677649, 821989017422, 822969470941, 824035436872, 825179899902, 826414307226,
+ 827719521455, 829106029879, 830572546616, 832114890622, 833716613001, 835411110262,
+ 837177165020, 839021213069, 840930930851, 842916649359, 844972836509, 847097499967,
+ 849298799875, 851576789297, 853903163473, 856331938931, 858791497471, 861331985362,
+ 863962242560, 866625630338, 869363060252, 872175658740, 875054103746, 877980110097,
+ 880975946858, 884048218881, 887171089932, 890339954723, 893573962494, 896878411923,
+ 900234010041, 903659884903, 907126102331, 910673269050, 914266110944, 917897409726,
+ 921597576949, 925364386158, 929161815914, 933015513595, 936936824067, 940877689459,
+ 944912156067, 948980488929, 953081003798, 957231607980, 961453590558, 965711597981,
+ 970004010105, 974358571556, 978754847098, 983204268459, 987669657610, 992198558014,
+ 996767161256, 1001386360978, 1006046700901, 1010749072213, 1015471626361, 1020258693631,
+ 1025054584775, 1029909842031, 1034789697625, 1039716743761, 1044692845653, 1049702564826,
+ 1054707264879, 1059775597373, 1064882345537, 1070005834258, 1075175024704, 1080380322095,
+ 1085587142549, 1090852470274, 1096136767172, 1101460461185, 1106804686306, 1112155724140,
+ 1117554744480, 1122993046929, 1128426460549, 1133897580718, 1139405112592, 1144914091087,
+ 1150478593260, 1156032420164,
}
)
@@ -140,7 +144,7 @@ func Test_CalcTokensDuringFormula_WhenUsingVaryingIncrements_OutputExpectedToken
timeOffset = timeOffset.Add(i)
}
- mintThreshold := sdkmath.NewUint(10_000_000) // 10 tokens
+ mintThreshold := sdkmath.NewUint(20_000_000) // 10 tokens
fmt.Printf("%v Returned Total, %v Total Minted(in store), %v Norm Time \n", mintedCoins, minter.TotalMinted, minter.NormTimePassed)
if types.GetAbsDiff(expectedCoins60Sec, mintedCoins).GT(mintThreshold) || types.GetAbsDiff(expectedCoins60Sec, sdkmath.Uint(minter.TotalMinted)).GT(mintThreshold) {
@@ -153,77 +157,6 @@ func Test_CalcTokensDuringFormula_WhenUsingVaryingIncrements_OutputExpectedToken
expectedNormTime20Sec, normTimeThreshold, minter.NormTimePassed)
}
}
-
-func Test_CalcTokensFixed_WhenNotHittingMintCapInAMonth_OutputsExpectedTokensWithinEpsilon(t *testing.T) {
- _, _, _, timeOffset := defaultParams()
-
- offsetNanoInMonth := timeOffset.Add(uintFromDec(nanoSecondsInMonth))
- minter := types.NewMinter(types.MonthsInFormula, sdkmath.ZeroUint(), timeOffset, sdkmath.ZeroUint())
- mintedCoins := sdkmath.ZeroUint()
- r := rand.New(rand.NewSource(util.GetCurrentTimeUnixNano()))
-
- for timeOffset.LT(offsetNanoInMonth) {
- i := sdkmath.NewUint(randomTimeBetweenBlocks(5, 60, r))
- coins := calcTokens(timeOffset.Add(i), &minter, fiveMinutesInNano)
-
- if coins.LT(sdkmath.ZeroUint()) {
- t.Errorf("Minted negative %v coins", coins)
- }
-
- mintedCoins = mintedCoins.Add(coins)
- timeOffset = timeOffset.Add(i)
- }
-
- fmt.Printf("%v Returned Total, %v Total Minted(in store), %v Norm Time \n",
- mintedCoins, minter.TotalMinted, minter.NormTimePassed)
- mintThreshold := sdkmath.NewUint(2_437_500) // 2.4375 tokens is the max deviation
-
- if types.GetAbsDiff(types.FixedMintedAmount, mintedCoins).GT(mintThreshold) || types.GetAbsDiff(types.FixedMintedAmount, minter.TotalMinted).GT(mintThreshold) {
- t.Errorf("Minted unexpected amount of tokens, expected [%v +/- %v] returned and in store, actual minted %v, actual in store %v",
- types.FixedMintedAmount, mintThreshold, mintedCoins, minter.TotalMinted)
- }
-
- if (types.MonthsInFormula.Add(sdkmath.LegacyOneDec())).Sub(minter.NormTimePassed).Abs().GT(normTimeThreshold) {
- t.Errorf("Received unexpected normalized time, expected [%v +/- %v], actual %v", expectedNormTime20Sec, normTimeThreshold, minter.NormTimePassed)
- }
-}
-
-// func Test_CalcTokensFixed_WhenHittingMintCapInAMonth_DoesNotExceedMaxMintingCap(t *testing.T) {
-// _, _, _, timeOffset := defaultParams()
-
-// offsetNanoInMonth := timeOffset.Add(uintFromDec(nanoSecondsInMonth))
-
-// halfFixedAmount := types.FixedMintedAmount.Quo(sdkmath.NewUint(2))
-// totalMinted := types.MintingCap.Sub(halfFixedAmount)
-// minter := types.NewMinter(types.MonthsInFormula, totalMinted, timeOffset, sdkmath.ZeroUint())
-// mintedCoins := sdkmath.NewUint(0)
-// r := rand.New(rand.NewSource(util.GetCurrentTimeUnixNano()))
-
-// for timeOffset.LT(offsetNanoInMonth) {
-// i := sdkmath.NewUint(randomTimeBetweenBlocks(5, 60, r))
-
-// coins := calcTokens(timeOffset.Add(i), &minter, fiveMinutesInNano)
-// mintedCoins = mintedCoins.Add(coins)
-// timeOffset = timeOffset.Add(i)
-// }
-
-// fmt.Printf("%v Returned Total, %v Total Minted(in store), %v Norm Time \n",
-// mintedCoins, minter.TotalMinted, minter.NormTimePassed)
-// mintThreshold := sdkmath.NewUint(1_000_000) // 1 token
-// if types.MintingCap.Sub(minter.TotalMinted).GT(sdkmath.ZeroUint()) {
-// t.Errorf("Minting Cap exceeded, minted total %v, with minting cap %v",
-// minter.TotalMinted, types.MintingCap)
-// }
-// if types.GetAbsDiff(halfFixedAmount, mintedCoins).GT(mintThreshold) {
-// t.Errorf("Minted unexpected amount of tokens, expected [%v +/- %v] returned and in store, actual minted %v",
-// halfFixedAmount, mintThreshold, mintedCoins)
-// }
-// if (types.MonthsInFormula.Add(sdkmath.LegacyMustNewDecFromStr("0.5"))).Sub(minter.NormTimePassed).Abs().GT(normTimeThreshold) {
-// t.Errorf("Received unexpected normalized time, expected [%v +/- %v], actual %v",
-// types.MonthsInFormula.Add(sdkmath.LegacyMustNewDecFromStr("0.5")), normTimeThreshold, minter.NormTimePassed)
-// }
-// }
-
func Test_CalcTokens_WhenMintingAllTokens_OutputsExactExpectedTokens(t *testing.T) {
minter, mintedCoins, mintedMonth, timeOffset := defaultParams()
prevOffset := timeOffset
@@ -347,47 +280,47 @@ func Test_PredictMintedByIntegral_TwelveMonthsAhead(t *testing.T) {
}{
{
title: "start from genesis, 1 month calculated by integral",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("0.47"),
+ normTimePassed: sdkmath.LegacyMustNewDecFromStr("0.17"),
timeAhead: sdkmath.LegacyMustNewDecFromStr("1"),
totalMinted: sdkmath.ZeroUint(),
- expIntegralMinted: sdkmath.NewUintFromString("3_760_114_000_000"),
+ expIntegralMinted: sdkmath.NewUintFromString("831_474_371_998"),
expError: false,
},
{
title: "start from genesis, 12 months calculated by integral",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("0.47"),
+ normTimePassed: sdkmath.LegacyMustNewDecFromStr("0.17"),
timeAhead: twelveMonths,
totalMinted: sdkmath.ZeroUint(),
- expIntegralMinted: sdkmath.NewUintFromString("39_897_845_000_000"),
+ expIntegralMinted: sdkmath.NewUintFromString("9_890_844_457_754"),
expError: false,
},
{
- title: "in the 96 months range, 12 months calculated by integral",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("5.44552083"),
+ title: "in the 120 months range, 12 months calculated by integral",
+ normTimePassed: sdkmath.LegacyMustNewDecFromStr("2.04"),
timeAhead: twelveMonths,
- totalMinted: sdkmath.NewUintFromString("14_537_732_000_000"),
- expIntegralMinted: sdkmath.NewUintFromString("38_996_481_000_000"),
+ totalMinted: sdkmath.NewUintFromString("141_722_242_835"),
+ expIntegralMinted: sdkmath.NewUintFromString("11_280_925_194_119"),
expError: false,
},
{
- title: "ends on the 96th month, 12 months calculated by integral",
+ title: "ends on the 120th month, 12 months calculated by integral",
normTimePassed: sdkmath.LegacyMustNewDecFromStr("84.05875000"),
timeAhead: twelveMonths,
- totalMinted: sdkmath.NewUintFromString("142_977_230_000_000"),
- expIntegralMinted: sdkmath.NewUintFromString("4_558_027_000_000"),
+ totalMinted: sdkmath.NewUintFromString("1_977_230_000_000"),
+ expIntegralMinted: sdkmath.NewUintFromString("82_441_220_298_725"),
expError: false,
},
{
- title: "partially in the 96 months range, 1 month calculated by integral",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("95.00489583"),
+ title: "partially in the 120 months range, 1 month calculated by integral",
+ normTimePassed: sdkmath.LegacyMustNewDecFromStr("119.00489583"),
timeAhead: twelveMonths,
- totalMinted: sdkmath.NewUintFromString("147_290_028_000_000"),
- expIntegralMinted: sdkmath.NewUintFromString("245_229_000_000"),
+ totalMinted: sdkmath.NewUintFromString("100_290_028_000_000"),
+ expIntegralMinted: sdkmath.NewUintFromString("10_381_241_757_165"),
expError: false,
},
{
- title: "after 96th months, 0 months calculated by integral",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("98"),
+ title: "after 120th month, 0 months calculated by integral",
+ normTimePassed: sdkmath.LegacyMustNewDecFromStr("125"),
timeAhead: twelveMonths,
totalMinted: sdkmath.NewUintFromString("147_741_507_000_000"),
expIntegralMinted: sdkmath.ZeroUint(),
@@ -405,7 +338,7 @@ func Test_PredictMintedByIntegral_TwelveMonthsAhead(t *testing.T) {
title: "zero time ahead should not mint tokens",
normTimePassed: sdkmath.LegacyMustNewDecFromStr("85.05385417"),
timeAhead: sdkmath.LegacyZeroDec(),
- totalMinted: sdkmath.NewUintFromString("143_483_520_000_000"),
+ totalMinted: sdkmath.NewUintFromString("73_345_777_103_641"),
expIntegralMinted: sdkmath.ZeroUint(),
expError: false,
},
@@ -430,101 +363,6 @@ func Test_PredictMintedByIntegral_TwelveMonthsAhead(t *testing.T) {
}
}
-func Test_PredictMintedByFixedAmount_TwelveMonthsAhead(t *testing.T) {
- expAcceptedDeviation := sdkmath.NewUint(500) // 0.0005 token
-
- for _, tc := range []struct {
- title string
- normTimePassed sdkmath.LegacyDec
- timeAhead sdkmath.LegacyDec
- totalMinted sdkmath.Uint
- expFixedMinted sdkmath.Uint
- expError bool
- }{
- {
- title: "in the 96 months range, 0 months calculated by fixed amount",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("0.47"),
- timeAhead: twelveMonths,
- totalMinted: sdkmath.ZeroUint(),
- expFixedMinted: sdkmath.ZeroUint(),
- expError: false,
- },
- {
- title: "starts on the 96th month, 1 month calculated by fixed amount",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("96"),
- timeAhead: sdkmath.LegacyMustNewDecFromStr("1"),
- totalMinted: sdkmath.NewUintFromString("147_535_257_000_000"),
- expFixedMinted: sdkmath.NewUintFromString("103_125_000_000"),
- expError: false,
- },
- {
- title: "partially in the 96 months range, 1 month calculated by fixed amount",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("85.05385417"),
- timeAhead: twelveMonths,
- totalMinted: sdkmath.NewUintFromString("143_483_520_000_000"),
- expFixedMinted: sdkmath.NewUintFromString("103_125_000_000"),
- expError: false,
- },
- {
- title: "starts on the 96th month, all months calculated by fixed amount",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("96"),
- timeAhead: twelveMonths,
- totalMinted: sdkmath.NewUintFromString("147_535_257_000_000"),
- expFixedMinted: sdkmath.NewUintFromString("103_125_000_000").MulUint64(12),
- expError: false,
- },
- {
- title: "partially in the 96-120 month range, few days calculated by fixed amount",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("119.0"),
- timeAhead: twelveMonths,
- totalMinted: sdkmath.NewUintFromString("149_900_000_000_000"),
- expFixedMinted: sdkmath.NewUintFromString("100_000_000_000"),
- expError: false,
- },
- {
- title: "after minting cap reached, 0 months calculated by fixed amount",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("119.9"),
- timeAhead: twelveMonths,
- totalMinted: sdkmath.NewUintFromString("150_000_000_000_000"),
- expFixedMinted: sdkmath.ZeroUint(),
- expError: false,
- },
- {
- title: "negative time ahead should result in error",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("98"),
- timeAhead: sdkmath.LegacyMustNewDecFromStr("-1.0"),
- totalMinted: sdkmath.ZeroUint(),
- expFixedMinted: sdkmath.ZeroUint(),
- expError: true,
- },
- {
- title: "zero time ahead should not mint tokens",
- normTimePassed: sdkmath.LegacyMustNewDecFromStr("85.05385417"),
- timeAhead: sdkmath.LegacyZeroDec(),
- totalMinted: sdkmath.NewUintFromString("143_483_520_000_000"),
- expFixedMinted: sdkmath.ZeroUint(),
- expError: false,
- },
- } {
- t.Run(tc.title, func(t *testing.T) {
- minter := &types.Minter{
- NormTimePassed: tc.normTimePassed,
- TotalMinted: tc.totalMinted,
- }
-
- newlyMinted, err := predictMintedByFixedAmount(minter.TotalMinted, minter.NormTimePassed, tc.timeAhead)
- if tc.expError && err == nil {
- t.Error("Error is expected")
- }
-
- actExpDiff := types.GetAbsDiff(newlyMinted, tc.expFixedMinted)
- if actExpDiff.GT(expAcceptedDeviation) {
- t.Errorf("Minted exp: %v, act: %v, diff: %v", tc.expFixedMinted, newlyMinted, actExpDiff)
- }
- })
- }
-}
-
func randomTimeBetweenBlocks(min uint64, max uint64, r *rand.Rand) uint64 {
return uint64(time.Second.Nanoseconds()) * (uint64(r.Int63n(sdkmath.NewIntFromUint64(max-min).Int64())) + min)
}
diff --git a/x/mint/client/testutil/suite.go b/x/mint/client/testutil/suite.go
index d8ad4bd4..e70ff784 100644
--- a/x/mint/client/testutil/suite.go
+++ b/x/mint/client/testutil/suite.go
@@ -96,12 +96,12 @@ func (s *IntegrationTestSuite) TestGetCmdQueryMintState() {
{
"json output",
[]string{fmt.Sprintf("--%s=1", flags.FlagHeight), fmt.Sprintf("--%s=json", tmcli.OutputFlag)},
- `{"norm_time_passed":"0.470000000000000000","total_minted":"0"}`,
+ `{"norm_time_passed":"0.170000000000000000","total_minted":"0"}`,
},
{
"text output",
[]string{fmt.Sprintf("--%s=1", flags.FlagHeight), fmt.Sprintf("--%s=text", tmcli.OutputFlag)},
- `norm_time_passed: "0.470000000000000000"
+ `norm_time_passed: "0.170000000000000000"
total_minted: "0"`,
},
}
diff --git a/x/mint/simulation/genesis_test.go b/x/mint/simulation/genesis_test.go
index 46a8c02d..306c1e13 100644
--- a/x/mint/simulation/genesis_test.go
+++ b/x/mint/simulation/genesis_test.go
@@ -45,7 +45,7 @@ func TestRandomizedGenState(t *testing.T) {
require.Equal(t, sdkmath.NewUint(uint64(time.Second.Nanoseconds()*13)), mintGenesis.Params.MaxMintableNanoseconds)
require.Equal(t, "0", mintGenesis.Minter.TotalMinted.String())
- require.Equal(t, "0.470000000000000000", mintGenesis.Minter.NormTimePassed.String())
+ require.Equal(t, "0.170000000000000000", mintGenesis.Minter.NormTimePassed.String())
require.Equal(t, sdkmath.ZeroUint(), mintGenesis.Minter.PrevBlockTimestamp)
}
diff --git a/x/mint/types/minter.go b/x/mint/types/minter.go
index 61f0f636..78809bec 100644
--- a/x/mint/types/minter.go
+++ b/x/mint/types/minter.go
@@ -11,13 +11,11 @@ import (
// Legacy Minting formula integral-4.33275 x^3 + 952.82456 x^2 - 88567.49981 x + 3.86381×10^6 dx = -1.08319 x^4 + 317.608 x^3 - 44283.7 x^2 + 3863810 x + constant
// Current Minting formula integral-0.11175 x^3 + 50.82456 x^2 - 1767.49981 x + 0.83381×10^6 dx = -0.0279375 x^4 + 16.9415 x^3 - 883.75 x^2 + 833810 x + constant
-// Minting formula f(x)=-4.33275 x^3 + 944.61206 x^2 - 88567.25194 x + 3.86335×10^6 integrated over 0.17 to 120
var (
- QuadCoef = sdkmath.LegacyMustNewDecFromStr("-0.0279375")
- CubeCoef = sdkmath.LegacyMustNewDecFromStr("16.9415")
- SquareCoef = sdkmath.LegacyMustNewDecFromStr("-883.75")
- Coef = sdkmath.LegacyMustNewDecFromStr("833810")
- // MintingCap = util.ConvertToMicroNolusInt64(150000000)
+ QuadCoef = sdkmath.LegacyMustNewDecFromStr("-0.0279375")
+ CubeCoef = sdkmath.LegacyMustNewDecFromStr("16.9415")
+ SquareCoef = sdkmath.LegacyMustNewDecFromStr("-883.75")
+ Coef = sdkmath.LegacyMustNewDecFromStr("833810")
FixedMintedAmount = util.ConvertToMicroNolusInt64(103125)
NormOffset = sdkmath.LegacyMustNewDecFromStr("0.17")
TotalMonths = sdkmath.LegacyMustNewDecFromStr("120")
@@ -60,23 +58,12 @@ func ValidateMinter(minter Minter) error {
minter.NormTimePassed.String())
}
- // if minter.NormTimePassed.GT(TotalMonths) {
- // return fmt.Errorf("mint parameter normTimePassed: %v should not be bigger than TotalMonths: %v", minter.NormTimePassed, TotalMonths)
- // }
-
- // if minter.TotalMinted.GT(MintingCap) {
- // return fmt.Errorf("mint parameter totalMinted: %v can not be bigger than MintingCap: %v",
- // minter.TotalMinted, MintingCap)
- // }
+ if minter.NormTimePassed.GT(TotalMonths) {
+ return fmt.Errorf("mint parameter normTimePassed: %v should not be bigger than TotalMonths: %v", minter.NormTimePassed, TotalMonths)
+ }
calculatedMintedTokens := calcMintedTokens(minter)
- // if minter.NormTimePassed.GT(TotalMonths.Sub(sdkmath.LegacyNewDec(1))) {
- // if calculatedMintedTokens.GT(MintingCap) || MintingCap.Sub(calculatedMintedTokens).GT(FixedMintedAmount) {
- // return fmt.Errorf("mint parameters are not conformant with the minting schedule, for %s month minted %s unls",
- // minter.NormTimePassed, calculatedMintedTokens)
- // }
- // } else
if !calculatedMintedTokens.Equal(minter.TotalMinted) {
return fmt.Errorf("minted unexpected amount of tokens for %s months. act: %v, exp: %v",
minter.NormTimePassed, minter.TotalMinted, calculatedMintedTokens)
@@ -86,19 +73,11 @@ func ValidateMinter(minter Minter) error {
}
func calcMintedTokens(m Minter) sdkmath.Uint {
- // if m.NormTimePassed.GTE(MonthsInFormula) {
- // fixedMonthsPeriod := sdkmath.NewUint(m.NormTimePassed.Sub(MonthsInFormula).TruncateInt().Uint64())
- // fixedMonthsTokens := fixedMonthsPeriod.Mul(FixedMintedAmount)
- // calculatedTokensByIntegral := CalcTokensByIntegral(MonthsInFormula).Sub(CalcTokensByIntegral(NormOffset))
-
- // return calculatedTokensByIntegral.Add(fixedMonthsTokens)
- // } else {
return CalcTokensByIntegral(m.NormTimePassed).Sub(CalcTokensByIntegral(NormOffset))
- // }
}
-// Integral: -1.08319 x^4 + 314.871 x^3 - 44283.6 x^2 + 3.86335×10^6 x
-// transformed to: (((-1.08319 x + 314.871) x - 44283.6) x +3.86335×10^6) x.
+// Integral: -0.0279375 x^4 + 16.9415 x^3 - 883.75 x^2 + 833810 x + constant
+// transformed to: (((-0.0279375 x + 16.9415) x - 883.75) x + 833810) x.
func CalcTokensByIntegral(x sdkmath.LegacyDec) sdkmath.Uint {
return util.ConvertToMicroNolusDec(((((QuadCoef.Mul(x).Add(CubeCoef)).Mul(x).Add(SquareCoef)).Mul(x).Add(Coef)).Mul(x)))
}
diff --git a/x/mint/types/minter_test.go b/x/mint/types/minter_test.go
index a8b7edf5..77916e58 100644
--- a/x/mint/types/minter_test.go
+++ b/x/mint/types/minter_test.go
@@ -22,22 +22,22 @@ func Test_calcMintedTokens(t *testing.T) {
{
title: "starting at the end of 1st month",
normTimePassed: sdkmath.LegacyMustNewDecFromStr("1.46510417"),
- expTotalMinted: sdkmath.NewUintFromString("3_760_114_000_000"),
+ expTotalMinted: sdkmath.NewUintFromString("1_078_052_419_498"),
},
{
title: "starting at the end of 2nd month",
normTimePassed: sdkmath.LegacyMustNewDecFromStr("2.46020833"),
- expTotalMinted: sdkmath.NewUintFromString("7_435_238_000_000"),
+ expTotalMinted: sdkmath.NewUintFromString("190_4526_305_072"),
},
{
title: "starting at the end of 96th month",
normTimePassed: sdkmath.LegacyMustNewDecFromStr("96.00000000"),
- expTotalMinted: sdkmath.NewUintFromString("147_535_257_000_000"),
+ expTotalMinted: sdkmath.NewUintFromString("84_375_290_749_165"),
},
{
title: "starting at the end of 97th month",
normTimePassed: sdkmath.LegacyMustNewDecFromStr("97.00000000"),
- expTotalMinted: sdkmath.NewUintFromString("147_638_382_000_000"),
+ expTotalMinted: sdkmath.NewUintFromString("85_411_406_848_727"),
},
} {
t.Run(tc.title, func(t *testing.T) {
@@ -75,18 +75,12 @@ func Test_ValidateMinter(t *testing.T) {
totalMinted: DefaultInitialMinter().TotalMinted,
expErr: true,
},
- // {
- // title: "norm time passed bigger then the minting schedule cap should return error",
- // normTimePassed: TotalMonths.Add(sdkmath.LegacyMustNewDecFromStr("0.1")),
- // totalMinted: DefaultInitialMinter().TotalMinted,
- // expErr: true,
- // },
- // {
- // title: "total minted bigger then minting cap should return error",
- // normTimePassed: DefaultInitialMinter().NormTimePassed,
- // totalMinted: MintingCap.Add(sdkmath.NewUint(1)),
- // expErr: true,
- // },
+ {
+ title: "norm time passed bigger then the minting schedule cap should return error",
+ normTimePassed: TotalMonths.Add(sdkmath.LegacyMustNewDecFromStr("0.1")),
+ totalMinted: DefaultInitialMinter().TotalMinted,
+ expErr: true,
+ },
{
title: "total minted not fitting the minting schedule should return error",
normTimePassed: sdkmath.LegacyMustNewDecFromStr("2.46020833"),