fix handling PATFO

Author: OPReturnCode

blockchain/cashtokens_test.go

@@ -455,6 +455,11 @@ func TestCashTokensBeforeActivationStandardInvalidOPCodes(t *testing.T) {
 			if len(test) == 7 {
 				txIdx = int(test[6].(float64))
 			}
+
+			if blockchain.IsPATFO(utxos[txIdx].TokenData, utxos[txIdx].PkScript, 100, 782772) {
+				continue
+			}
+
 			inputAmount := utxos[txIdx].Value
 
 			vm, err := txscript.NewEngine(utxos[txIdx].PkScript, &tx, txIdx, flags, nil, nil, cache, inputAmount)

blockchain/scriptval.go

@@ -29,15 +29,16 @@ type txValidateItem struct {
 // inputs.  It provides several channels for communication and a processing
 // function that is intended to be in run multiple goroutines.
 type txValidator struct {
-	validateChan chan *txValidateItem
-	quitChan     chan struct{}
-	resultChan   chan error
-	utxoView     *UtxoViewpoint
-	flags        txscript.ScriptFlags
-	sigCache     *txscript.SigCache
-	hashCache    *txscript.HashCache
-	sigChecks    uint32
-	maxSigChecks uint32
+	validateChan       chan *txValidateItem
+	quitChan           chan struct{}
+	resultChan         chan error
+	utxoView           *UtxoViewpoint
+	flags              txscript.ScriptFlags
+	sigCache           *txscript.SigCache
+	hashCache          *txscript.HashCache
+	sigChecks          uint32
+	maxSigChecks       uint32
+	upgrade9ForkHeight int32
 }
 
 // sendResult sends the result of a script pair validation on the internal
@@ -98,9 +99,29 @@ out:
 				utxoEntryCache.AddEntry(i, *wire.NewTxOut(u.amount, u.pkScript, u.tokenData))
 			}
 
-			_, err := wire.RunCashTokensValidityAlgorithm(utxoEntryCache, txVI.tx.MsgTx())
-			if err != nil {
+			isPATFO := IsPATFO(
+				utxo.tokenData, utxo.pkScript,
+				utxo.blockHeight, v.upgrade9ForkHeight)
+
+			if isPATFO {
+				// PATFOs are provably unspendable. The software ignores
+				// other types of provably unspendable tokens so we use
+				// the same behaviour here.
+				str := fmt.Sprintf("unable to find unspent "+
+					"output %v referenced from "+
+					"transaction %s:%d",
+					txIn.PreviousOutPoint, txVI.tx.Hash(),
+					txVI.txInIndex)
+				err := ruleError(ErrMissingTxOut, str)
 				v.sendResult(err)
+				break out
+			}
+
+			if v.flags.HasFlag(txscript.ScriptAllowCashTokens) {
+				_, err := wire.RunCashTokensValidityAlgorithm(utxoEntryCache, txVI.tx.MsgTx())
+				if err != nil {
+					v.sendResult(err)
+				}
 			}
 
 			vm, err := txscript.NewEngine(pkScript, txVI.tx.MsgTx(),
@@ -222,24 +243,25 @@ func (v *txValidator) Validate(items []*txValidateItem) error {
 // newTxValidator returns a new instance of txValidator to be used for
 // validating transaction scripts asynchronously.
 func newTxValidator(utxoView *UtxoViewpoint, flags txscript.ScriptFlags,
-	sigCache *txscript.SigCache, hashCache *txscript.HashCache, maxSigChecks uint32) *txValidator {
+	sigCache *txscript.SigCache, hashCache *txscript.HashCache, maxSigChecks uint32, upgrade9ForkHeight int32) *txValidator {
 	return &txValidator{
-		validateChan: make(chan *txValidateItem),
-		quitChan:     make(chan struct{}),
-		resultChan:   make(chan error),
-		utxoView:     utxoView,
-		sigCache:     sigCache,
-		hashCache:    hashCache,
-		flags:        flags,
-		maxSigChecks: maxSigChecks,
+		validateChan:       make(chan *txValidateItem),
+		quitChan:           make(chan struct{}),
+		resultChan:         make(chan error),
+		utxoView:           utxoView,
+		sigCache:           sigCache,
+		hashCache:          hashCache,
+		flags:              flags,
+		maxSigChecks:       maxSigChecks,
+		upgrade9ForkHeight: upgrade9ForkHeight,
 	}
 }
 
 // ValidateTransactionScripts validates the scripts for the passed transaction
 // using multiple goroutines. It returns the number of sigchecks in the transaction.
 func ValidateTransactionScripts(tx *bchutil.Tx, utxoView *UtxoViewpoint,
 	flags txscript.ScriptFlags, sigCache *txscript.SigCache,
-	hashCache *txscript.HashCache) (uint32, error) {
+	hashCache *txscript.HashCache, upgrade9ForkHeight int32) (uint32, error) {
 
 	// If the HashCache is present, and it doesn't yet contain the
 	// partial sighashes for this transaction, then we add the
@@ -269,8 +291,9 @@ func ValidateTransactionScripts(tx *bchutil.Tx, utxoView *UtxoViewpoint,
 			}
 			utxoCache.AddEntry(i, *wire.NewTxOut(u.amount, u.pkScript, u.tokenData))
 		}
-
-		cachedHashes.AddTxSigHashUtxoFromUtxoCache(tx.MsgTx(), utxoCache)
+		if flags.HasFlag(txscript.ScriptAllowCashTokens) {
+			cachedHashes.AddTxSigHashUtxoFromUtxoCache(tx.MsgTx(), utxoCache)
+		}
 	}
 
 	// Collect all of the transaction inputs and required information for
@@ -295,18 +318,32 @@ func ValidateTransactionScripts(tx *bchutil.Tx, utxoView *UtxoViewpoint,
 	}
 
 	// Validate all of the inputs.
-	validator := newTxValidator(utxoView, flags, sigCache, hashCache, 0)
+	validator := newTxValidator(utxoView, flags, sigCache, hashCache, 0, upgrade9ForkHeight)
 	if err := validator.Validate(txValItems); err != nil {
 		return 0, err
 	}
 	return sigChecks, nil
 }
 
+// Checks if the input contains pre-activation token-forgery output.
+// PATFOs are provably unspendable so a better place to check for them might be inside
+// txscript.IsUnspendable() but since we need to check for block heights, to mimimize
+// changes in the codebase, we handle it here. It might be a good idea to change this later.
+func IsPATFO(tokenData wire.TokenData, pkScript []byte, utxoBlockHeight int32, upgrade9ForkHeight int32) bool {
+	isPATFO := false
+	if !tokenData.IsEmpty() || pkScript[0] == 0xef {
+		if utxoBlockHeight < upgrade9ForkHeight {
+			isPATFO = true
+		}
+	}
+	return isPATFO
+}
+
 // checkBlockScripts executes and validates the scripts for all transactions in
 // the passed block using multiple goroutines.
 func checkBlockScripts(block *bchutil.Block, utxoView *UtxoViewpoint,
 	scriptFlags txscript.ScriptFlags, sigCache *txscript.SigCache,
-	hashCache *txscript.HashCache, maxSigChecks uint32) error {
+	hashCache *txscript.HashCache, maxSigChecks uint32, upgrade9ForkHeight int32) error {
 
 	// Collect all of the transaction inputs and required information for
 	// validation for all transactions in the block into a single slice.
@@ -346,8 +383,9 @@ func checkBlockScripts(block *bchutil.Block, utxoView *UtxoViewpoint,
 				}
 				utxoCache.AddEntry(i, *wire.NewTxOut(u.amount, u.pkScript, u.tokenData))
 			}
-
-			cachedHashes.AddTxSigHashUtxoFromUtxoCache(tx.MsgTx(), utxoCache)
+			if scriptFlags.HasFlag(txscript.ScriptAllowCashTokens) {
+				cachedHashes.AddTxSigHashUtxoFromUtxoCache(tx.MsgTx(), utxoCache)
+			}
 		}
 
 		for txInIdx, txIn := range tx.MsgTx().TxIn {
@@ -368,7 +406,7 @@ func checkBlockScripts(block *bchutil.Block, utxoView *UtxoViewpoint,
 	}
 
 	// Validate all of the inputs.
-	validator := newTxValidator(utxoView, scriptFlags, sigCache, hashCache, maxSigChecks)
+	validator := newTxValidator(utxoView, scriptFlags, sigCache, hashCache, maxSigChecks, upgrade9ForkHeight)
 	start := time.Now()
 	if err := validator.Validate(txValItems); err != nil {
 		return err

blockchain/scriptval_test.go

@@ -41,7 +41,7 @@ func TestCheckBlockScripts(t *testing.T) {
 	}
 
 	scriptFlags := txscript.ScriptBip16
-	err = checkBlockScripts(blocks[0], view, scriptFlags, nil, nil, 0)
+	err = checkBlockScripts(blocks[0], view, scriptFlags, nil, nil, 0, 0)
 	if err != nil {
 		t.Errorf("Transaction script validation failed: %v\n", err)
 		return

blockchain/validate.go

@@ -1256,7 +1256,7 @@ func (b *BlockChain) checkConnectBlock(node *blockNode, block *bchutil.Block, vi
 	if runScripts {
 		maxSigChecks := b.excessiveBlockSize / BlockMaxBytesMaxSigChecksRatio
 		err := checkBlockScripts(block, view, scriptFlags, b.sigCache,
-			b.hashCache, maxSigChecks)
+			b.hashCache, maxSigChecks, b.chainParams.Upgrade9ForkHeight)
 		if err != nil {
 			return err
 		}

mempool/mempool.go

@@ -955,7 +955,7 @@ func (mp *TxPool) maybeAcceptTransaction(tx *bchutil.Tx, isNew, rateLimit, rejec
 	// Verify crypto signatures for each input and reject the transaction if
 	// any don't verify.
 	_, err = blockchain.ValidateTransactionScripts(tx, utxoView, scriptFlags,
-		mp.cfg.SigCache, mp.cfg.HashCache)
+		mp.cfg.SigCache, mp.cfg.HashCache, mp.cfg.ChainParams.Upgrade9ForkHeight)
 	if err != nil {
 		if cerr, ok := err.(blockchain.RuleError); ok {
 			return nil, nil, chainRuleError(cerr)

mining/mining.go

@@ -698,7 +698,7 @@ mempoolLoop:
 		}
 		sigchecks, err := blockchain.ValidateTransactionScripts(tx, blockUtxos,
 			txscript.StandardVerifyFlags, g.sigCache,
-			g.hashCache)
+			g.hashCache, g.chainParams.Upgrade9ForkHeight)
 		if err != nil {
 			log.Tracef("Skipping tx %s due to error in "+
 				"ValidateTransactionScripts: %v", tx.Hash(), err)

txscript/opcode.go

@@ -2384,7 +2384,9 @@ func opcodeCheckSig(op *parsedOpcode, vm *Engine) error {
 		sigHashes = NewTxSigHashes(&vm.tx)
 	}
 
-	sigHashes.AddTxSigHashUtxoFromUtxoCache(&vm.tx, vm.utxoCache)
+	if hashType&SigHashUTXO != 0 { // TODO TODO use hashType. For other places that use AddTxSigHashUtxoFromUtxoCache too
+		sigHashes.AddTxSigHashUtxoFromUtxoCache(&vm.tx, vm.utxoCache)
+	}
 
 	hash, err = calcSignatureHash(subScript, sigHashes, hashType, &vm.tx, vm.txIdx,
 		vm.inputAmount, vm.hasFlag(ScriptVerifyBip143SigHash))
@@ -2574,9 +2576,9 @@ func opcodeCheckMultiSig(op *parsedOpcode, vm *Engine) error {
 			sigHashes = NewTxSigHashes(&vm.tx)
 		}
 	}
-
-	sigHashes.AddTxSigHashUtxoFromUtxoCache(&vm.tx, vm.utxoCache)
-
+	if vm.hasFlag(ScriptAllowCashTokens) {
+		sigHashes.AddTxSigHashUtxoFromUtxoCache(&vm.tx, vm.utxoCache)
+	}
 	success := true
 
 	if vm.hasFlag(ScriptVerifySchnorrMultisig) && len(dummy) > 0 { // Schnorr multisig

wire/cashtokens.go

@@ -30,7 +30,7 @@ type TokenData struct {
 }
 
 func (tokenData *TokenData) SeparateTokenDataFromPKScriptIfExists(buf []byte, pver uint32) ([]byte, error) {
-	if buf[0] != PREFIX_BYTE {
+	if len(buf) == 0 || buf[0] != PREFIX_BYTE {
 		// There is no token data. Return the whole buffer as script
 		return buf, nil
 	} else {
@@ -201,7 +201,6 @@ func IsCoinBaseTx(msgTx *MsgTx) bool {
 
 // Token Validation Algorithm
 func RunCashTokensValidityAlgorithm(cache utxoCacheInterface, tx *MsgTx) (bool, error) {
-
 	if IsCoinBaseTx(tx) {
 		return false, messageError("RunCashTokensValidityAlgorithm", "ErrCashTokensValidation")
 	}

wire/msgtx.go

@@ -783,10 +783,17 @@ func readTxOut(r io.Reader, pver uint32, version int32, to *TxOut) (int, error)
 
 	scriptAndTokendataSize := len(ScriptAndPossibleTokenData)
 
-	if ScriptAndPossibleTokenData[0] != 0xef { // Todo maybe change this
+	if scriptAndTokendataSize > 0 && ScriptAndPossibleTokenData[0] != 0xef { // Todo maybe change this
+		to.PkScript = ScriptAndPossibleTokenData
+		return scriptAndTokendataSize, err
+	}
+	var tokenDataSeparationErr error
+	to.PkScript, tokenDataSeparationErr = to.TokenData.SeparateTokenDataFromPKScriptIfExists(ScriptAndPossibleTokenData, pver)
+
+	if tokenDataSeparationErr != nil { // after activation this must fail! TODO TODO
+		to.TokenData = TokenData{} // Maybe move this inside TokenData.SeparateTokenDataFromPKScriptIfExists()
 		to.PkScript = ScriptAndPossibleTokenData
 	}
-	to.PkScript, err = to.TokenData.SeparateTokenDataFromPKScriptIfExists(ScriptAndPossibleTokenData, pver)
 	return scriptAndTokendataSize, err
 }