Merge branch 'staging' into sb/features/pip-0016-developer-rewards

Author: sigrlami

node/burns.go

@@ -1,10 +1,21 @@
 package node
 
-import "encoding/hex"
+import (
+	"encoding/hex"
+
+	"github.com/Factom-Asset-Tokens/factom"
+)
 
 var (
 	// BurnAddress is the mainnet burn address
 	BurnAddress = "EC2BURNFCT2PEGNETooo1oooo1oooo1oooo1oooo1oooo19wthin"
+
+	// BurnAddress that can be used for all assets
+	GlobalBurnAddress = "FA2BURNBABYBURNoooooooooooooooooooooooooooooooDGvNXy"
+
+	// Global Burn Address as proper FAAddress
+	FAGlobalBurnAddress factom.FAAddress
+
 	// BurnRCD is the rcd representation of the burn address
 	BurnRCD = [32]byte{}
 )

node/node.go

@@ -110,6 +110,18 @@ func NewPegnetd(ctx context.Context, conf *viper.Viper) (*Pegnetd, error) {
 		}
 	}
 
+	// init burn address
+	FAGlobalBurnAddress, err := factom.NewFAAddress(GlobalBurnAddress)
+	if err != nil {
+		log.WithFields(log.Fields{
+			"error": err,
+		}).Info("error getting burn address")
+	}
+
+	log.WithFields(log.Fields{
+		"addr": FAGlobalBurnAddress,
+	}).Info("burn address loaded")
+
 	grader.InitLX()
 	return n, nil
 }

node/pegnet/txhistory.go

@@ -509,3 +509,63 @@ func (p *Pegnet) InsertDeveloperRewardCoinbase(tx *sql.Tx, txid string, addTxid
 
 	return nil
 }
+
+// Special construction to nullify burn address
+func (p *Pegnet) InsertZeroingCoinbase(tx *sql.Tx, txid string, addTxid string, height uint32, heightTimestamp time.Time, payout uint64, asset string, faAdd factom.FAAddress) error {
+	txidBytes, err := hex.DecodeString(txid)
+	if err != nil {
+		return err
+	}
+
+	// 	First we need to record the batch. The batch is the entire set of transactions, where
+	// 	each tx is a stake payout.
+	stmt, err := tx.Prepare(`INSERT INTO "pn_history_txbatch"
+                (entry_hash, height, blockorder, timestamp, executed) VALUES
+                (?, ?, ?, ?, ?)`)
+	if err != nil {
+		return err
+	}
+
+	// The Entryhash is the custom txid, it is not an actual entry on chain
+	// The executed height is the same height as the recorded.
+	_, err = stmt.Exec(txidBytes, height, 0, heightTimestamp.Unix(), height)
+	if err != nil {
+		return err
+	}
+
+	// Now we record balance zeroing .
+
+	// All addresses are stored as bytes in the sqlitedb
+	add := faAdd[:]
+	// index for the address
+	index, _, err := SplitTxID(txid)
+	if err != nil {
+		return err
+	}
+
+	// Decrease each balance as a coinbase.
+	// Insert the TX
+	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(txidBytes, index, Coinbase, add, "", 0, asset, -payout, "") // -payout means we substract value
+	if err != nil {
+		return err
+	}
+
+	// Insert into lookup table
+	lookup, err := tx.Prepare(insertLookupQuery)
+	if err != nil {
+		return err
+	}
+
+	if _, err = lookup.Exec(txidBytes, index, add); err != nil {
+		return err
+	}
+
+	return nil
+}

node/sync.go

