Added a rate sampling threshhold to allow averaging with missing rates to avoid really long conversion stalls

Author: PaulSnow

node/average.go

@@ -6,7 +6,8 @@ import (
 	"github.com/pegnet/pegnetd/fat/fat2"
 )
 
-const AveragePeriod = uint64(288) // Our Average Period is 2 days (144 10 minute blocks per day)
+const AveragePeriod = uint64(288)         // Our Average Period is 2 days (144 10 minute blocks per day)
+const AverageRequired = AveragePeriod / 2 // If we have at least half the rates, we can do conversions
 
 // getPegNetRateAverages
 // Gets all the rates for the AveragePeriod (the number of blocks contributing to the average), and computes
@@ -55,14 +56,14 @@ func (d *Pegnetd) GetPegNetRateAverages(ctx context.Context, height uint32) (Avg
 	}
 
 	for k, v := range ratesOverPeriod { //                      When we average the rates, we return a zero for
-		averages[k] = 0                      //                   any asset that doesn't have a rate in all blocks
-		if uint64(len(v)) != AveragePeriod { //                 We can see missing rates because the list isn't
-			continue //                                           long enough.  Just skip it, it will be zero
+		averages[k] = 0                       //                  any asset that doesn't have a rate in all blocks
+		if uint64(len(v)) < AverageRequired { //                We can see missing rates because the list isn't
+			continue //                                           long enough. Too many missing rates, and we skip it
 		}
 		for _, v2 := range v { //                               Sum up all the rates found for an asset
-			averages[k] += v2
-		}
-		averages[k] = averages[k] / AveragePeriod //            We made sure all valid assets have AveragePeriod rates
+			averages[k] += v2 //                                The assumption is that rates are no where near
+		} //                                                       64 bits, so they won't overflow
+		averages[k] = averages[k] / uint64(len(v)) // Divide the sum of the rates by the number of rates
 	}
 
 	return averages // Return the rates we found.

node/conversions/conversions.go

@@ -7,28 +7,45 @@ import (
 	"github.com/pegnet/pegnetd/config"
 )
 
-// Convert takes an input amount and returns an output amount that can be created
+// Convert
+// takes an input amount and returns an output amount that can be created
 // from it, given the two rates `fromRate` and `toRate` denominated in 1e-8 USD.
 // All parameters must be in their lowest divisible unit as whole numbers.
-//  X fromType -> ?? toType
 //
-//  X fromType     fromRate USD      1 toType
-//  ----------  *  ------------  *  ----------  =  ?? toType
+// Prior to PIP-10:
+//  RateSource = fromRate
+//  RateDest = toRate
+//
+// Under PIP-10:
+//  RateSource = min(fromRate, fromAvg)
+//  RateDest = max(toRate, toAvg)
+//
+//  A Source Tokens
+//  X Destination Tokens
+//
+//     A           fromRate USD         1
+//  ----------  *  ------------  *  ----------  =  X
 //     1            1 fromType      toRate USD
+//
 func Convert(height uint32, amount int64, fromRate, fromAvg, toRate, toAvg uint64) (int64, error) {
-	if amount < 0 {
-		return 0, fmt.Errorf("invalid amount: must be greater than or equal to zero")
-	}
-	if fromRate == 0 || toRate == 0 {
-		return 0, fmt.Errorf("invalid rate: 0")
+	if amount < 0 { //                                           Must have something to convert; negative numbers
+		return 0, fmt.Errorf("invalid amount: must be greater than or equal to zero") // do not qualify
 	}
 
-	if height >= config.PIP10AverageActivation {
-		if fromRate > fromAvg {
-			fromRate = fromAvg
+	if fromRate == 0 || toRate == 0 { //                         If either rate (fromRate or toRate) is zero
+		return 0, fmt.Errorf("invalid rate: 0") //                  then we can't do the conversion
+	}
+	RateSource := fromRate
+	RateDest := toRate
+	if height >= config.PIP10AverageActivation { //              Check that PIP-10 has been activated.
+		if fromAvg == 0 || toAvg == 0 { //                       If either Average (fromAvg or toAvg) is zero
+			return 0, fmt.Errorf("invalid rate: 0") //              then we can't do the conversion
+		}
+		if fromRate > fromAvg { //                               Use the min(fromRate, fromAvg)
+			RateSource = fromAvg
 		}
-		if toRate < toAvg {
-			toRate = toAvg
+		if toRate < toAvg { //                                   Use the max(toRate,toAvg)
+			RateDest = toAvg
 		}
 	}
 
@@ -37,8 +54,8 @@ func Convert(height uint32, amount int64, fromRate, fromAvg, toRate, toAvg uint6
 	// accuracy a miner reports. Anything beyond the 8th decimal point, we cannot account for.
 	//
 	// Uses big ints to avoid overflows.
-	fr := new(big.Int).SetUint64(fromRate)
-	tr := new(big.Int).SetUint64(toRate)
+	fr := new(big.Int).SetUint64(RateSource)
+	tr := new(big.Int).SetUint64(RateDest)
 	amt := big.NewInt(amount)
 
 	// Now we can run the conversion