// Copyright (c) 2009-2010 Satoshi Nakamoto

// Copyright (c) 2009-2015 The Bitcoin Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include "main.h"

#include "addrman.h"

#include "alert.h"

#include "arith_uint256.h"

#include "chainparams.h"

#include "checkpoints.h"

#include "checkqueue.h"

#include "consensus/consensus.h"

#include "consensus/merkle.h"

#include "consensus/validation.h"

#include "hash.h"

#include "init.h"

#include "merkleblock.h"

#include "net.h"

#include "policy/policy.h"

#include "pow.h"

#include "primitives/block.h"

#include "primitives/transaction.h"

#include "script/script.h"

#include "script/sigcache.h"

#include "script/standard.h"

#include "tinyformat.h"

#include "txdb.h"

#include "txmempool.h"

#include "ui_interface.h"

#include "undo.h"

#include "util.h"

#include "utilmoneystr.h"

#include "utilstrencodings.h"

#include "validationinterface.h"

#include "versionbits.h"

#include <sstream>

#include <boost/algorithm/string/replace.hpp>

#include <boost/filesystem.hpp>

#include <boost/filesystem/fstream.hpp>

#include <boost/math/distributions/poisson.hpp>

#include <boost/thread.hpp>

using namespace std;

#if defined(NDEBUG)

# error "Bitcoin cannot be compiled without assertions."

#endif

/**

* Global state

*/

CCriticalSection cs_main;

BlockMap mapBlockIndex;

CChain chainActive;

CBlockIndex *pindexBestHeader = NULL;

int64_t nTimeBestReceived = 0;

CWaitableCriticalSection csBestBlock;

CConditionVariable cvBlockChange;

int nScriptCheckThreads = 0;

bool fImporting = false;

bool fReindex = false;

bool fTxIndex = false;

bool fHavePruned = false;

bool fPruneMode = false;

bool fIsBareMultisigStd = DEFAULT_PERMIT_BAREMULTISIG;

bool fRequireStandard = true;

unsigned int nBytesPerSigOp = DEFAULT_BYTES_PER_SIGOP;

bool fCheckBlockIndex = false;

bool fCheckpointsEnabled = DEFAULT_CHECKPOINTS_ENABLED;

size_t nCoinCacheUsage = 5000 * 300;

uint64_t nPruneTarget = 0;

bool fAlerts = DEFAULT_ALERTS;

bool fEnableReplacement = DEFAULT_ENABLE_REPLACEMENT;

/** Fees smaller than this (in satoshi) are considered zero fee (for relaying, mining and transaction creation) */

CFeeRate minRelayTxFee = CFeeRate(DEFAULT_MIN_RELAY_TX_FEE);

CTxMemPool mempool(::minRelayTxFee);

struct COrphanTx {

CTransaction tx;

NodeId fromPeer;

};

map<uint256, COrphanTx> mapOrphanTransactions GUARDED_BY(cs_main);;

map<uint256, set<uint256> > mapOrphanTransactionsByPrev GUARDED_BY(cs_main);;

void EraseOrphansFor(NodeId peer) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

/**

* Returns true if there are nRequired or more blocks of minVersion or above

* in the last Consensus::Params::nMajorityWindow blocks, starting at pstart and going backwards.

*/

static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart, unsigned nRequired, const Consensus::Params& consensusParams);

static void CheckBlockIndex(const Consensus::Params& consensusParams);

/** Constant stuff for coinbase transactions we create: */

CScript COINBASE_FLAGS;

const string strMessageMagic = "Bitcoin Signed Message:\n";

// Internal stuff

