Merge pull request #140 from pegnet/feature/PIP-14

Feature/pip 14

Author: StarNeit

go.mod

@@ -6,7 +6,7 @@ require (
 	github.com/AdamSLevy/jsonrpc2/v13 v13.0.1
 	github.com/Factom-Asset-Tokens/factom v0.0.0-20191114224337-71de98ff5b3e
 	github.com/mattn/go-sqlite3 v1.11.0
-	github.com/pegnet/pegnet v0.5.1-0.20200723222201-c2cae6127a81
+	github.com/pegnet/pegnet v0.5.1-0.20200817185314-09e233fbd64d // this is staging branch of pegnet
 	github.com/rs/cors v1.7.0
 	github.com/sirupsen/logrus v1.4.2
 	github.com/spf13/cobra v0.0.5

go.sum

@@ -254,6 +254,8 @@ github.com/pegnet/pegnet v0.4.1-0.20200203165724-3fc45a9a417a h1:JWKI8cKFamD9yYr
 github.com/pegnet/pegnet v0.4.1-0.20200203165724-3fc45a9a417a/go.mod h1:Fy8Qohe9zIuqO9Q/ZOLUNpP2kuiFqxjevzaS3IL62+E=
 github.com/pegnet/pegnet v0.5.1-0.20200723222201-c2cae6127a81 h1:CPsIntmwrXaKJSXnxT3vP3iK3KQ9ZVLOHD7e6HXICOo=
 github.com/pegnet/pegnet v0.5.1-0.20200723222201-c2cae6127a81/go.mod h1:Fy8Qohe9zIuqO9Q/ZOLUNpP2kuiFqxjevzaS3IL62+E=
+github.com/pegnet/pegnet v0.5.1-0.20200817185314-09e233fbd64d h1:bvSLli3ILdKD6bGmu8memh1+QY3KIrJ3OtvOm/tpKwo=
+github.com/pegnet/pegnet v0.5.1-0.20200817185314-09e233fbd64d/go.mod h1:Fy8Qohe9zIuqO9Q/ZOLUNpP2kuiFqxjevzaS3IL62+E=
 github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0=

node/node.go

@@ -17,6 +17,7 @@ import (
 
 var (
 	OPRChain         = factom.NewBytes32("a642a8674f46696cc47fdb6b65f9c87b2a19c5ea8123b3d2f0c13b6f33a9d5ef")
+	SPRChain         = factom.NewBytes32("d5e395125335a21cef0ceca528168e87fe929fdac1f156870c1b1be6502448b4")
 	TransactionChain = factom.NewBytes32("cffce0f409ebba4ed236d49d89c70e4bd1f1367d86402a3363366683265a242d")
 
 	// Acivation Heights

node/pegnet/addresses.go

@@ -1,6 +1,7 @@
 package pegnet
 
 import (
+	"bytes"
 	"database/sql"
 	"fmt"
 	"strings"
@@ -438,6 +439,29 @@ type BalancesPair struct {
 	Balances []uint64
 }
 
+func (p *Pegnet) IsIncludedTopPEGAddress(address []byte) bool {
+	count := 100 // Top 100 addresses
+	stmtStringFmt := `SELECT address, %[1]s_balance FROM pn_addresses WHERE %[1]s_balance > 0 ORDER BY %[1]s_balance DESC LIMIT ?;`
+	stmt := fmt.Sprintf(stmtStringFmt, strings.ToLower("PEG"))
+	rows, err := p.DB.Query(stmt, count)
+	if err != nil {
+		return false
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var Balance uint64
+		var adr []byte
+		if err := rows.Scan(&adr, &Balance); err != nil {
+			return false
+		}
+		if bytes.Equal(address, adr) {
+			return true
+		}
+	}
+	return false
+}
+
 // SelectRichList returns the balance of all addresses for a given ticker
 func (p *Pegnet) SelectRichList(ticker fat2.PTicker, count int) ([]BalancePair, error) {
 	if ticker <= fat2.PTickerInvalid || fat2.PTickerMax <= ticker {

node/pegnet/txhistory.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/Factom-Asset-Tokens/factom"
 	"github.com/pegnet/pegnet/modules/grader"
+	"github.com/pegnet/pegnet/modules/graderStake"
 	"github.com/pegnet/pegnetd/fat/fat2"
 	log "github.com/sirupsen/logrus"
 )
@@ -386,6 +387,45 @@ func (p *Pegnet) InsertCoinbase(tx *sql.Tx, winner *grader.GradingOPR, addr []by
 	return nil
 }
 
+// InsertCoinbase inserts the payouts from staking into the history system.
+// There is one transaction per winning SPR, with the entry hash pointing to that specific spr
+func (p *Pegnet) InsertStaking100Coinbase(tx *sql.Tx, winner *graderStake.GradingSPR, addr []byte, timestamp time.Time) error {
+	stmt, err := tx.Prepare(`INSERT INTO "pn_history_txbatch"
+                (entry_hash, height, blockorder, timestamp, executed) VALUES
+                (?, ?, ?, ?, ?)`)
+	if err != nil {
+		return err
+	}
+
+	lookup, err := tx.Prepare(insertLookupQuery)
+	if err != nil {
+		return err
+	}
+
+	_, err = stmt.Exec(winner.EntryHash, winner.SPR.GetHeight(), 0, timestamp.Unix(), winner.SPR.GetHeight())
+	if err != nil {
+		return err
+	}
+
+	coinbaseStatement, err := tx.Prepare(`INSERT INTO "pn_history_transaction"
+                (entry_hash, tx_index, action_type, from_address, from_asset, from_amount, to_asset, to_amount, outputs) VALUES
+                (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+	if err != nil {
+		return err
+	}
+
+	_, err = coinbaseStatement.Exec(winner.EntryHash, 0, Coinbase, addr, "", 0, "PEG", winner.Payout(), "")
+	if err != nil {
+		return err
+	}
+
+	if _, err = lookup.Exec(winner.EntryHash, 0, addr); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // InsertStakingCoinbase inserts the payouts from mining into the history system.
 // There is one transaction per winning OPR, with the entry hash pointing to that specific opr
 func (p *Pegnet) InsertStakingCoinbase(tx *sql.Tx, txid string, height uint32, heightTimestamp time.Time, payouts map[string]uint64, addressMap map[string]factom.FAAddress) error {

node/spr.go

@@ -0,0 +1,49 @@
+package node
+
+import (
+	"context"
+	"fmt"
+	"github.com/Factom-Asset-Tokens/factom"
+	"github.com/pegnet/pegnet/modules/graderStake"
+)
+
+// Grade Staking Price Records
+func (d *Pegnetd) GradeS(ctx context.Context, block *factom.EBlock) (graderStake.GradedBlock, error) {
+	if block == nil {
+		// TODO: Handle the case where there is no opr block.
+		// 		Must delay conversions if this- happens
+		return nil, nil
+	}
+
+	if *block.ChainID != SPRChain {
+		return nil, fmt.Errorf("trying to grade a non-spr chain")
+	}
+
+	ver := uint8(5)
+	if block.Height >= V20HeightActivation {
+		ver = 5
+	}
+
+	g, err := graderStake.NewGrader(ver, int32(block.Height))
+	if err != nil {
+		return nil, err
+	}
+	for _, entry := range block.Entries {
+		extids := make([][]byte, len(entry.ExtIDs))
+		for i := range entry.ExtIDs {
+			extids[i] = entry.ExtIDs[i]
+		}
+		// allow only top 100 stake holders submit prices
+		stakerRCD := extids[1]
+		if d.Pegnet.IsIncludedTopPEGAddress(stakerRCD) {
+			// ignore bad opr errors
+			err = g.AddSPR(entry.Hash[:], extids, entry.Content)
+			if err != nil {
+				// This is a noisy debug print
+				//logrus.WithError(err).WithFields(logrus.Fields{"hash": entry.Hash.String()}).Debug("failed to add spr")
+			}
+		}
+	}
+
+	return g.Grade(), nil
+}

node/sync.go

@@ -11,6 +11,8 @@ import (
 	"github.com/Factom-Asset-Tokens/factom"
 	"github.com/pegnet/pegnet/modules/conversions"
 	"github.com/pegnet/pegnet/modules/grader"
+	"github.com/pegnet/pegnet/modules/graderStake"
+	"github.com/pegnet/pegnet/modules/opr"
 	"github.com/pegnet/pegnet/modules/transactionid"
 	"github.com/pegnet/pegnetd/config"
 	"github.com/pegnet/pegnetd/fat/fat2"
@@ -247,43 +249,94 @@ func (d *Pegnetd) SyncBlock(ctx context.Context, tx *sql.Tx, height uint32) erro
 			return err
 		}
 	}
+	sprEBlock := dblock.EBlock(SPRChain)
+	if sprEBlock != nil {
+		if err := multiFetch(sprEBlock, d.FactomClient); err != nil {
+			return err
+		}
+	}
 
 	// Then, grade the new OPR Block. The results of this will be used
 	// to execute conversions that are in holding.
 	gradedBlock, err := d.Grade(ctx, oprEBlock)
-	if err != nil {
-		return err
-	} else if gradedBlock != nil {
-		err = d.Pegnet.InsertGradeBlock(tx, oprEBlock, gradedBlock)
+	gradedSPRBlock, err_s := d.GradeS(ctx, sprEBlock)
+	isRatesAvailable := false
+	if height < V20HeightActivation {
 		if err != nil {
 			return err
 		}
-		winners := gradedBlock.Winners()
-		if 0 < len(winners) {
-			// PEG has 3 current pricing phases
-			// 1: Price is 0
-			// 2: Price is determined by equation
-			// 3: Price is determine by miners
-			var phase pegnet.PEGPricingPhase
-			if height < PEGPricingActivation {
-				phase = pegnet.PEGPriceIsZero
-			}
-			if height >= PEGPricingActivation {
-				phase = pegnet.PEGPriceIsEquation
+		isRatesAvailable = gradedBlock != nil && 0 < len(gradedBlock.Winners())
+		if gradedBlock != nil {
+			err = d.Pegnet.InsertGradeBlock(tx, oprEBlock, gradedBlock)
+			if err != nil {
+				return err
 			}
-			if height >= PEGFreeFloatingPriceActivation {
-				phase = pegnet.PEGPriceIsFloating
+			winners := gradedBlock.Winners()
+			if 0 < len(winners) {
+				// PEG has 3 current pricing phases
+				// 1: Price is 0
+				// 2: Price is determined by equation
+				// 3: Price is determine by miners
+				var phase pegnet.PEGPricingPhase
+				if height < PEGPricingActivation {
+					phase = pegnet.PEGPriceIsZero
+				}
+				if height >= PEGPricingActivation {
+					phase = pegnet.PEGPriceIsEquation
+				}
+				if height >= PEGFreeFloatingPriceActivation {
+					phase = pegnet.PEGPriceIsFloating
+				}
+
+				err = d.Pegnet.InsertRates(tx, height, winners[0].OPR.GetOrderedAssetsUint(), phase)
+				if err != nil {
+					return err
+				}
+			} else {
+				fLog.WithFields(log.Fields{"section": "grading", "reason": "no winners"}).Tracef("block not graded")
 			}
+		} else {
+			fLog.WithFields(log.Fields{"section": "grading", "reason": "no graded block"}).Tracef("block not graded")
+		}
+	} else {
+		if err != nil {
+			return err
+		}
+		if err_s != nil {
+			return err_s
+		}
+		// 1. Determine the rates from 2 OPRs (OPR, SPR)
+		// 2. Insert rates to DB
+		var oprWinners []opr.AssetUint
+		var sprWinners []opr.AssetUint
 
-			err = d.Pegnet.InsertRates(tx, height, winners[0].OPR.GetOrderedAssetsUint(), phase)
+		if gradedBlock != nil {
+			winnersOpr := gradedBlock.Winners()
+			if 0 < len(winnersOpr) {
+				oprWinners = winnersOpr[0].OPR.GetOrderedAssetsUint()
+			}
+		}
+		if gradedSPRBlock != nil {
+			winnersSpr := gradedSPRBlock.Winners()
+			if 0 < len(winnersSpr) {
+				sprWinners = winnersSpr[0].SPR.GetOrderedAssetsUint()
+			}
+		}
+		if 0 < len(oprWinners) || 0 < len(sprWinners) {
+			filteredRates, errRate := d.GetAssetRates(oprWinners, sprWinners)
+			if errRate != nil {
+				return err
+			}
+			isRatesAvailable = true
+			var phase pegnet.PEGPricingPhase
+			phase = pegnet.PEGPriceIsFloating
+			err = d.Pegnet.InsertRates(tx, height, filteredRates, phase)
 			if err != nil {
 				return err
 			}
 		} else {
-			fLog.WithFields(log.Fields{"section": "grading", "reason": "no winners"}).Tracef("block not graded")
+			fLog.WithFields(log.Fields{"section": "grading", "reason": "no winners from OPR & SPR"}).Tracef("block not graded")
 		}
-	} else {
-		fLog.WithFields(log.Fields{"section": "grading", "reason": "no graded block"}).Tracef("block not graded")
 	}
 
 	// Only apply transactions if we crossed the activation
@@ -324,7 +377,7 @@ func (d *Pegnetd) SyncBlock(ctx context.Context, tx *sql.Tx, height uint32) erro
 		// At this point, we start making updates to the database in a specific order:
 		// TODO: ensure we rollback the tx when needed
 		// 1) Apply transaction batches that are in holding (conversions are always applied here)
-		if gradedBlock != nil && 0 < len(gradedBlock.Winners()) {
+		if isRatesAvailable {
 			// Before conversions can be run, we have to adjust and discover the bank's value.
 			// We also only sync the bank if the block is a pegnet block
 			if err := d.SyncBank(ctx, tx, height); err != nil {
@@ -362,7 +415,17 @@ func (d *Pegnetd) SyncBlock(ctx context.Context, tx *sql.Tx, height uint32) erro
 		}
 	}
 
-	// 5) Apply Developers Rewards
+	if height >= V20HeightActivation {
+		// 5) Apply effects of graded SPR Block (PEG rewards, if any)
+		//    These funds will be available for transactions and conversions executed in the next block
+		if gradedSPRBlock != nil {
+			if err := d.ApplyGradedSPRBlock(tx, gradedSPRBlock, dblock.Timestamp); err != nil {
+				return err
+			}
+		}
+	}
+
+	// 6) Apply Developers Rewards
 	if height >= V20HeightActivation && height%pegnet.SnapshotRate == 0 {
 		err := d.DevelopersPayouts(tx, fLog, height, dblock.Timestamp, DeveloperRewardAddreses)
 		if err != nil {
@@ -1088,6 +1151,34 @@ func (d *Pegnetd) ApplyGradedOPRBlock(tx *sql.Tx, gradedBlock grader.GradedBlock
 	return nil
 }
 
+// ApplyGradedOPRBlock pays out PEG to the winners of the given GradedBlock.
+// If an error is returned, the sql.Tx should be rolled back by the caller.
+func (d *Pegnetd) ApplyGradedSPRBlock(tx *sql.Tx, gradedSPRBlock graderStake.GradedBlock, timestamp time.Time) error {
+	winners := gradedSPRBlock.Winners()
+	for i := range winners {
+		addr, err := factom.NewFAAddress(winners[i].SPR.GetAddress())
+		if err != nil {
+			// TODO: This is kinda an odd case. I think we should just drop the rewards
+			// 		for an invalid address. We can always add back the rewards and they will have
+			//		a higher balance after a change.
+			log.WithError(err).WithFields(log.Fields{
+				"height": winners[i].SPR.GetHeight(),
+				"ehash":  fmt.Sprintf("%x", winners[i].EntryHash),
+			}).Warnf("failed to reward")
+			continue
+		}
+
+		if _, err := d.Pegnet.AddToBalance(tx, &addr, fat2.PTickerPEG, uint64(winners[i].Payout())); err != nil {
+			return err
+		}
+
+		if err := d.Pegnet.InsertStaking100Coinbase(tx, winners[i], addr[:], timestamp); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func isDone(ctx context.Context) bool {
 	select {
 	case <-ctx.Done():
@@ -1096,3 +1187,40 @@ func isDone(ctx context.Context) bool {
 		return false
 	}
 }
+
+func (d *Pegnetd) GetAssetRates(oprWinners []opr.AssetUint, sprWinners []opr.AssetUint) ([]opr.AssetUint, error) {
+	if 0 < len(oprWinners) && 0 == len(sprWinners) {
+		return oprWinners, nil
+	}
+	if 0 == len(oprWinners) && 0 < len(sprWinners) {
+		return sprWinners, nil
+	}
+	if 0 < len(oprWinners) && 0 < len(sprWinners) {
+		// 1) sprWinners determine tolerance range
+		// 2) oprWinners set the real rates
+		if len(oprWinners) != len(sprWinners) {
+			return nil, fmt.Errorf("SPR & OPR use different assets version")
+		}
+
+		var filteredRates []opr.AssetUint
+		for i := range oprWinners {
+			if oprWinners[i].Name == sprWinners[i].Name {
+				sprRate := sprWinners[i].Value
+				oprRate := oprWinners[i].Value
+				toleranceRate := 0.01 // 1% band
+				if sprRate >= 100000 {
+					toleranceRate = 0.001 // 0.1% band
+				}
+				toleranceBandHigh := float64(sprRate) * (1 + toleranceRate)
+				toleranceBandLow := float64(sprRate) * (1 - toleranceRate)
+				if (float64(oprRate) >= toleranceBandLow) && (float64(oprRate) <= toleranceBandHigh) {
+					filteredRates = append(filteredRates, oprWinners[i])
+				} else {
+					return nil, fmt.Errorf("opr is out side of tolerance band")
+				}
+			}
+		}
+		return filteredRates, nil
+	}
+	return nil, fmt.Errorf("no winners")
+}