script.go

package upgrademanager

import (
	"encoding/hex"

	"github.com/lbryio/chainquery/daemon/processing"
	"github.com/lbryio/chainquery/lbrycrd"
	"github.com/lbryio/chainquery/model"
	"github.com/lbryio/chainquery/util"

	"github.com/sirupsen/logrus"
	"github.com/volatiletech/sqlboiler/v4/boil"
	"github.com/volatiletech/sqlboiler/v4/queries/qm"
)

func reProcessAllClaims() {
	outputs := model.Outputs(qm.Where(model.OutputColumns.Type+" =?", lbrycrd.NonStandard),
		qm.Select(model.OutputColumns.TransactionHash)).AllGP()
	for i, output := range outputs {
		processClaimOut(i, len(outputs), output.TransactionHash)
	}
}

func processClaimOut(index int, total int, txHash string) {
	tx, err := model.Transactions(qm.Where(model.TransactionColumns.Hash+"=?", txHash),
		qm.Select(model.TransactionColumns.Hash, model.TransactionColumns.BlockHashID)).OneG()
	if err != nil {
		logrus.Panic(err)
	}
	txResult, err := lbrycrd.GetRawTransactionResponse(tx.Hash)
	if err != nil {
		logrus.Panic(err)
	}

	block, err := model.Blocks(qm.Where(model.BlockColumns.Hash+"=?", txResult.BlockHash)).OneG()
	if err != nil {
		logrus.Panic(err)
	}
	if index%50 == 0 {
		logrus.Info("(", index, "/", total, ")", "Processing@Height ", block.Height)
	}

	err = processing.ProcessTx(txResult, block.BlockTime, block.Height)
	if err != nil {
		logrus.Error("Reprocess Claim Error: ", err)
	}
}

func setClaimAddresses() {
	type claimForClaimAddress struct {
		ID              uint64 `boil:"id"`
		ScriptPubKeyHex string `boil:"script_pub_key_hex"`
		ClaimAddress    string `boil:"claim_address"`
	}
	rows, err := boil.GetDB().Query(`
		SELECT claim.id,output.script_pub_key_hex FROM claim
		LEFT JOIN output ON output.transaction_hash = claim.transaction_hash_id AND output.vout = claim.vout
		WHERE claim_address = ''`)

	if err != nil {
		logrus.Panic("Error During Upgrade: ", err)
	}
	defer util.CloseRows(rows)

	var slice []claimForClaimAddress
	for rows.Next() {
		var claimForCA claimForClaimAddress
		err = rows.Scan(&claimForCA.ID, &claimForCA.ScriptPubKeyHex)
		if err != nil {
			logrus.Panic("Error During Upgrade: ", err)
		}
		slice = append(slice, claimForCA)
	}

	for i, claimAddress := range slice {
		if i%1000 == 0 {
			logrus.Info("Processing: ", "(", i, "/", len(slice), ")")
		}
		claim := model.Claim{ID: claimAddress.ID}
		scriptBytes, err := hex.DecodeString(claimAddress.ScriptPubKeyHex)
		if err != nil {
			logrus.Panic("Error During Upgrade: ", err)
		}
		var pkscript []byte
		if lbrycrd.IsClaimScript(scriptBytes) {
			if lbrycrd.IsClaimNameScript(scriptBytes) {
				_, _, pkscript, err = lbrycrd.ParseClaimNameScript(scriptBytes)
			} else if lbrycrd.IsClaimUpdateScript(scriptBytes) {
				_, _, _, pkscript, err = lbrycrd.ParseClaimUpdateScript(scriptBytes)
			} else if lbrycrd.IsClaimSupportScript(scriptBytes) {
				_, _, _, pkscript, err = lbrycrd.ParseClaimSupportScript(scriptBytes)
			} else {
				continue
			}
			if err != nil {
				logrus.Error("Error Parsing claim script: ", err)
				continue
			}
			pksAddress := lbrycrd.GetAddressFromPublicKeyScript(pkscript)
			claim.ClaimAddress = pksAddress
			if err := claim.UpdateG(boil.Whitelist(model.ClaimColumns.ClaimAddress)); err != nil {
				logrus.Error("Saving Claim Address Error: ", err)
			}
		}
	}
}

func setBlockHeightOnAllClaims() {

	type claimInfo struct {
		ID     uint64 `boil:"id"`
		height uint64 `boil:"height"`
	}

	rows, err := boil.GetDB().Query(`
	SELECT c.id,b.height
	FROM claim c
	LEFT JOIN transaction t on c.transaction_hash_id = t.hash
	LEFT JOIN block b on b.hash = t.block_hash_id
	WHERE c.height = 0`)

	if err != nil {
		logrus.Panic("Error During Upgrade: ", err)
	}
	defer util.CloseRows(rows)

	var slice []claimInfo

	for rows.Next() {
		var info claimInfo
		err = rows.Scan(&info.ID, &info.height)
		if err != nil {
			logrus.Panic("Error During Upgrade: ", err)
		}
		slice = append(slice, info)
	}

	for i, info := range slice {
		if i%1000 == 0 {
			logrus.Info("Processing: ", "(", i, "/", len(slice), ")")
		}

		claim := model.Claim{ID: info.ID, Height: uint(info.height)}
		if err := claim.UpdateG(boil.Whitelist(model.ClaimColumns.Height)); err != nil {
			println(err)
		}
	}
}

func reProcessAllClaimsFromHeight(height uint) {
	transaction := model.TableNames.Transaction
	txHash := transaction + "." + model.TransactionColumns.Hash
	outputTxHash := model.TableNames.Output + "." + model.OutputColumns.TransactionHash
	block := model.TableNames.Block
	blockHash := block + "." + model.BlockColumns.Hash
	blockHeight := block + "." + model.BlockColumns.Height
	txBlockHash := transaction + "." + model.TransactionColumns.BlockHashID
	outputs := model.Outputs(
		qm.Select(model.OutputColumns.TransactionHash, model.BlockColumns.Height),
		qm.InnerJoin(transaction+" on "+txHash+" = "+outputTxHash),
		qm.InnerJoin(block+" on "+txBlockHash+" = "+blockHash),
		qm.Where(model.OutputColumns.Type+" =?", lbrycrd.NonStandard),
		qm.And(blockHeight+" >= ?", height),
	).AllGP()
	for i, output := range outputs {
		processClaimOut(i, len(outputs), output.TransactionHash)
	}
}