namespace {

struct CBlockIndexWorkComparator

{

bool operator()(CBlockIndex *pa, CBlockIndex *pb) const {

// First sort by most total work, ...

if (pa->nChainWork > pb->nChainWork) return false;

if (pa->nChainWork < pb->nChainWork) return true;

// ... then by earliest time received, ...

if (pa->nSequenceId < pb->nSequenceId) return false;

if (pa->nSequenceId > pb->nSequenceId) return true;

// Use pointer address as tie breaker (should only happen with blocks

// loaded from disk, as those all have id 0).

if (pa < pb) return false;

if (pa > pb) return true;

// Identical blocks.

return false;

}

};

CBlockIndex *pindexBestInvalid;

/**

* The set of all CBlockIndex entries with BLOCK_VALID_TRANSACTIONS (for itself and all ancestors) and

* as good as our current tip or better. Entries may be failed, though, and pruning nodes may be

* missing the data for the block.

*/

set<CBlockIndex*, CBlockIndexWorkComparator> setBlockIndexCandidates;

/** Number of nodes with fSyncStarted. */

int nSyncStarted = 0;

/** All pairs A->B, where A (or one of its ancestors) misses transactions, but B has transactions.

* Pruned nodes may have entries where B is missing data.

*/

multimap<CBlockIndex*, CBlockIndex*> mapBlocksUnlinked;

CCriticalSection cs_LastBlockFile;

std::vector<CBlockFileInfo> vinfoBlockFile;

int nLastBlockFile = 0;

/** Global flag to indicate we should check to see if there are

* block/undo files that should be deleted. Set on startup

* or if we allocate more file space when we're in prune mode

*/

bool fCheckForPruning = false;

/**

* Every received block is assigned a unique and increasing identifier, so we

* know which one to give priority in case of a fork.

*/

CCriticalSection cs_nBlockSequenceId;

/** Blocks loaded from disk are assigned id 0, so start the counter at 1. */

uint32_t nBlockSequenceId = 1;

/**

* Sources of received blocks, saved to be able to send them reject

* messages or ban them when processing happens afterwards. Protected by

* cs_main.

*/

map<uint256, NodeId> mapBlockSource;

/**

* Filter for transactions that were recently rejected by

* AcceptToMemoryPool. These are not rerequested until the chain tip

* changes, at which point the entire filter is reset. Protected by

* cs_main.

*

* Without this filter we'd be re-requesting txs from each of our peers,

* increasing bandwidth consumption considerably. For instance, with 100

* peers, half of which relay a tx we don't accept, that might be a 50x

* bandwidth increase. A flooding attacker attempting to roll-over the

* filter using minimum-sized, 60byte, transactions might manage to send

* 1000/sec if we have fast peers, so we pick 120,000 to give our peers a

* two minute window to send invs to us.

*

* Decreasing the false positive rate is fairly cheap, so we pick one in a

* million to make it highly unlikely for users to have issues with this

* filter.

*

* Memory used: 1.7MB

*/

boost::scoped_ptr<CRollingBloomFilter> recentRejects;

uint256 hashRecentRejectsChainTip;

/** Blocks that are in flight, and that are in the queue to be downloaded. Protected by cs_main. */

struct QueuedBlock {

uint256 hash;

CBlockIndex* pindex; //!< Optional.

bool fValidatedHeaders; //!< Whether this block has validated headers at the time of request.

};

map<uint256, pair<NodeId, list<QueuedBlock>::iterator> > mapBlocksInFlight;

/** Number of preferable block download peers. */

int nPreferredDownload = 0;

/** Dirty block index entries. */

set<CBlockIndex*> setDirtyBlockIndex;

/** Dirty block file entries. */

set<int> setDirtyFileInfo;

/** Number of peers from which we're downloading blocks. */

int nPeersWithValidatedDownloads = 0;

} // anon namespace

//////////////////////////////////////////////////////////////////////////////

//

// Registration of network node signals.

//