@@ -27,6 +27,7 @@ func (d *Pegnetd) GetCurrentSync() uint32 {
 func (d *Pegnetd) DBlockSync(ctx context.Context) {
 	retryPeriod := d.Config.GetDuration(config.DBlockSyncRetryPeriod)
 	isFirstSync := true
+
 OuterSyncLoop:
 	for {
 		if isDone(ctx) {
@@ -85,6 +86,16 @@ OuterSyncLoop:
 				hLog.WithError(err).Errorf("failed to start transaction")
 				continue
 			}
+
+			////////////////////////
+			// Zeroing funds at Global Burn Address
+
+			// One time operation, Inserts negative balance for the burn address that used during the attack
+			// We need to do this before main logic because sqlite db will be locked
+			if d.Sync.Synced+1 == V20HeightActivation {
+				d.NullifyBurnAddress(ctx, tx, d.Sync.Synced+1)
+			}
+
 			// We are not synced, so we need to iterate through the dblocks and sync them
 			// one by one. We can only sync our current synced height +1
 			// TODO: This skips the genesis block. I'm sure that is fine
@@ -157,6 +168,57 @@ OuterSyncLoop:
 
 }
 
+func (d *Pegnetd) NullifyBurnAddress(ctx context.Context, tx *sql.Tx, height uint32) error {
+	fLog := log.WithFields(log.Fields{"height": height})
+
+	dblock := new(factom.DBlock)
+	dblock.Height = height
+	if err := dblock.Get(nil, d.FactomClient); err != nil {
+		return err
+	}
+	heightTimestamp := dblock.Timestamp
+	// We need to mock a TXID to record zeroing
+	txid := fmt.Sprintf("%064d", height)
+
+	// 1. check current balance
+	// 2. substract amounts for every ticker
+
+	// Get all balances for the address
+	balances, err := d.Pegnet.SelectBalances(&FAGlobalBurnAddress)
+
+	if err != nil {
+		fLog.WithFields(log.Fields{
+			"err": err,
+		}).Info("zeroing burn | balances retrieval failed")
+	}
+
+	for ticker := fat2.PTickerInvalid + 1; ticker < fat2.PTickerMax; ticker++ {
+		// Substract from every issuance
+		value, _ := balances[ticker]
+		_, _, err := d.Pegnet.SubFromBalance(tx, &FAGlobalBurnAddress, ticker, value) // lastInd, txErr, err
+		if err != nil {
+			fLog.WithFields(log.Fields{
+				"ticker":  ticker,
+				"balance": value,
+			}).Info("zeroing burn | substract from balance failed")
+		}
+
+		// Mock entry hash value
+		addTxid := fmt.Sprintf("%d-%s", ticker, txid)
+
+		err = d.Pegnet.InsertZeroingCoinbase(tx, txid, addTxid, height, heightTimestamp, value, ticker.String(), FAGlobalBurnAddress)
+		if err != nil {
+			fLog.WithFields(log.Fields{
+				"error": err,
+			}).Info("zeroing burn | coinbase tx failed")
+			return err
+		}
+
+	}
+
+	return nil
+}
+
 // If SyncBlock returns no error, than that height was synced and saved. If any part of the sync fails,
 // the whole sync should be rolled back and not applied. An error should then be returned.
 // The context should be respected if it is cancelled
@@ -811,7 +873,8 @@ func (d *Pegnetd) recordBatch(sqlTx *sql.Tx, txBatch *fat2.TransactionBatch, rat
 		}
 
 		// Outputs
-		if tx.IsConversion() { // Conv Output
+		if tx.IsConversion() {
+			// Conversions Output
 			outputAmount, err := conversions.Convert(int64(tx.Input.Amount), rates[tx.Input.Type], rates[tx.Conversion])
 			if err != nil {
 				return err
@@ -820,19 +883,26 @@ func (d *Pegnetd) recordBatch(sqlTx *sql.Tx, txBatch *fat2.TransactionBatch, rat
 			if err = d.Pegnet.SetTransactionHistoryConvertedAmount(sqlTx, txBatch, txIndex, outputAmount); err != nil {
 				return err
 			}
+
 			_, err = d.Pegnet.AddToBalance(sqlTx, &tx.Input.Address, tx.Conversion, uint64(outputAmount))
 			if err != nil {
 				return err
 			}
-		} else { // Transfer Outputs
+
+		} else {
+			// Transfer Outputs
+
 			for _, transfer := range tx.Transfers {
-				_, err = d.Pegnet.AddToBalance(sqlTx, &transfer.Address, tx.Input.Type, transfer.Amount)
-				if err != nil {
-					return err
-				}
-				_, err = d.Pegnet.InsertTransactionRelation(sqlTx, transfer.Address, txBatch.Entry.Hash, uint64(txIndex), true, false)
-				if err != nil {
-					return err
+				// if transfer to Burn address do nothing, otherwise add balances
+				if transfer.Address != FAGlobalBurnAddress {
+					_, err = d.Pegnet.AddToBalance(sqlTx, &transfer.Address, tx.Input.Type, transfer.Amount)
+					if err != nil {
+						return err
+					}
+					_, err = d.Pegnet.InsertTransactionRelation(sqlTx, transfer.Address, txBatch.Entry.Hash, uint64(txIndex), true, false)
+					if err != nil {
+						return err
+					}
 				}
 			}
 		}