PIP 14

- Grade Staking Price Records
- IsIncludedTopPEGAddress (top 100)
- Getting Winner from OPR & SPR

Author: StarNeit

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,50 @@
+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) {
+			return nil, fmt.Errorf("trying to submit without enough peg. only top 100 peg holders can submit prices")
+		}
+		// 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"
@@ -257,11 +259,14 @@ func (d *Pegnetd) SyncBlock(ctx context.Context, tx *sql.Tx, height uint32) erro
 	// 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)
-	gradedSPRBlock, err_s := d.Grade(ctx, sprEBlock)
-	if err != nil {
-		return err
-	} else if gradedBlock != nil {
-		if height < V20HeightActivation {
+	gradedSPRBlock, err_s := d.GradeS(ctx, sprEBlock)
+	isRatesAvailable := false
+	if height < V20HeightActivation {
+		if err != nil {
+			return err
+		}
+		isRatesAvailable = gradedBlock != nil && 0 < len(gradedBlock.Winners())
+		if gradedBlock != nil {
 			err = d.Pegnet.InsertGradeBlock(tx, oprEBlock, gradedBlock)
 			if err != nil {
 				return err
@@ -291,15 +296,47 @@ func (d *Pegnetd) SyncBlock(ctx context.Context, tx *sql.Tx, height uint32) erro
 				fLog.WithFields(log.Fields{"section": "grading", "reason": "no winners"}).Tracef("block not graded")
 			}
 		} else {
-			if err_s != nil {
-				return err_s
-			}
-			// Todo:
-			// 1. Determine the rate from 3 OPRs (OPR, SPR, DPR)
-			// 2. Insert rate to DB
+			fLog.WithFields(log.Fields{"section": "grading", "reason": "no graded block"}).Tracef("block not graded")
 		}
 	} else {
-		fLog.WithFields(log.Fields{"section": "grading", "reason": "no graded block"}).Tracef("block not graded")
+		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
+
+		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 from OPR & SPR"}).Tracef("block not graded")
+		}
 	}
 
 	// Only apply transactions if we crossed the activation
@@ -340,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 {
@@ -382,7 +419,7 @@ func (d *Pegnetd) SyncBlock(ctx context.Context, tx *sql.Tx, height uint32) erro
 		// 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.ApplyGradedOPRBlock(tx, gradedSPRBlock, dblock.Timestamp); err != nil {
+			if err := d.ApplyGradedSPRBlock(tx, gradedSPRBlock, dblock.Timestamp); err != nil {
 				return err
 			}
 		}
@@ -1114,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():
@@ -1122,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 {
+					filteredRates = append(filteredRates, sprWinners[i])
+				}
+			}
+		}
+		return filteredRates, nil
+	}
+	return nil, fmt.Errorf("no winners")
+}