namespace {

struct CBlockReject {

unsigned char chRejectCode;

string strRejectReason;

uint256 hashBlock;

};

/**

* Maintain validation-specific state about nodes, protected by cs_main, instead

* by CNode's own locks. This simplifies asynchronous operation, where

* processing of incoming data is done after the ProcessMessage call returns,

* and we're no longer holding the node's locks.

*/

struct CNodeState {

//! The peer's address

CService address;

//! Whether we have a fully established connection.

bool fCurrentlyConnected;

//! Accumulated misbehaviour score for this peer.

int nMisbehavior;

//! Whether this peer should be disconnected and banned (unless whitelisted).

bool fShouldBan;

//! String name of this peer (debugging/logging purposes).

std::string name;

//! List of asynchronously-determined block rejections to notify this peer about.

std::vector<CBlockReject> rejects;

//! The best known block we know this peer has announced.

CBlockIndex *pindexBestKnownBlock;

//! The hash of the last unknown block this peer has announced.

uint256 hashLastUnknownBlock;

//! The last full block we both have.

CBlockIndex *pindexLastCommonBlock;

//! The best header we have sent our peer.

CBlockIndex *pindexBestHeaderSent;

//! Whether we've started headers synchronization with this peer.

bool fSyncStarted;

//! Since when we're stalling block download progress (in microseconds), or 0.

int64_t nStallingSince;

list<QueuedBlock> vBlocksInFlight;

//! When the first entry in vBlocksInFlight started downloading. Don't care when vBlocksInFlight is empty.

int64_t nDownloadingSince;

int nBlocksInFlight;

int nBlocksInFlightValidHeaders;

//! Whether we consider this a preferred download peer.

bool fPreferredDownload;

//! Whether this peer wants invs or headers (when possible) for block announcements.

bool fPreferHeaders;

CNodeState() {

fCurrentlyConnected = false;

nMisbehavior = 0;

fShouldBan = false;

pindexBestKnownBlock = NULL;

hashLastUnknownBlock.SetNull();

pindexLastCommonBlock = NULL;

pindexBestHeaderSent = NULL;

fSyncStarted = false;

nStallingSince = 0;

nDownloadingSince = 0;

nBlocksInFlight = 0;

nBlocksInFlightValidHeaders = 0;

fPreferredDownload = false;

fPreferHeaders = false;

}

};

/** Map maintaining per-node state. Requires cs_main. */

map<NodeId, CNodeState> mapNodeState;

// Requires cs_main.

CNodeState *State(NodeId pnode) {

map<NodeId, CNodeState>::iterator it = mapNodeState.find(pnode);

if (it == mapNodeState.end())

return NULL;

return &it->second;

}

int GetHeight()

{

LOCK(cs_main);

return chainActive.Height();

}

void UpdatePreferredDownload(CNode* node, CNodeState* state)

{

nPreferredDownload -= state->fPreferredDownload;

// Whether this node should be marked as a preferred download node.

state->fPreferredDownload = (!node->fInbound || node->fWhitelisted) && !node->fOneShot && !node->fClient;

nPreferredDownload += state->fPreferredDownload;

}

void InitializeNode(NodeId nodeid, const CNode *pnode) {

LOCK(cs_main);

CNodeState &state = mapNodeState.insert(std::make_pair(nodeid, CNodeState())).first->second;

state.name = pnode->addrName;

state.address = pnode->addr;

}

void FinalizeNode(NodeId nodeid) {

LOCK(cs_main);

CNodeState *state = State(nodeid);

if (state->fSyncStarted)

nSyncStarted--;

if (state->nMisbehavior == 0 && state->fCurrentlyConnected) {

AddressCurrentlyConnected(state->address);

}

BOOST_FOREACH(const QueuedBlock& entry, state->vBlocksInFlight) {

mapBlocksInFlight.erase(entry.hash);

}

EraseOrphansFor(nodeid);

nPreferredDownload -= state->fPreferredDownload;

nPeersWithValidatedDownloads -= (state->nBlocksInFlightValidHeaders != 0);

assert(nPeersWithValidatedDownloads >= 0);

mapNodeState.erase(nodeid);

if (mapNodeState.empty()) {

// Do a consistency check after the last peer is removed.

assert(mapBlocksInFlight.empty());

assert(nPreferredDownload == 0);

assert(nPeersWithValidatedDownloads == 0);

}

}

// Requires cs_main.

// Returns a bool indicating whether we requested this block.

bool MarkBlockAsReceived(const uint256& hash) {

map<uint256, pair<NodeId, list<QueuedBlock>::iterator> >::iterator itInFlight = mapBlocksInFlight.find(hash);

if (itInFlight != mapBlocksInFlight.end()) {

CNodeState *state = State(itInFlight->second.first);

state->nBlocksInFlightValidHeaders -= itInFlight->second.second->fValidatedHeaders;

if (state->nBlocksInFlightValidHeaders == 0 && itInFlight->second.second->fValidatedHeaders) {

// Last validated block on the queue was received.

nPeersWithValidatedDownloads--;

}

if (state->vBlocksInFlight.begin() == itInFlight->second.second) {

// First block on the queue was received, update the start download time for the next one

state->nDownloadingSince = std::max(state->nDownloadingSince, GetTimeMicros());

}

state->vBlocksInFlight.erase(itInFlight->second.second);

state->nBlocksInFlight--;

state->nStallingSince = 0;

mapBlocksInFlight.erase(itInFlight);

return true;

}

return false;

}

// Requires cs_main.

void MarkBlockAsInFlight(NodeId nodeid, const uint256& hash, const Consensus::Params& consensusParams, CBlockIndex *pindex = NULL) {

CNodeState *state = State(nodeid);

assert(state != NULL);

// Make sure it's not listed somewhere already.

MarkBlockAsReceived(hash);

QueuedBlock newentry = {hash, pindex, pindex != NULL};

list<QueuedBlock>::iterator it = state->vBlocksInFlight.insert(state->vBlocksInFlight.end(), newentry);

state->nBlocksInFlight++;

state->nBlocksInFlightValidHeaders += newentry.fValidatedHeaders;

if (state->nBlocksInFlight == 1) {

// We're starting a block download (batch) from this peer.

state->nDownloadingSince = GetTimeMicros();

}

if (state->nBlocksInFlightValidHeaders == 1 && pindex != NULL) {

nPeersWithValidatedDownloads++;

}

mapBlocksInFlight[hash] = std::make_pair(nodeid, it);

}

/** Check whether the last unknown block a peer advertised is not yet known. */

void ProcessBlockAvailability(NodeId nodeid) {

CNodeState *state = State(nodeid);

assert(state != NULL);

if (!state->hashLastUnknownBlock.IsNull()) {

BlockMap::iterator itOld = mapBlockIndex.find(state->hashLastUnknownBlock);

if (itOld != mapBlockIndex.end() && itOld->second->nChainWork > 0) {

if (state->pindexBestKnownBlock == NULL || itOld->second->nChainWork >= state->pindexBestKnownBlock->nChainWork)

state->pindexBestKnownBlock = itOld->second;

state->hashLastUnknownBlock.SetNull();

}

}

}

/** Update tracking information about which blocks a peer is assumed to have. */

void UpdateBlockAvailability(NodeId nodeid, const uint256 &hash) {

CNodeState *state = State(nodeid);

assert(state != NULL);

ProcessBlockAvailability(nodeid);

BlockMap::iterator it = mapBlockIndex.find(hash);

if (it != mapBlockIndex.end() && it->second->nChainWork > 0) {

// An actually better block was announced.

if (state->pindexBestKnownBlock == NULL || it->second->nChainWork >= state->pindexBestKnownBlock->nChainWork)

state->pindexBestKnownBlock = it->second;

} else {

// An unknown block was announced; just assume that the latest one is the best one.

state->hashLastUnknownBlock = hash;

}

}

// Requires cs_main

bool CanDirectFetch(const Consensus::Params &consensusParams)

{

return chainActive.Tip()->GetBlockTime() > GetAdjustedTime() - consensusParams.nPowTargetSpacing * 20;

}

// Requires cs_main

bool PeerHasHeader(CNodeState *state, CBlockIndex *pindex)

{

if (state->pindexBestKnownBlock && pindex == state->pindexBestKnownBlock->GetAncestor(pindex->nHeight))

return true;

if (state->pindexBestHeaderSent && pindex == state->pindexBestHeaderSent->GetAncestor(pindex->nHeight))

return true;

return false;

}

/** Find the last common ancestor two blocks have.

* Both pa and pb must be non-NULL. */

CBlockIndex* LastCommonAncestor(CBlockIndex* pa, CBlockIndex* pb) {

if (pa->nHeight > pb->nHeight) {

pa = pa->GetAncestor(pb->nHeight);

} else if (pb->nHeight > pa->nHeight) {

pb = pb->GetAncestor(pa->nHeight);

}

while (pa != pb && pa && pb) {

pa = pa->pprev;

pb = pb->pprev;

}

// Eventually all chain branches meet at the genesis block.

assert(pa == pb);

return pa;

}

/** Update pindexLastCommonBlock and add not-in-flight missing successors to vBlocks, until it has

* at most count entries. */

void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::vector<CBlockIndex*>& vBlocks, NodeId& nodeStaller) {

if (count == 0)

return;

vBlocks.reserve(vBlocks.size() + count);

CNodeState *state = State(nodeid);

assert(state != NULL);

// Make sure pindexBestKnownBlock is up to date, we'll need it.

ProcessBlockAvailability(nodeid);

if (state->pindexBestKnownBlock == NULL || state->pindexBestKnownBlock->nChainWork < chainActive.Tip()->nChainWork) {

// This peer has nothing interesting.

return;

}

if (state->pindexLastCommonBlock == NULL) {

// Bootstrap quickly by guessing a parent of our best tip is the forking point.

// Guessing wrong in either direction is not a problem.

state->pindexLastCommonBlock = chainActive[std::min(state->pindexBestKnownBlock->nHeight, chainActive.Height())];

}

// If the peer reorganized, our previous pindexLastCommonBlock may not be an ancestor

// of its current tip anymore. Go back enough to fix that.

state->pindexLastCommonBlock = LastCommonAncestor(state->pindexLastCommonBlock, state->pindexBestKnownBlock);

if (state->pindexLastCommonBlock == state->pindexBestKnownBlock)

return;

std::vector<CBlockIndex*> vToFetch;

CBlockIndex *pindexWalk = state->pindexLastCommonBlock;

// Never fetch further than the best block we know the peer has, or more than BLOCK_DOWNLOAD_WINDOW + 1 beyond the last

// linked block we have in common with this peer. The +1 is so we can detect stalling, namely if we would be able to

// download that next block if the window were 1 larger.

int nWindowEnd = state->pindexLastCommonBlock->nHeight + BLOCK_DOWNLOAD_WINDOW;

int nMaxHeight = std::min<int>(state->pindexBestKnownBlock->nHeight, nWindowEnd + 1);

NodeId waitingfor = -1;

while (pindexWalk->nHeight < nMaxHeight) {

// Read up to 128 (or more, if more blocks than that are needed) successors of pindexWalk (towards

// pindexBestKnownBlock) into vToFetch. We fetch 128, because CBlockIndex::GetAncestor may be as expensive

// as iterating over ~100 CBlockIndex* entries anyway.

int nToFetch = std::min(nMaxHeight - pindexWalk->nHeight, std::max<int>(count - vBlocks.size(), 128));

vToFetch.resize(nToFetch);

pindexWalk = state->pindexBestKnownBlock->GetAncestor(pindexWalk->nHeight + nToFetch);

vToFetch[nToFetch - 1] = pindexWalk;

for (unsigned int i = nToFetch - 1; i > 0; i--) {

vToFetch[i - 1] = vToFetch[i]->pprev;

}

// Iterate over those blocks in vToFetch (in forward direction), adding the ones that

// are not yet downloaded and not in flight to vBlocks. In the mean time, update

// pindexLastCommonBlock as long as all ancestors are already downloaded, or if it's

// already part of our chain (and therefore don't need it even if pruned).

BOOST_FOREACH(CBlockIndex* pindex, vToFetch) {

if (!pindex->IsValid(BLOCK_VALID_TREE)) {

// We consider the chain that this peer is on invalid.

return;

}

if (pindex->nStatus & BLOCK_HAVE_DATA || chainActive.Contains(pindex)) {

if (pindex->nChainTx)

state->pindexLastCommonBlock = pindex;

} else if (mapBlocksInFlight.count(pindex->GetBlockHash()) == 0) {

// The block is not already downloaded, and not yet in flight.

if (pindex->nHeight > nWindowEnd) {

// We reached the end of the window.

if (vBlocks.size() == 0 && waitingfor != nodeid) {

// We aren't able to fetch anything, but we would be if the download window was one larger.

nodeStaller = waitingfor;

}

return;

}

vBlocks.push_back(pindex);

if (vBlocks.size() == count) {

return;

}

} else if (waitingfor == -1) {

// This is the first already-in-flight block.

waitingfor = mapBlocksInFlight[pindex->GetBlockHash()].first;

}

}

}

}

} // anon namespace

bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) {

LOCK(cs_main);

CNodeState *state = State(nodeid);

if (state == NULL)

return false;

stats.nMisbehavior = state->nMisbehavior;

stats.nSyncHeight = state->pindexBestKnownBlock ? state->pindexBestKnownBlock->nHeight : -1;

stats.nCommonHeight = state->pindexLastCommonBlock ? state->pindexLastCommonBlock->nHeight : -1;

BOOST_FOREACH(const QueuedBlock& queue, state->vBlocksInFlight) {

if (queue.pindex)

stats.vHeightInFlight.push_back(queue.pindex->nHeight);

}

return true;

}

void RegisterNodeSignals(CNodeSignals& nodeSignals)

{

nodeSignals.GetHeight.connect(&GetHeight);

nodeSignals.ProcessMessages.connect(&ProcessMessages);

nodeSignals.SendMessages.connect(&SendMessages);

nodeSignals.InitializeNode.connect(&InitializeNode);

nodeSignals.FinalizeNode.connect(&FinalizeNode);

}

void UnregisterNodeSignals(CNodeSignals& nodeSignals)

{

nodeSignals.GetHeight.disconnect(&GetHeight);

nodeSignals.ProcessMessages.disconnect(&ProcessMessages);

nodeSignals.SendMessages.disconnect(&SendMessages);

nodeSignals.InitializeNode.disconnect(&InitializeNode);

nodeSignals.FinalizeNode.disconnect(&FinalizeNode);

}

CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& locator)

{

// Find the first block the caller has in the main chain

BOOST_FOREACH(const uint256& hash, locator.vHave) {

BlockMap::iterator mi = mapBlockIndex.find(hash);

if (mi != mapBlockIndex.end())

{

CBlockIndex* pindex = (*mi).second;

if (chain.Contains(pindex))

return pindex;

}

}

return chain.Genesis();

}

CCoinsViewCache *pcoinsTip = NULL;

CBlockTreeDB *pblocktree = NULL;

//////////////////////////////////////////////////////////////////////////////

//

// mapOrphanTransactions

//

bool AddOrphanTx(const CTransaction& tx, NodeId peer) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

uint256 hash = tx.GetHash();

if (mapOrphanTransactions.count(hash))

return false;

// Ignore big transactions, to avoid a

// send-big-orphans memory exhaustion attack. If a peer has a legitimate

// large transaction with a missing parent then we assume

// it will rebroadcast it later, after the parent transaction(s)

// have been mined or received.

// 10,000 orphans, each of which is at most 5,000 bytes big is

// at most 500 megabytes of orphans:

unsigned int sz = tx.GetSerializeSize(SER_NETWORK, CTransaction::CURRENT_VERSION);

if (sz > 5000)

{

LogPrint("mempool", "ignoring large orphan tx (size: %u, hash: %s)\n", sz, hash.ToString());

return false;

}

