// isBIP0030Node returns whether or not the passed node represents one of the
// two blocks that violate the BIP0030 rule which prevents transactions from
// overwriting old ones.
func isBIP0030Node(node *blockNode) bool {
        if node.height == 91842 && node.hash.IsEqual(block91842Hash) {
                return true
        }

        if node.height == 91880 && node.hash.IsEqual(block91880Hash) {
                return true
        }

        return false

// checkBIP0030 ensures blocks do not contain duplicate transactions which
// 'overwrite' older transactions that are not fully spent.  This prevents an
// attack where a coinbase and all of its dependent transactions could be
// duplicated to effectively revert the overwritten transactions to a single
// confirmation thereby making them vulnerable to a double spend.
//
// For more details, see
// https://github.com/bitcoin/bips/blob/master/bip-0030.mediawiki and
// http://r6.ca/blog/20120206T005236Z.html.
//
// This function MUST be called with the chain state lock held (for reads).
func (b *BlockChain) checkBIP0030(node *blockNode, block *btcutil.Block, view *UtxoViewpoint) error {
        // Fetch utxos for all of the transaction ouputs in this block.
        // Typically, there will not be any utxos for any of the outputs.
        fetchSet := make(map[wire.OutPoint]struct{})
        for _, tx := range block.Transactions() {
                prevOut := wire.OutPoint{Hash: *tx.Hash()}
                for txOutIdx := range tx.MsgTx().TxOut {
                        prevOut.Index = uint32(txOutIdx)
                        fetchSet[prevOut] = struct{}{}
                }
        }
        err := view.fetchUtxos(b.db, fetchSet)
        if err != nil {
                return err
        }

        // Duplicate transactions are only allowed if the previous transaction
        // is fully spent.
        for outpoint := range fetchSet {
                utxo := view.LookupEntry(outpoint)
                if utxo != nil && !utxo.IsSpent() {
                        str := fmt.Sprintf("tried to overwrite transaction %v "+
                                "at block height %d that is not fully spent",
                                outpoint.Hash, utxo.BlockHeight())
                        return ruleError(ErrOverwriteTx, str)
                }
        }

        return nil
}

func (b *BlockChain) checkConnectBlock(node *blockNode, block *btcutil.Block, view *UtxoViewpoint, stxos *[]SpentTxOut) error {
        /* 省略其它 */

        // BIP0030 added a rule to prevent blocks which contain duplicate
        // transactions that 'overwrite' older transactions which are not fully
        // spent.  See the documentation for checkBIP0030 for more details.
        //
        // There are two blocks in the chain which violate this rule, so the
        // check must be skipped for those blocks.  The isBIP0030Node function
        // is used to determine if this block is one of the two blocks that must
        // be skipped.
        //
        // In addition, as of BIP0034, duplicate coinbases are no longer
        // possible due to its requirement for including the block height in the
        // coinbase and thus it is no longer possible to create transactions
        // that 'overwrite' older ones.  Therefore, only enforce the rule if
        // BIP0034 is not yet active.  This is a useful optimization because the
        // BIP0030 check is expensive since it involves a ton of cache misses in
        // the utxoset.
        if !isBIP0030Node(node) && (node.height < b.chainParams.BIP0034Height) {
                err := b.checkBIP0030(node, block, view)
                if err != nil {
                        return err
                }
        }

        /* 省略其它 */
}