[refactor] call ltx.AcceptTxToMemPool for detail tx checks, during disconnectTip and sendrawtransaction.

Author: whunmr

errcode/txerror.go

@@ -5,13 +5,8 @@ import "fmt"
 type TxErr int
 
 const (
-	TxErrRejectNonstandard     TxErr = 0x40
-	TxErrRejectDust            TxErr = 0x41
 	TxErrRejectCheckPoint      TxErr = 0x43
 
-	TxErrRejectAlreadyKnown TxErr = 0x101
-	TxErrRejectConflict     TxErr = 0x102
-
 	TxErrNoPreviousOut TxErr = TxErrorBase + iota
 	ScriptCheckInputsBug
 	TxErrSignRawTransaction
@@ -20,11 +15,7 @@ const (
 )
 
 var txErrorToString = map[TxErr]string{
-	TxErrRejectNonstandard:     "TxErrRejectNonstandard",
-	TxErrRejectDust:            "TxErrRejectDust",
 	TxErrRejectCheckPoint:      "TxErrRejectCheckPoint",
-	TxErrRejectAlreadyKnown:    "TxErrRejectAlreadyKnown",
-	TxErrRejectConflict:        "TxErrRejectConflict",
 	TxErrNoPreviousOut:         "There is no previousout",
 	ScriptCheckInputsBug:       "ScriptCheckInputsBug",
 	TxErrSignRawTransaction:    "TxErrSignRawTransaction",

errcode/txerror_test.go

@@ -9,11 +9,7 @@ func TestTxErr_String(t *testing.T) {
 		in   TxErr
 		want string
 	}{
-		{TxErrRejectNonstandard, "TxErrRejectNonstandard"},
-		{TxErrRejectDust, "TxErrRejectDust"},
 		{TxErrRejectCheckPoint, "TxErrRejectCheckPoint"},
-		{TxErrRejectAlreadyKnown, "TxErrRejectAlreadyKnown"},
-		{TxErrRejectConflict, "TxErrRejectConflict"},
 		{TxErrNoPreviousOut, "There is no previousout"},
 		{ScriptCheckInputsBug, "ScriptCheckInputsBug"},
 		{TxErrSignRawTransaction, "TxErrSignRawTransaction"},

logic/lmempool/ltxmempool.go

@@ -18,59 +18,31 @@ import (
 	"github.com/copernet/copernicus/util"
 )
 
-// AcceptTxToMemPool add one check corret transaction to mempool.
-func AcceptTxToMemPool(tx *tx.Tx) error {
+func AcceptTxToMemPool(txn *tx.Tx) error {
+	txEntry, err := ltx.CheckTxBeforeAcceptToMemPool(txn)
+	if err != nil {
+		return err
+	}
 
-	//first : check whether enter mempool.
+	return addTxToMemPool(txEntry)
+}
+
+func addTxToMemPool(txe *mempool.TxEntry) error {
 	pool := mempool.GetInstance()
-	pool.Lock()
-	defer pool.Unlock()
 
-	gChain := chain.GetInstance()
-	utxoTip := utxo.GetUtxoCacheInstance()
-
-	allPreout := tx.GetAllPreviousOut()
-	coins := make([]*utxo.Coin, len(allPreout))
-	var txfee int64
-	var inputValue int64
-	spendCoinbase := false
-
-	for i, preout := range allPreout {
-		if coin := utxoTip.GetCoin(&preout); coin != nil {
-			coins[i] = coin
-			inputValue += int64(coin.GetAmount())
-			if coin.IsCoinBase() {
-				spendCoinbase = true
-			}
-		} else {
-			if coin := pool.GetCoin(&preout); coin != nil {
-				coins[i] = coin
-				inputValue += int64(coin.GetAmount())
-				if coin.IsCoinBase() {
-					spendCoinbase = true
-				}
-			} else {
-				log.Error("the transaction in mempool, not found its parent " +
-					"transaction in local node and utxo")
-				return errcode.New(errcode.TxErrNoPreviousOut)
-			}
-		}
-	}
+	ancestorNum := conf.Cfg.Mempool.LimitAncestorCount
+	ancestorSize := conf.Cfg.Mempool.LimitAncestorSize
+	descendantNum := conf.Cfg.Mempool.LimitDescendantCount
+	descendantSize := conf.Cfg.Mempool.LimitDescendantSize
+
+	ancestors, err := pool.CalculateMemPoolAncestors(txe.Tx, uint64(ancestorNum), uint64(ancestorSize*1000),
+		uint64(descendantNum), uint64(descendantSize*1000), true)
 
-	txfee = inputValue - int64(tx.GetValueOut())
-	ancestors, lp, err := isTxAcceptable(tx, txfee)
 	if err != nil {
 		return err
 	}
 
-	//TODO: sigsCount := ltx.GetTransactionSigOpCount(tx, script.StandardScriptVerifyFlags,
-
-	//second : add transaction to mempool.
-	txentry := mempool.NewTxentry(tx, txfee, util.GetTime(), gChain.Height(), *lp,
-		tx.GetSigOpCountWithoutP2SH(), spendCoinbase)
-
-	pool.AddTx(txentry, ancestors)
-
+	pool.AddTx(txe, ancestors)
 	return nil
 }
 
@@ -95,7 +67,7 @@ func TryAcceptOrphansTxs(transaction *tx.Tx) (acceptTxs []*tx.Tx, rejectTxs []ut
 					continue
 				}
 
-				err := AcceptTxToMemPool(iOrphanTx.Tx) //TODO: check transaction before add to mempool
+				err := AcceptTxToMemPool(iOrphanTx.Tx)
 				if err == nil {
 					acceptTxs = append(acceptTxs, iOrphanTx.Tx)
 					for i := 0; i < iOrphanTx.Tx.GetOutsCount(); i++ {
@@ -120,52 +92,11 @@ func TryAcceptOrphansTxs(transaction *tx.Tx) (acceptTxs []*tx.Tx, rejectTxs []ut
 	return
 }
 
-func isTxAcceptable(tx *tx.Tx, txfee int64) (map[*mempool.TxEntry]struct{}, *mempool.LockPoints, error) {
-	pool := mempool.GetInstance()
-	allEntry := pool.GetAllTxEntryWithoutLock()
-	if _, ok := allEntry[tx.GetHash()]; ok {
-		return nil, nil, errcode.New(errcode.AlreadHaveTx)
-	}
-
-	lp := ltx.CalculateLockPoints(tx, consensus.LocktimeVerifySequence|consensus.LocktimeMedianTimePast)
-	if lp == nil {
-		return nil, lp, errcode.New(errcode.Nomature)
-	}
-	if !ltx.CheckSequenceLocks(lp.Height, lp.Time) {
-		return nil, lp, errcode.New(errcode.Nomature)
-	}
-
-	ancestorNum := conf.Cfg.Mempool.LimitAncestorCount
-	ancestorSize := conf.Cfg.Mempool.LimitAncestorSize
-	descendantNum := conf.Cfg.Mempool.LimitDescendantCount
-	descendantSize := conf.Cfg.Mempool.LimitDescendantSize
-	ancestors, err := pool.CalculateMemPoolAncestors(tx, uint64(ancestorNum), uint64(ancestorSize*1000),
-		uint64(descendantNum), uint64(descendantSize*1000), true)
-	if err != nil {
-		return nil, lp, err
-	}
-
-	txsize := int64(tx.EncodeSize())
-	minfeeRate := pool.GetMinFee(conf.Cfg.Mempool.MaxPoolSize)
-	rejectFee := minfeeRate.GetFee(int(txsize))
-	// compare the transaction feeRate with enter mempool min txfeeRate
-	if txfee < rejectFee {
-		return nil, lp, errcode.New(errcode.RejectInsufficientFee)
-	}
-
-	return ancestors, lp, nil
-}
-
 func RemoveTxSelf(txs []*tx.Tx) {
 	pool := mempool.GetInstance()
 	pool.RemoveTxSelf(txs)
 }
 
-func RemoveTxRecursive(origTx *tx.Tx, reason mempool.PoolRemovalReason) {
-	pool := mempool.GetInstance()
-	pool.RemoveTxRecursive(origTx, reason)
-}
-
 func RemoveForReorg(nMemPoolHeight int32, flag int) {
 	//gChain := chain.GetInstance()
 	view := utxo.GetUtxoCacheInstance()

logic/lreindex/lreindex.go

@@ -23,6 +23,7 @@ func Reindex() (err error) {
 	blkFiles, err := disk.GetBlkFiles()
 	if err != nil {
 		log.Error("reindex: get blk files failed, err:%s", err)
+		return err
 	}
 
 	log.Info("Start reindexing")

logic/ltx/ltx.go

@@ -2,6 +2,7 @@ package ltx
 
 import (
 	"bytes"
+	"fmt"
 	"github.com/copernet/copernicus/logic/lscript"
 	"github.com/copernet/copernicus/model/tx"
 	"github.com/copernet/copernicus/model/utxo"
@@ -65,54 +66,49 @@ func ScriptVerifyInit() {
 	}
 }
 
-// CheckRegularTransaction transaction service will use this func to check transaction before accepting to mempool
-func CheckRegularTransaction(txn *tx.Tx) error {
+func CheckTxBeforeAcceptToMemPool(txn *tx.Tx) (*mempool.TxEntry, error) {
 	if err := txn.CheckRegularTransaction(); err != nil {
-		return err
+		return nil, err
 	}
 
 	if model.ActiveNetParams.RequireStandard {
 		ok, reason := txn.IsStandard()
 		if !ok {
 			log.Debug("non standard tx: %s, reason: %s", txn.GetHash(), reason)
-			return errcode.NewError(errcode.RejectNonstandard, reason)
+			return nil, errcode.NewError(errcode.RejectNonstandard, reason)
 		}
 	}
 
 	// check common locktime, sequence final can disable it
 	err := ContextualCheckTransactionForCurrentBlock(txn, int(tx.StandardLockTimeVerifyFlags))
 	if err != nil {
-		return errcode.New(errcode.RejectNonstandard)
+		return nil, errcode.New(errcode.RejectNonstandard)
 	}
 
 	// is mempool already have it? conflict tx with mempool
 	gPool := mempool.GetInstance()
 	if gPool.FindTx(txn.GetHash()) != nil {
 		log.Debug("tx already known in mempool, hash: %s", txn.GetHash())
-		return errcode.NewError(errcode.RejectAlreadyKnown, "txn-already-in-mempool")
+		return nil, errcode.NewError(errcode.RejectAlreadyKnown, "txn-already-in-mempool")
 	}
 
 	for _, txin := range txn.GetIns() {
 		if gPool.HasSpentOut(txin.PreviousOutPoint) {
 			log.Debug("tx ins alread spent out in mempool, tx hash:%s", txn.GetHash())
-			return errcode.NewError(errcode.TxErrRejectConflict, "txn-mempool-conflict")
+			return nil, errcode.NewError(errcode.RejectConflict, "txn-mempool-conflict")
 		}
 	}
 
 	// check outpoint alread exist
 	if areOutputsAlreadExist(txn) {
 		log.Debug("tx's outpoint already known in utxo, tx hash: %s", txn.GetHash())
-		return errcode.NewError(errcode.TxErrRejectAlreadyKnown, "txn-already-known")
+		return nil, errcode.NewError(errcode.RejectAlreadyKnown, "txn-already-known")
 	}
 
 	// are inputs are exists and available?
-	inputCoins, missingInput, alreadySpent := inputCoinsOf(txn)
+	inputCoins, missingInput, spendCoinbase := inputCoinsOf(txn)
 	if missingInput {
-		return errcode.New(errcode.TxErrNoPreviousOut)
-	}
-
-	if alreadySpent {
-		return errcode.NewError(errcode.RejectDuplicate, "bad-txns-inputs-spent")
+		return nil, errcode.New(errcode.TxErrNoPreviousOut)
 	}
 
 	// CLTV(CheckLockTimeVerify)
@@ -124,7 +120,7 @@ func CheckRegularTransaction(txn *tx.Tx) error {
 	lp := CalculateLockPoints(txn, uint32(tx.StandardLockTimeVerifyFlags))
 	if lp == nil {
 		log.Debug("cann't calculate out lockpoints")
-		return errcode.New(errcode.RejectNonstandard)
+		return nil, errcode.New(errcode.RejectNonstandard)
 	}
 	// Only accept BIP68 sequence locked transactions that can be mined
 	// in the next block; we don't want our mempool filled up with
@@ -133,13 +129,13 @@ func CheckRegularTransaction(txn *tx.Tx) error {
 	// instead of create its own.
 	if !CheckSequenceLocks(lp.Height, lp.Time) {
 		log.Debug("tx sequence lock check faild")
-		return errcode.NewError(errcode.RejectNonstandard, "non-BIP68-final")
+		return nil, errcode.NewError(errcode.RejectNonstandard, "non-BIP68-final")
 	}
 
 	//check standard inputs
 	if model.ActiveNetParams.RequireStandard {
 		if areInputsStandard(txn, inputCoins) {
-			return errcode.NewError(errcode.RejectNonstandard, "bad-txns-nonstandard-inputs")
+			return nil, errcode.NewError(errcode.RejectNonstandard, "bad-txns-nonstandard-inputs")
 		}
 	}
 
@@ -150,9 +146,18 @@ func CheckRegularTransaction(txn *tx.Tx) error {
 	// than merely non-standard transaction.
 	sigOpsCount := GetTransactionSigOpCount(txn, uint32(script.StandardScriptVerifyFlags), inputCoins)
 	if uint(sigOpsCount) > tx.MaxStandardTxSigOps {
-		return errcode.NewError(errcode.RejectNonstandard, "bad-txns-too-many-sigops")
+		return nil, errcode.NewError(errcode.RejectNonstandard, "bad-txns-too-many-sigops")
+	}
+
+	txFee, err := checkFee(txn, inputCoins)
+	if err != nil {
+		return nil, err
 	}
 
+	//TODO: Require that free transactions have sufficient priority to be mined in the next block
+	//TODO: Continuously rate-limit free (really, very-low-fee) transactions.
+	//TODO: check absurdly-high-fee (nFees > nAbsurdFee)
+
 	var extraFlags uint32 = script.ScriptVerifyNone
 	tip := chain.GetInstance().Tip()
 	//if chainparams.IsMagneticAnomalyEnable(tip.GetMedianTimePast()) {
@@ -177,7 +182,7 @@ func CheckRegularTransaction(txn *tx.Tx) error {
 	// prevent CPU exhaustion denial-of-service attacks.
 	err = checkInputs(txn, inputCoins, scriptVerifyFlags)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// Check again against the current block tip's script verification flags
@@ -199,18 +204,38 @@ func CheckRegularTransaction(txn *tx.Tx) error {
 	err = checkInputs(txn, inputCoins, currentBlockScriptVerifyFlags)
 	if err != nil {
 		if ((^scriptVerifyFlags) & currentBlockScriptVerifyFlags) == 0 {
-			return errcode.New(errcode.ScriptCheckInputsBug)
+			return nil, errcode.New(errcode.ScriptCheckInputsBug)
 		}
 		err = checkInputs(txn, inputCoins, uint32(script.MandatoryScriptVerifyFlags)|extraFlags)
 		if err != nil {
-			return err
+			return nil, err
 		}
 
 		log.Debug("Warning: -promiscuousmempool flags set to not include currently enforced soft forks, " +
 			"this may break mining or otherwise cause instability!\n")
 	}
 
-	return nil
+	txEntry := mempool.NewTxentry(txn, txFee, util.GetTime(),
+		chain.GetInstance().Height(), *lp, sigOpsCount, spendCoinbase)
+
+	return txEntry, nil
+}
+
+func checkFee(txn *tx.Tx, inputCoins *utxo.CoinsMap) (int64, error) {
+	inputValue := inputCoins.GetValueIn(txn)
+	txFee := inputValue - txn.GetValueOut()
+
+	txsize := int64(txn.EncodeSize())
+	minfeeRate := mempool.GetInstance().GetMinFee(conf.Cfg.Mempool.MaxPoolSize)
+	rejectFee := minfeeRate.GetFee(int(txsize))
+
+	if int64(txFee) < rejectFee {
+		reason := fmt.Sprintf("mempool min fee not met %d < %d", txFee, rejectFee)
+		log.Debug("reject tx:%s, for %s", txn.GetHash(), reason)
+		return 0, errcode.NewError(errcode.RejectInsufficientFee, reason)
+	}
+
+	return int64(txFee), nil
 }
 
 func promiscuousMempoolFlags() uint32 {
@@ -328,7 +353,7 @@ func ApplyBlockTransactions(txs []*tx.Tx, bip30Enable bool, scriptCheckFlags uin
 			coinHeight, coinTime := CalculateSequenceLocks(transaction, coinsMap, scriptCheckFlags)
 			if !CheckSequenceLocks(coinHeight, coinTime) {
 				log.Debug("block contains a non-bip68-final transaction")
-				return nil, nil, errcode.New(errcode.TxErrRejectNonstandard)
+				return nil, nil, errcode.New(errcode.RejectNonstandard)
 			}
 		}
 		//check sigops
@@ -434,7 +459,7 @@ func areOutputsAlreadExist(transaction *tx.Tx) (exist bool) {
 	return false
 }
 
-func inputCoinsOf(txn *tx.Tx) (coinMap *utxo.CoinsMap, missingInput, alreadySpent bool) {
+func inputCoinsOf(txn *tx.Tx) (coinMap *utxo.CoinsMap, missingInput bool, spendCoinbase bool) {
 	coinMap = utxo.NewEmptyCoinsMap()
 
 	for _, txin := range txn.GetIns() {
@@ -445,18 +470,18 @@ func inputCoinsOf(txn *tx.Tx) (coinMap *utxo.CoinsMap, missingInput, alreadySpen
 			coin = mempool.GetInstance().GetCoin(prevout)
 		}
 
-		if coin == nil {
-			return nil, true, false
+		if coin == nil || coin.IsSpent() {
+			return coinMap, true, spendCoinbase
 		}
 
-		if coin.IsSpent() {
-			return nil, false, true
+		if coin.IsCoinBase() {
+			spendCoinbase = true
 		}
 
 		coinMap.AddCoin(prevout, coin, coin.IsCoinBase())
 	}
 
-	return coinMap, false, false
+	return coinMap, false, spendCoinbase
 }
 
 func GetTransactionSigOpCount(txn *tx.Tx, flags uint32, coinMap *utxo.CoinsMap) int {