mapOrphanTransactions[hash].tx = tx;

mapOrphanTransactions[hash].fromPeer = peer;

BOOST_FOREACH(const CTxIn& txin, tx.vin)

mapOrphanTransactionsByPrev[txin.prevout.hash].insert(hash);

LogPrint("mempool", "stored orphan tx %s (mapsz %u prevsz %u)\n", hash.ToString(),

mapOrphanTransactions.size(), mapOrphanTransactionsByPrev.size());

return true;

}

void static EraseOrphanTx(uint256 hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

map<uint256, COrphanTx>::iterator it = mapOrphanTransactions.find(hash);

if (it == mapOrphanTransactions.end())

return;

BOOST_FOREACH(const CTxIn& txin, it->second.tx.vin)

{

map<uint256, set<uint256> >::iterator itPrev = mapOrphanTransactionsByPrev.find(txin.prevout.hash);

if (itPrev == mapOrphanTransactionsByPrev.end())

continue;

itPrev->second.erase(hash);

if (itPrev->second.empty())

mapOrphanTransactionsByPrev.erase(itPrev);

}

mapOrphanTransactions.erase(it);

}

void EraseOrphansFor(NodeId peer)

{

int nErased = 0;

map<uint256, COrphanTx>::iterator iter = mapOrphanTransactions.begin();

while (iter != mapOrphanTransactions.end())

{

map<uint256, COrphanTx>::iterator maybeErase = iter++; // increment to avoid iterator becoming invalid

if (maybeErase->second.fromPeer == peer)

{

EraseOrphanTx(maybeErase->second.tx.GetHash());

++nErased;

}

}

if (nErased > 0) LogPrint("mempool", "Erased %d orphan tx from peer %d\n", nErased, peer);

}

unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

unsigned int nEvicted = 0;

while (mapOrphanTransactions.size() > nMaxOrphans)

{

// Evict a random orphan:

uint256 randomhash = GetRandHash();

map<uint256, COrphanTx>::iterator it = mapOrphanTransactions.lower_bound(randomhash);

if (it == mapOrphanTransactions.end())

it = mapOrphanTransactions.begin();

EraseOrphanTx(it->first);

++nEvicted;

}

return nEvicted;

}

bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)

{

if (tx.nLockTime == 0)

return true;

if ((int64_t)tx.nLockTime < ((int64_t)tx.nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))

return true;

BOOST_FOREACH(const CTxIn& txin, tx.vin) {

if (!(txin.nSequence == CTxIn::SEQUENCE_FINAL))

return false;

}

return true;

}

bool CheckFinalTx(const CTransaction &tx, int flags)

{

AssertLockHeld(cs_main);

// By convention a negative value for flags indicates that the

// current network-enforced consensus rules should be used. In

// a future soft-fork scenario that would mean checking which

// rules would be enforced for the next block and setting the

// appropriate flags. At the present time no soft-forks are

// scheduled, so no flags are set.

flags = std::max(flags, 0);

// CheckFinalTx() uses chainActive.Height()+1 to evaluate

// nLockTime because when IsFinalTx() is called within

// CBlock::AcceptBlock(), the height of the block *being*

// evaluated is what is used. Thus if we want to know if a

// transaction can be part of the *next* block, we need to call

// IsFinalTx() with one more than chainActive.Height().

const int nBlockHeight = chainActive.Height() + 1;

// BIP113 will require that time-locked transactions have nLockTime set to

// less than the median time of the previous block they're contained in.

// When the next block is created its previous block will be the current

// chain tip, so we use that to calculate the median time passed to

// IsFinalTx() if LOCKTIME_MEDIAN_TIME_PAST is set.

const int64_t nBlockTime = (flags & LOCKTIME_MEDIAN_TIME_PAST)

? chainActive.Tip()->GetMedianTimePast()

: GetAdjustedTime();

return IsFinalTx(tx, nBlockHeight, nBlockTime);

}

/**

* Calculates the block height and previous block's median time past at

* which the transaction will be considered final in the context of BIP 68.

* Also removes from the vector of input heights any entries which did not

* correspond to sequence locked inputs as they do not affect the calculation.

*/

static std::pair<int, int64_t> CalculateSequenceLocks(const CTransaction &tx, int flags, std::vector<int>* prevHeights, const CBlockIndex& block)

