// AddUnconfirmedTx adds all addresses related to the transaction to the
// unconfirmed (memory-only) address index.
//
// NOTE: This transaction MUST have already been validated by the memory pool
// before calling this function with it and have all of the inputs available in
// the provided utxo view. Failure to do so could result in some or all
// addresses not being indexed.
//
// This function is safe for concurrent access.
func (idx *AddrIndex) AddUnconfirmedTx(tx *dcrutil.Tx, utxoView *blockchain.UtxoViewpoint) {
// Index addresses of all referenced previous transaction outputs.
//
// The existence checks are elided since this is only called after the
// transaction has already been validated and thus all inputs are
// already known to exist.
msgTx := tx.MsgTx()
isSSGen, _ := stake.IsSSGen(msgTx)
for i, txIn := range msgTx.TxIn {
// Skip stakebase.
if i == 0 && isSSGen {
continue
}
entry := utxoView.LookupEntry(&txIn.PreviousOutPoint.Hash)
if entry == nil {
// Ignore missing entries. This should never happen
// in practice since the function comments specifically
// call out all inputs must be available.
continue
}
version := entry.ScriptVersionByIndex(txIn.PreviousOutPoint.Index)
pkScript := entry.PkScriptByIndex(txIn.PreviousOutPoint.Index)
txType := entry.TransactionType()
idx.indexUnconfirmedAddresses(version, pkScript, tx,
txType == stake.TxTypeSStx)
}
// Index addresses of all created outputs.
isSStx, _ := stake.IsSStx(msgTx)
for _, txOut := range msgTx.TxOut {
idx.indexUnconfirmedAddresses(txOut.Version, txOut.PkScript, tx,
isSStx)
}
}
// calcInputValueAge is a helper function used to calculate the input age of
// a transaction. The input age for a txin is the number of confirmations
// since the referenced txout multiplied by its output value. The total input
// age is the sum of this value for each txin. Any inputs to the transaction
// which are currently in the mempool and hence not mined into a block yet,
// contribute no additional input age to the transaction.
func calcInputValueAge(tx *wire.MsgTx, utxoView *blockchain.UtxoViewpoint, nextBlockHeight int64) float64 {
var totalInputAge float64
for _, txIn := range tx.TxIn {
// Don't attempt to accumulate the total input age if the
// referenced transaction output doesn't exist.
originHash := &txIn.PreviousOutPoint.Hash
originIndex := txIn.PreviousOutPoint.Index
txEntry := utxoView.LookupEntry(originHash)
if txEntry != nil && !txEntry.IsOutputSpent(originIndex) {
// Inputs with dependencies currently in the mempool
// have their block height set to a special constant.
// Their input age should be computed as zero since
// their parent hasn't made it into a block yet.
var inputAge int64
originHeight := txEntry.BlockHeight()
if originHeight == mempoolHeight {
inputAge = 0
} else {
inputAge = nextBlockHeight - originHeight
}
// Sum the input value times age.
inputValue := txEntry.AmountByIndex(originIndex)
totalInputAge += float64(inputValue * inputAge)
}
}
return totalInputAge
}
// checkInputsStandard performs a series of checks on a transaction's inputs
// to ensure they are "standard". A standard transaction input is one that
// that consumes the expected number of elements from the stack and that number
// is the same as the output script pushes. This help prevent resource
// exhaustion attacks by "creative" use of scripts that are super expensive to
// process like OP_DUP OP_CHECKSIG OP_DROP repeated a large number of times
// followed by a final OP_TRUE.
func checkInputsStandard(tx *dcrutil.Tx, txType stake.TxType, utxoView *blockchain.UtxoViewpoint) error {
// NOTE: The reference implementation also does a coinbase check here,
// but coinbases have already been rejected prior to calling this
// function so no need to recheck.
for i, txIn := range tx.MsgTx().TxIn {
if i == 0 && txType == stake.TxTypeSSGen {
continue
}
// It is safe to elide existence and index checks here since
// they have already been checked prior to calling this
// function.
prevOut := txIn.PreviousOutPoint
entry := utxoView.LookupEntry(&prevOut.Hash)
originPkScript := entry.PkScriptByIndex(prevOut.Index)
// Calculate stats for the script pair.
scriptInfo, err := txscript.CalcScriptInfo(txIn.SignatureScript,
originPkScript, true)
if err != nil {
str := fmt.Sprintf("transaction input #%d script parse "+
"failure: %v", i, err)
return txRuleError(wire.RejectNonstandard, str)
}
// A negative value for expected inputs indicates the script is
// non-standard in some way.
if scriptInfo.ExpectedInputs < 0 {
str := fmt.Sprintf("transaction input #%d expects %d "+
"inputs", i, scriptInfo.ExpectedInputs)
return txRuleError(wire.RejectNonstandard, str)
}
// The script pair is non-standard if the number of available
// inputs does not match the number of expected inputs.
if scriptInfo.NumInputs != scriptInfo.ExpectedInputs {
str := fmt.Sprintf("transaction input #%d expects %d "+
"inputs, but referenced output script provides "+
"%d", i, scriptInfo.ExpectedInputs,
scriptInfo.NumInputs)
return txRuleError(wire.RejectNonstandard, str)
}
}
return nil
}
// indexBlock extract all of the standard addresses from all of the transactions
// in the passed block and maps each of them to the assocaited transaction using
// the passed map.
func (idx *AddrIndex) indexBlock(data writeIndexData, block, parent *dcrutil.Block, view *blockchain.UtxoViewpoint) {
regularTxTreeValid := dcrutil.IsFlagSet16(block.MsgBlock().Header.VoteBits,
dcrutil.BlockValid)
var stakeStartIdx int
if regularTxTreeValid {
for txIdx, tx := range parent.Transactions() {
// Coinbases do not reference any inputs. Since the block is
// required to have already gone through full validation, it has
// already been proven on the first transaction in the block is
// a coinbase.
if txIdx != 0 {
for _, txIn := range tx.MsgTx().TxIn {
// The view should always have the input since
// the index contract requires it, however, be
// safe and simply ignore any missing entries.
origin := &txIn.PreviousOutPoint
entry := view.LookupEntry(&origin.Hash)
if entry == nil {
log.Warnf("Missing input %v for tx %v while "+
"indexing block %v (height %v)\n", origin.Hash,
tx.Sha(), block.Sha(), block.Height())
continue
}
version := entry.ScriptVersionByIndex(origin.Index)
pkScript := entry.PkScriptByIndex(origin.Index)
txType := entry.TransactionType()
idx.indexPkScript(data, version, pkScript, txIdx,
txType == stake.TxTypeSStx)
}
}
for _, txOut := range tx.MsgTx().TxOut {
idx.indexPkScript(data, txOut.Version, txOut.PkScript, txIdx,
false)
}
}
stakeStartIdx = len(parent.Transactions())
}
for txIdx, tx := range block.STransactions() {
msgTx := tx.MsgTx()
thisTxOffset := txIdx + stakeStartIdx
isSSGen, _ := stake.IsSSGen(msgTx)
for i, txIn := range msgTx.TxIn {
// Skip stakebases.
if isSSGen && i == 0 {
continue
}
// The view should always have the input since
// the index contract requires it, however, be
// safe and simply ignore any missing entries.
origin := &txIn.PreviousOutPoint
entry := view.LookupEntry(&origin.Hash)
if entry == nil {
log.Warnf("Missing input %v for tx %v while "+
"indexing block %v (height %v)\n", origin.Hash,
tx.Sha(), block.Sha(), block.Height())
continue
}
version := entry.ScriptVersionByIndex(origin.Index)
pkScript := entry.PkScriptByIndex(origin.Index)
txType := entry.TransactionType()
idx.indexPkScript(data, version, pkScript, thisTxOffset,
txType == stake.TxTypeSStx)
}
isSStx, _ := stake.IsSStx(msgTx)
for _, txOut := range msgTx.TxOut {
idx.indexPkScript(data, txOut.Version, txOut.PkScript,
thisTxOffset, isSStx)
}
}
}