Remove legacy stake reward calculation code.

This commit is similar to this one.

https://github.com/novacoin-project/novacoin/commit/8118d1168e4e3f87f8d19c58ec3cce36eccdb92b

diff --git a/Novacoin/CBlock.cs b/Novacoin/CBlock.cs
index 923b47a..69c8a28 100644 (file)
--- a/Novacoin/CBlock.cs
+++ b/Novacoin/CBlock.cs
@@ -509,7 +509,7 @@ namespace Novacoin
                     bnLowerBound = bnMidValue;
             }
 
-            long nSubsidy = (long)bnUpperBound;
+            long nSubsidy = bnUpperBound;
             nSubsidy = (nSubsidy / CTransaction.nCent) * CTransaction.nCent;
 
             return Math.Min(nSubsidy, NetInfo.nMaxMintProofOfWork) + nFees;
@@ -517,82 +517,56 @@ namespace Novacoin
 
         public static long GetProofOfStakeReward(long nCoinAge, uint nBits, uint nTime)
         {
+            // Second stage of emission process is mostly PoS-based.
+
             long nRewardCoinYear, nSubsidy, nSubsidyLimit = 10 * CTransaction.nCoin;
+            // Base stake mint rate, 100% year interest
+            BigNum bnRewardCoinYearLimit = NetInfo.nMaxMintProofOfStake; 
 
-            if (nTime > NetInfo.nDynamicStakeRewardTime)
-            {
-                // Stage 2 of emission process is PoS-based. It will be active on mainNet since 20 Jun 2013.
+            uint256 nTarget = 0;
+            nTarget.Compact = nBits;
 
-                BigNum bnRewardCoinYearLimit = NetInfo.nMaxMintProofOfStake; // Base stake mint rate, 100% year interest
+            BigNum bnTarget = nTarget;
+            BigNum bnTargetLimit = NetInfo.GetProofOfStakeLimit(0, nTime);
 
-                uint256 nTarget = 0;
-                nTarget.Compact = nBits;
+            // A reasonably continuous curve is used to avoid shock to market
 
-                BigNum bnTarget = nTarget;
-                BigNum bnTargetLimit = NetInfo.GetProofOfStakeLimit(0, nTime);
+            BigNum bnLowerBound = CTransaction.nCent, // Lower interest bound is 1% per year
+                bnUpperBound = bnRewardCoinYearLimit, // Upper interest bound is 100% per year
+                bnMidPart, bnRewardPart;
 
-                // NovaCoin: A reasonably continuous curve is used to avoid shock to market
+            while (bnLowerBound + CTransaction.nCent <= bnUpperBound)
+            {
+                BigNum bnMidValue = (bnLowerBound + bnUpperBound) / 2;
 
-                BigNum bnLowerBound = CTransaction.nCent, // Lower interest bound is 1% per year
-                    bnUpperBound = bnRewardCoinYearLimit, // Upper interest bound is 100% per year
-                    bnMidPart, bnRewardPart;
+                // Reward for coin-year is cut in half every 8x multiply of PoS difficulty
+                //
+                // (nRewardCoinYearLimit / nRewardCoinYear) ** 3 == bnProofOfStakeLimit / bnTarget
+                //
+                // Human readable form: nRewardCoinYear = 1 / (posdiff ^ 1/3)
 
-                while (bnLowerBound + CTransaction.nCent <= bnUpperBound)
-                {
-                    BigNum bnMidValue = (bnLowerBound + bnUpperBound) / 2;
-                    if (nTime < NetInfo.nStakeCurveSwitchTime)
-                    {
-                        //
-                        // Until 20 Oct 2013: reward for coin-year is cut in half every 64x multiply of PoS difficulty
-                        //
-                        // (nRewardCoinYearLimit / nRewardCoinYear) ** 6 == bnProofOfStakeLimit / bnTarget
-                        //
-                        // Human readable form: nRewardCoinYear = 1 / (posdiff ^ 1/6)
-                        //
-
-                        bnMidPart = bnMidValue * bnMidValue * bnMidValue * bnMidValue * bnMidValue * bnMidValue;
-                        bnRewardPart = bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit;
-                    }
-                    else
-                    {
-                        //
-                        // Since 20 Oct 2013: reward for coin-year is cut in half every 8x multiply of PoS difficulty
-                        //
-                        // (nRewardCoinYearLimit / nRewardCoinYear) ** 3 == bnProofOfStakeLimit / bnTarget
-                        //
-                        // Human readable form: nRewardCoinYear = 1 / (posdiff ^ 1/3)
-                        //
-
-                        bnMidPart = bnMidValue * bnMidValue * bnMidValue;
-                        bnRewardPart = bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit;
-                    }
+                bnMidPart = bnMidValue * bnMidValue * bnMidValue;
+                bnRewardPart = bnRewardCoinYearLimit * bnRewardCoinYearLimit * bnRewardCoinYearLimit;
 
-                    if (bnMidPart * bnTargetLimit > bnRewardPart * bnTarget)
-                        bnUpperBound = bnMidValue;
-                    else
-                        bnLowerBound = bnMidValue;
+                if (bnMidPart * bnTargetLimit > bnRewardPart * bnTarget)
+                {
+                    bnUpperBound = bnMidValue;
+                }
+                else
+                {
+                    bnLowerBound = bnMidValue;
                 }
-
-                nRewardCoinYear = bnUpperBound;
-                nRewardCoinYear = Math.Min((nRewardCoinYear / CTransaction.nCent) * CTransaction.nCent, NetInfo.nMaxMintProofOfStake);
-            }
-            else
-            {
-                // Old creation amount per coin-year, 5% fixed stake mint rate
-                nRewardCoinYear = 5 * CTransaction.nCent;
             }
 
-            nSubsidy = nCoinAge * nRewardCoinYear * 33 / (365 * 33 + 8);
+            nRewardCoinYear = bnUpperBound;
+            nRewardCoinYear = Math.Min((nRewardCoinYear / CTransaction.nCent) * CTransaction.nCent, NetInfo.nMaxMintProofOfStake);
 
-            // Set reasonable reward limit for large inputs since 20 Oct 2013
-            //
-            // This will stimulate large holders to use smaller inputs, that's good for the network protection
-            if (NetInfo.nStakeCurveSwitchTime < nTime)
-            {
-                nSubsidy = Math.Min(nSubsidy, nSubsidyLimit);
-            }
+            nSubsidy = nCoinAge * nRewardCoinYear * 33 / (365 * 33 + 8);
 
-            return nSubsidy;
+            // Set reasonable reward limit for large inputs
+            // This will stimulate large holders to use smaller inputs, that's good 
+            //   for the network protection
+            return Math.Min(nSubsidy, nSubsidyLimit);
         }
 
         public Tuple<COutPoint, uint> ProofOfStake

diff --git a/Novacoin/CBlockStore.cs b/Novacoin/CBlockStore.cs
index 1861ef2..62a021f 100644 (file)
--- a/Novacoin/CBlockStore.cs
+++ b/Novacoin/CBlockStore.cs
@@ -970,20 +970,22 @@ namespace Novacoin
 
                 if (tx.IsCoinStake)
                 {
-                    // Coin stake tx earns reward instead of paying fee
-                    long nCoinAge;
-                    if (!tx.GetCoinAge(ref inputs, out nCoinAge))
+                    if (HashCheckpoints.LastCheckpointTime < tx.nTime)
                     {
-                        return false; // unable to get coin age for coinstake
-                    }
-
-                    long nReward = tx.nValueOut - nValueIn;
+                        // Coin stake tx earns reward instead of paying fee
+                        long nCoinAge;
+                        if (!tx.GetCoinAge(ref inputs, out nCoinAge))
+                        {
+                            return false; // unable to get coin age for coinstake
+                        }
 
-                    long nCalculatedReward = CBlock.GetProofOfStakeReward(nCoinAge, cursorBlock.nBits, tx.nTime) - tx.GetMinFee(1, false, CTransaction.MinFeeMode.GMF_BLOCK) + CTransaction.nCent;
+                        long nReward = tx.nValueOut - nValueIn;
+                        long nCalculatedReward = CBlock.GetProofOfStakeReward(nCoinAge, cursorBlock.nBits, tx.nTime) - tx.GetMinFee(1, false, CTransaction.MinFeeMode.GMF_BLOCK) + CTransaction.nCent;
 
-                    if (nReward > nCalculatedReward)
-                    {
-                        return false; // coinstake pays too much
+                        if (nReward > nCalculatedReward)
+                        {
+                            return false; // coinstake pays too much
+                        }
                     }
                 }
                 else

diff --git a/Novacoin/CTransaction.cs b/Novacoin/CTransaction.cs
index 3434842..6d0b6eb 100644 (file)
--- a/Novacoin/CTransaction.cs
+++ b/Novacoin/CTransaction.cs
@@ -627,12 +627,6 @@ namespace Novacoin
                 // Enforce 0.01 as minimum fee for old approach or coinstake
                 nMinTxFee = nCent;
                 nMinRelayTxFee = nCent;
-
-                if (nTime < NetInfo.nStakeValidationSwitchTime)
-                {
-                    // Enforce zero size for compatibility with old blocks.
-                    nBytes = 0;
-                }
             }
 
             // Base fee is either nMinTxFee or nMinRelayTxFee

diff --git a/Novacoin/NetInfo.cs b/Novacoin/NetInfo.cs
index 96cf321..97d83e8 100644 (file)
--- a/Novacoin/NetInfo.cs
+++ b/Novacoin/NetInfo.cs
@@ -51,16 +51,6 @@
         public const uint nStakeValidationSwitchTime = 1408492800;
 
         /// <summary>
-        /// Thu, 20 Jun 2013 00:00:00 GMT
-        /// </summary>
-        public const uint nDynamicStakeRewardTime = 1371686400;
-
-        /// <summary>
-        /// Sun, 20 Oct 2013 00:00:00 GMT
-        /// </summary>
-        public const uint nStakeCurveSwitchTime = 1382227200;
-
-        /// <summary>
         /// Hash of block #0
         /// </summary>
         public static uint256 nHashGenesisBlock = new uint256("00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");