{

assert(prevHeights->size() == tx.vin.size());

// Will be set to the equivalent height- and time-based nLockTime

// values that would be necessary to satisfy all relative lock-

// time constraints given our view of block chain history.

// The semantics of nLockTime are the last invalid height/time, so

// use -1 to have the effect of any height or time being valid.

int nMinHeight = -1;

int64_t nMinTime = -1;

// tx.nVersion is signed integer so requires cast to unsigned otherwise

// we would be doing a signed comparison and half the range of nVersion

// wouldn't support BIP 68.

bool fEnforceBIP68 = static_cast<uint32_t>(tx.nVersion) >= 2

&& flags & LOCKTIME_VERIFY_SEQUENCE;

// Do not enforce sequence numbers as a relative lock time

// unless we have been instructed to

if (!fEnforceBIP68) {

return std::make_pair(nMinHeight, nMinTime);

}

for (size_t txinIndex = 0; txinIndex < tx.vin.size(); txinIndex++) {

const CTxIn& txin = tx.vin[txinIndex];

// Sequence numbers with the most significant bit set are not

// treated as relative lock-times, nor are they given any

// consensus-enforced meaning at this point.

if (txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) {

// The height of this input is not relevant for sequence locks

(*prevHeights)[txinIndex] = 0;

continue;

}

int nCoinHeight = (*prevHeights)[txinIndex];

if (txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG) {

int64_t nCoinTime = block.GetAncestor(std::max(nCoinHeight-1, 0))->GetMedianTimePast();

// NOTE: Subtract 1 to maintain nLockTime semantics

// BIP 68 relative lock times have the semantics of calculating

// the first block or time at which the transaction would be

// valid. When calculating the effective block time or height

// for the entire transaction, we switch to using the

// semantics of nLockTime which is the last invalid block

// time or height. Thus we subtract 1 from the calculated

// time or height.

// Time-based relative lock-times are measured from the

// smallest allowed timestamp of the block containing the

// txout being spent, which is the median time past of the

// block prior.

nMinTime = std::max(nMinTime, nCoinTime + (int64_t)((txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) << CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) - 1);

} else {

nMinHeight = std::max(nMinHeight, nCoinHeight + (int)(txin.nSequence & CTxIn::SEQUENCE_LOCKTIME_MASK) - 1);

}

}

return std::make_pair(nMinHeight, nMinTime);

}

static bool EvaluateSequenceLocks(const CBlockIndex& block, std::pair<int, int64_t> lockPair)

{

assert(block.pprev);

int64_t nBlockTime = block.pprev->GetMedianTimePast();

if (lockPair.first >= block.nHeight || lockPair.second >= nBlockTime)

return false;

return true;

}

bool SequenceLocks(const CTransaction &tx, int flags, std::vector<int>* prevHeights, const CBlockIndex& block)

{

return EvaluateSequenceLocks(block, CalculateSequenceLocks(tx, flags, prevHeights, block));

}

bool TestLockPointValidity(const LockPoints* lp)

{

AssertLockHeld(cs_main);

assert(lp);

// If there are relative lock times then the maxInputBlock will be set

// If there are no relative lock times, the LockPoints don't depend on the chain

if (lp->maxInputBlock) {

// Check whether chainActive is an extension of the block at which the LockPoints

// calculation was valid. If not LockPoints are no longer valid

if (!chainActive.Contains(lp->maxInputBlock)) {

return false;

}

}

// LockPoints still valid

return true;

}

bool CheckSequenceLocks(const CTransaction &tx, int flags, LockPoints* lp, bool useExistingLockPoints)

{

AssertLockHeld(cs_main);

AssertLockHeld(mempool.cs);

CBlockIndex* tip = chainActive.Tip();

CBlockIndex index;

index.pprev = tip;

// CheckSequenceLocks() uses chainActive.Height()+1 to evaluate

// height based locks because when SequenceLocks() is called within

// ConnectBlock(), the height of the block *being*

// evaluated is what is used.

// Thus if we want to know if a transaction can be part of the

// *next* block, we need to use one more than chainActive.Height()

index.nHeight = tip->nHeight + 1;

std::pair<int, int64_t> lockPair;

if (useExistingLockPoints) {

assert(lp);

lockPair.first = lp->height;

lockPair.second = lp->time;

}

else {

// pcoinsTip contains the UTXO set for chainActive.Tip()

CCoinsViewMemPool viewMemPool(pcoinsTip, mempool);

std::vector<int> prevheights;

prevheights.resize(tx.vin.size());

for (size_t txinIndex = 0; txinIndex < tx.vin.size(); txinIndex++) {

const CTxIn& txin = tx.vin[txinIndex];

CCoins coins;

if (!viewMemPool.GetCoins(txin.prevout.hash, coins)) {

return error("%s: Missing input", __func__);

}

if (coins.nHeight == MEMPOOL_HEIGHT) {

// Assume all mempool transaction confirm in the next block

prevheights[txinIndex] = tip->nHeight + 1;

} else {

prevheights[txinIndex] = coins.nHeight;

}

}

lockPair = CalculateSequenceLocks(tx, flags, &prevheights, index);

if (lp) {

lp->height = lockPair.first;

lp->time = lockPair.second;

// Also store the hash of the block with the highest height of

// all the blocks which have sequence locked prevouts.

// This hash needs to still be on the chain

// for these LockPoint calculations to be valid

// Note: It is impossible to correctly calculate a maxInputBlock

// if any of the sequence locked inputs depend on unconfirmed txs,

// except in the special case where the relative lock time/height

// is 0, which is equivalent to no sequence lock. Since we assume

// input height of tip+1 for mempool txs and test the resulting

// lockPair from CalculateSequenceLocks against tip+1. We know

// EvaluateSequenceLocks will fail if there was a non-zero sequence

// lock on a mempool input, so we can use the return value of

// CheckSequenceLocks to indicate the LockPoints validity

int maxInputHeight = 0;

BOOST_FOREACH(int height, prevheights) {

// Can ignore mempool inputs since we'll fail if they had non-zero locks

if (height != tip->nHeight+1) {

maxInputHeight = std::max(maxInputHeight, height);

}

}

lp->maxInputBlock = tip->GetAncestor(maxInputHeight);

}

}

return EvaluateSequenceLocks(index, lockPair);

}

