Changed convert to consider the average prices of the source and destination assets. Added an activation height for this. Did some minor refactoring

Author: PaulSnow

cmd/api.go

@@ -13,12 +13,13 @@ import (
 	"text/tabwriter"
 	"time"
 
-	"github.com/pegnet/pegnet/modules/conversions"
+	"github.com/pegnet/pegnetd/node"
 
 	"github.com/Factom-Asset-Tokens/factom"
 	"github.com/pegnet/pegnetd/config"
 	"github.com/pegnet/pegnetd/fat/fat2"
-	"github.com/pegnet/pegnetd/node"
+
+	"github.com/pegnet/pegnetd/node/conversions"
 	"github.com/pegnet/pegnetd/node/pegnet"
 	"github.com/pegnet/pegnetd/srv"
 	"github.com/spf13/cobra"
@@ -350,8 +351,8 @@ var conv = &cobra.Command{
 
 		// Let's check the pXXX -> pFCT first
 		status := getStatus()
-		if (destAsset == "pFCT" || destAsset == "FCT") && uint32(status.Current) >= node.OneWaypFCTConversions {
-			cmd.PrintErrln(fmt.Sprintf("pXXX -> pFCT conversions are not allowed since block height %d. If you need to acquire pFCT, you have to burn FCT -> pFCT", node.OneWaypFCTConversions))
+		if (destAsset == "pFCT" || destAsset == "FCT") && uint32(status.Current) >= config.OneWaypFCTConversions {
+			cmd.PrintErrln(fmt.Sprintf("pXXX -> pFCT conversions are not allowed since block height %d. If you need to acquire pFCT, you have to burn FCT -> pFCT", config.OneWaypFCTConversions))
 			os.Exit(1)
 		}
 
@@ -360,8 +361,8 @@ var conv = &cobra.Command{
 		if (destAsset == "PEG" || destAsset == "pDCR" || destAsset == "pDGB" || destAsset == "pDOGE" || destAsset == "pHBAR" ||
 			destAsset == "pONT" || destAsset == "pRVN" || destAsset == "pBAT" || destAsset == "pALGO" || destAsset == "pBIF" ||
 			destAsset == "pETB" || destAsset == "pKES" || destAsset == "pNGN" || destAsset == "pRWF" || destAsset == "pTZS" ||
-			destAsset == "pUGX") && uint32(status.Current) >= node.OneWaySmallAssetsConversions {
-			cmd.PrintErrln(fmt.Sprintf("pXXX -> pSmallAssets conversions are not allowed since block height %d.", node.OneWaySmallAssetsConversions))
+			destAsset == "pUGX") && uint32(status.Current) >= config.OneWaySmallAssetsConversions {
+			cmd.PrintErrln(fmt.Sprintf("pXXX -> pSmallAssets conversions are not allowed since block height %d.", config.OneWaySmallAssetsConversions))
 			os.Exit(1)
 		}
 
@@ -793,7 +794,7 @@ var getBank = &cobra.Command{
 		cl := srv.NewClient()
 		cl.PegnetdServer = viper.GetString(config.Pegnetd)
 		var res pegnet.BankEntry
-		err = cl.Request("get-bank", srv.ParamsGetBank{Height: int32(height)}, &res)
+		err = cl.Request("get-bank", srv.ParamsGetBank{Height: int32(height)}, &res) //TODO: height should be uint32
 		if err != nil {
 			fmt.Printf("Failed to make RPC request\nDetails:\n%v\n", err)
 			os.Exit(1)
@@ -822,9 +823,9 @@ var getBank = &cobra.Command{
 		if err == nil {
 			fmt.Println("")
 			fmt.Println("Value in USD")
-			dAmt, _ := conversions.Convert(res.BankAmount, rates[fat2.PTickerPEG], rates[fat2.PTickerUSD])
-			dUsed, _ := conversions.Convert(res.BankUsed, rates[fat2.PTickerPEG], rates[fat2.PTickerUSD])
-			dReq, _ := conversions.Convert(res.PEGRequested, rates[fat2.PTickerPEG], rates[fat2.PTickerUSD])
+			dAmt, _ := conversions.Convert(uint32(height), res.BankAmount, rates[fat2.PTickerPEG], rates[fat2.PTickerPEG], rates[fat2.PTickerUSD], rates[fat2.PTickerUSD])
+			dUsed, _ := conversions.Convert(uint32(height), res.BankUsed, rates[fat2.PTickerPEG], rates[fat2.PTickerPEG], rates[fat2.PTickerUSD], rates[fat2.PTickerUSD])
+			dReq, _ := conversions.Convert(uint32(height), res.PEGRequested, rates[fat2.PTickerPEG], rates[fat2.PTickerPEG], rates[fat2.PTickerUSD], rates[fat2.PTickerUSD])
 			fmt.Printf("PEG in Bank   : $%s\n", FactoshiToFactoid(dAmt))
 			fmt.Printf("PEG Consumed  : $%s\n", FactoshiToFactoid(dUsed))
 			fmt.Printf("PEG Requested : $%s\n", FactoshiToFactoid(dReq))

cmd/root.go

@@ -149,12 +149,12 @@ func always(cmd *cobra.Command, args []string) {
 		}
 
 		// Set all activations for testing
-		node.SetAllActivations(uint32(act))
+		config.SetAllActivations(uint32(act))
 	}
 
 	if testingact, _ := cmd.Flags().GetInt32("testingact"); testingact >= 0 {
 		fat2.Fat2RCDEActivation = uint32(testingact)
-		node.V20HeightActivation = uint32(testingact)
+		config.V20HeightActivation = uint32(testingact)
 		// Also updaet hardfork
 		pegnet.Hardforks[1].ActivationHeight = uint32(testingact)
 	}

cmd/tx.go

@@ -4,11 +4,12 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/pegnet/pegnetd/config"
+
 	"github.com/spf13/cobra"
 
 	"github.com/Factom-Asset-Tokens/factom"
 	"github.com/pegnet/pegnetd/fat/fat2"
-	"github.com/pegnet/pegnetd/node"
 )
 
 func addressRules(input string, output string) error {
@@ -67,7 +68,7 @@ func signAndSend(source string, tx *fat2.Transaction, cl *factom.Client, payment
 	var txBatch fat2.TransactionBatch
 	txBatch.Version = 1
 	txBatch.Transactions = []fat2.Transaction{*tx}
-	txBatch.Entry.ChainID = &node.TransactionChain
+	txBatch.Entry.ChainID = &config.TransactionChain //TODO consider not passing a pointer to config.TransactionChain
 
 	// Sign the tx and make an entry
 	entry, err := txBatch.Sign(priv)

config/activations.go

@@ -0,0 +1,98 @@
+package config
+
+import (
+	"github.com/Factom-Asset-Tokens/factom"
+	"github.com/pegnet/pegnetd/fat/fat2"
+)
+
+var (
+	OPRChain         = factom.NewBytes32("a642a8674f46696cc47fdb6b65f9c87b2a19c5ea8123b3d2f0c13b6f33a9d5ef")
+	SPRChain         = factom.NewBytes32("d5e395125335a21cef0ceca528168e87fe929fdac1f156870c1b1be6502448b4")
+	TransactionChain = factom.NewBytes32("cffce0f409ebba4ed236d49d89c70e4bd1f1367d86402a3363366683265a242d")
+
+	// Acivation Heights
+
+	PegnetActivation    uint32 = 206421
+	GradingV2Activation uint32 = 210330
+
+	// TransactionConversionActivation indicates when tx/conversions go live on mainnet.
+	// Target Activation Height is Oct 7, 2019 15 UTC
+	TransactionConversionActivation uint32 = 213237
+
+	// This is when PEG is priced by the market cap equation
+	// Estimated to be Oct 14 2019, 15:00:00 UTC
+	PEGPricingActivation uint32 = 214287
+
+	// OneWaypFCTConversions makes pFCT a 1 way conversion. This means pFCT->pXXX,
+	// but no asset can go into pFCT. AKA pXXX -/> pFCT.
+	// The only way to aquire pFCT is to burn FCT. The burn command will remain.
+	// Estimated to be Nov 25, 2019 17:47:00 UTC
+	OneWaypFCTConversions uint32 = 220346
+
+	// Once this is activated, a maximum amount of PEG of 5,000 can be
+	// converted per block. At a future height, a dynamic bank should be used.
+	// Estimated to be  Dec 9, 2019, 17:00 UTC
+	PegnetConversionLimitActivation uint32 = 222270
+
+	// This is when PEG price is determined by the exchange price
+	// Estimated to be  Dec 9, 2019, 17:00 UTC
+	PEGFreeFloatingPriceActivation uint32 = 222270
+
+	// V4OPRUpdate indicates the activation of additional currencies and ecdsa keys.
+	// Estimated to be  Feb 12, 2020, 18:00 UTC
+	V4OPRUpdate uint32 = 231620
+
+	// V20HeightActivation indicates the activation of PegNet 2.0.
+	// Estimated to be  Aug 19th 2020 14:00 UTC
+	V20HeightActivation uint32 = 258796
+
+	// Activation height for developer rewards
+	V20DevRewardsHeightActivation uint32 = 260118
+
+	// SprSignatureActivation indicates the activation of SPR Signature.
+	// Estimated to be  Aug 28th 2020
+	SprSignatureActivation uint32 = 260118
+
+	// OneWaypAssetsConversions makes some pAssets a 1 way conversion.
+	// pDCR, pDGB, pDOGE, pHBAR, pONT, pRVN, pBAT, pALGO, pBIF, pETB, pKES, pNGN, pRWF, pTZS, pUGX
+	// These pAssets have got small marketcap, and these will be disabled for conversion.
+	// Estimated to be Dec 3th 2020
+	OneWaySmallAssetsConversions uint32 = 274036
+
+	// V202EnhanceActivation indicates the activation of PegNet 2.0.2.
+	// Estimated to be  Dec 3th 2020
+	V202EnhanceActivation uint32 = 274036
+
+	// V204EnhanceActivation indicates the activation of PegNet 2.0.4.
+	// Estimated to be  Mar 16th 2021
+	V204EnhanceActivation uint32 = 288878
+
+	// V204EnhanceActivation indicates the activation that burns remaining airdrop amount.
+	// Estimated to be  April 16th 2021
+	V204BurnMintedTokenActivation uint32 = 294206
+
+	// PIP10AveragingActivation changes conversions to use the lesser of a rolling average and market price
+	// for the source of a conversion, and the higher of the rolling average and the market price for the
+	// target of a conversion
+	PIP10AverageActivation uint32 = 300000
+)
+
+func SetAllActivations(act uint32) {
+	PegnetActivation = act
+	GradingV2Activation = act
+	TransactionConversionActivation = act
+	PEGPricingActivation = act
+	OneWaypFCTConversions = act
+	PegnetConversionLimitActivation = act
+	PEGFreeFloatingPriceActivation = act
+	fat2.Fat2RCDEActivation = act
+	V4OPRUpdate = act
+	V20HeightActivation = act
+	V20DevRewardsHeightActivation = act
+	OneWaySmallAssetsConversions = act
+	SprSignatureActivation = act
+	V202EnhanceActivation = act
+	V204EnhanceActivation = act
+	V204BurnMintedTokenActivation = act
+	PIP10AverageActivation = act
+}

go.mod

@@ -19,3 +19,5 @@ replace github.com/Factom-Asset-Tokens/factom => github.com/Emyrk/factom v0.0.0-
 replace crawshaw.io/sqlite => github.com/AdamSLevy/sqlite v0.1.3-0.20191014215059-b98bb18889de
 
 replace github.com/spf13/pflag v1.0.3 => github.com/AdamSLevy/pflag v1.0.4
+
+replace github.com/pegnet/pegnet => ../pegnet

node/average.go

@@ -0,0 +1,69 @@
+package node
+
+import (
+	"context"
+
+	"github.com/pegnet/pegnetd/fat/fat2"
+)
+
+const AveragePeriod = uint64(288) // Our Average Period is 2 days (144 10 minute blocks per day)
+
+// getPegNetRateAverages
+// Gets all the rates for the AveragePeriod (the number of blocks contributing to the average), and computes
+// the average rate for all assets.  If values are missing for an asset for any of the blocks in the AveragePeriod,
+// then don't allow conversions by setting the averate to zero for that asset
+//
+// Return a map of averages of the form map[fat2.PTicker]uint64
+//
+// Also note that if asked twice about the same height, we cache the response.
+func (d *Pegnetd) GetPegNetRateAverages(ctx context.Context, height uint32) (Avg interface{}) {
+
+	if d.LastAveragesHeight == height { //                      If a cache hit is detected, return the cache value
+		return d.LastAverages
+	}
+
+	ratesOverPeriod := map[fat2.PTicker][]uint64{} //           First collect all the values over the blocks
+	averages := map[fat2.PTicker]uint64{}          //             in the average period, then compute the averages
+
+	defer func() { //                                           Always set up the cache when exiting the routine
+		d.LastAveragesHeight = height
+		d.LastAverages = averages
+	}()
+
+	startHeight := height - (uint32(AveragePeriod)) + 1 //      The startHeight is AveragePeriod before height+1
+	//                                                            (add 1 so the block at height is included)
+	if startHeight < 1 { //                                     If AveragePeriod blocks don't exist, then ignore
+		return averages
+	}
+
+	for h := startHeight; height <= height; h++ { //            Collect rates over the blocks (including height)
+		var rates map[fat2.PTicker]uint64 //                    Collect all the rates
+		var err error
+
+		if rates, err = d.Pegnet.SelectRates(ctx, h); err != nil { // Pull the rates out of the database at each
+			return averages //                                          height.  Return averages if an error
+		}
+
+		for k, v := range rates { //                            For all the rates
+			if ratesOverPeriod[k] == nil { //                     if no rates yet, at a slice for them
+				ratesOverPeriod[k] = []uint64{} //              Allocate the slice
+			}
+			if v != 0 { //                                      Only collect non-zero rates
+				ratesOverPeriod[k] = append(ratesOverPeriod[k], v) // Add the rates we find
+			}
+		}
+	}
+
+	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
+		}
+		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
+	}
+
+	return averages // Return the rates we found.
+}