unsigned int GetLegacySigOpCount(const CTransaction& tx)

{

unsigned int nSigOps = 0;

BOOST_FOREACH(const CTxIn& txin, tx.vin)

{

nSigOps += txin.scriptSig.GetSigOpCount(false);

}

BOOST_FOREACH(const CTxOut& txout, tx.vout)

{

nSigOps += txout.scriptPubKey.GetSigOpCount(false);

}

return nSigOps;

}

unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewCache& inputs)

{

if (tx.IsCoinBase())

return 0;

unsigned int nSigOps = 0;

for (unsigned int i = 0; i < tx.vin.size(); i++)

{

const CTxOut &prevout = inputs.GetOutputFor(tx.vin[i]);

if (prevout.scriptPubKey.IsPayToScriptHash())

nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);

}

return nSigOps;

}

bool CheckTransaction(const CTransaction& tx, CValidationState &state)

{

// Basic checks that don't depend on any context

if (tx.vin.empty())

return state.DoS(10, false, REJECT_INVALID, "bad-txns-vin-empty");

if (tx.vout.empty())

return state.DoS(10, false, REJECT_INVALID, "bad-txns-vout-empty");

// Size limits

if (::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION) > MAX_BLOCK_SIZE)

return state.DoS(100, false, REJECT_INVALID, "bad-txns-oversize");

// Check for negative or overflow output values

CAmount nValueOut = 0;

BOOST_FOREACH(const CTxOut& txout, tx.vout)

{

if (txout.nValue < 0)

return state.DoS(100, false, REJECT_INVALID, "bad-txns-vout-negative");

if (txout.nValue > MAX_MONEY)

return state.DoS(100, false, REJECT_INVALID, "bad-txns-vout-toolarge");

nValueOut += txout.nValue;

if (!MoneyRange(nValueOut))

return state.DoS(100, false, REJECT_INVALID, "bad-txns-txouttotal-toolarge");

}

// Check for duplicate inputs

set<COutPoint> vInOutPoints;

BOOST_FOREACH(const CTxIn& txin, tx.vin)

{

if (vInOutPoints.count(txin.prevout))

return state.DoS(100, false, REJECT_INVALID, "bad-txns-inputs-duplicate");

vInOutPoints.insert(txin.prevout);

}

if (tx.IsCoinBase())

{

if (tx.vin[0].scriptSig.size() < 2 || tx.vin[0].scriptSig.size() > 100)

return state.DoS(100, false, REJECT_INVALID, "bad-cb-length");

}

else

{

BOOST_FOREACH(const CTxIn& txin, tx.vin)

if (txin.prevout.IsNull())

return state.DoS(10, false, REJECT_INVALID, "bad-txns-prevout-null");

}

return true;

}

void LimitMempoolSize(CTxMemPool& pool, size_t limit, unsigned long age) {

int expired = pool.Expire(GetTime() - age);

if (expired != 0)

LogPrint("mempool", "Expired %i transactions from the memory pool\n", expired);

std::vector<uint256> vNoSpendsRemaining;

pool.TrimToSize(limit, &vNoSpendsRemaining);

BOOST_FOREACH(const uint256& removed, vNoSpendsRemaining)

pcoinsTip->Uncache(removed);

}

/** Convert CValidationState to a human-readable message for logging */

std::string FormatStateMessage(const CValidationState &state)

{

return strprintf("%s%s (code %i)",

state.GetRejectReason(),