// Copyright (c) 2009-2010 Satoshi Nakamoto

// Copyright (c) 2009-2014 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/validation.h"

#include "init.h"

#include "merkleblock.h"

#include "net.h"

#include "pow.h"

#include "txdb.h"

#include "txmempool.h"

#include "ui_interface.h"

#include "undo.h"

#include "util.h"

#include "utilmoneystr.h"

#include "validationinterface.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 = true;

bool fCheckBlockIndex = false;

bool fCheckpointsEnabled = true;

size_t nCoinCacheUsage = 5000 * 300;

uint64_t nPruneTarget = 0;

bool fAlerts = DEFAULT_ALERTS;

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

CFeeRate minRelayTxFee = CFeeRate(5000);

CTxMemPool mempool(::minRelayTxFee);

struct COrphanTx {

CTransaction tx;

NodeId fromPeer;

};

map<uint256, COrphanTx> mapOrphanTransactions;

map<uint256, set<uint256> > mapOrphanTransactionsByPrev;

void EraseOrphansFor(NodeId peer);

/**

* 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();

/** 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 if 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.

int64_t nTime; //! Time of "getdata" request in microseconds.

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

int64_t nTimeDisconnect; //! The timeout for this block request (for disconnecting a slow peer)

};

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

/** Number of blocks in flight with validated headers. */

int nQueuedValidatedHeaders = 0;

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

int nPreferredDownload = 0;

/** Dirty block index entries. */

set<CBlockIndex*> setDirtyBlockIndex;

/** Dirty block file entries. */

set<int> setDirtyFileInfo;

} // 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;

//! 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;

int nBlocksInFlight;

int nBlocksInFlightValidHeaders;

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

bool fPreferredDownload;

CNodeState() {

fCurrentlyConnected = false;

nMisbehavior = 0;

fShouldBan = false;

pindexBestKnownBlock = NULL;

hashLastUnknownBlock.SetNull();

pindexLastCommonBlock = NULL;

fSyncStarted = false;

nStallingSince = 0;

nBlocksInFlight = 0;

nBlocksInFlightValidHeaders = 0;

fPreferredDownload = 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;

}

// Returns time at which to timeout block request (nTime in microseconds)

int64_t GetBlockTimeout(int64_t nTime, int nValidatedQueuedBefore, const Consensus::Params &consensusParams)

{

return nTime + 500000 * consensusParams.nPowTargetSpacing * (4 + nValidatedQueuedBefore);

}

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;

mapNodeState.erase(nodeid);

}

// 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);

nQueuedValidatedHeaders -= itInFlight->second.second->fValidatedHeaders;

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

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);

int64_t nNow = GetTimeMicros();

QueuedBlock newentry = {hash, pindex, nNow, pindex != NULL, GetBlockTimeout(nNow, nQueuedValidatedHeaders, consensusParams)};

nQueuedValidatedHeaders += newentry.fValidatedHeaders;

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

state->nBlocksInFlight++;

state->nBlocksInFlightValidHeaders += newentry.fValidatedHeaders;

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

}

/** Check whether the last unknown block a peer advertized 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;

}

}

/** 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)

{

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)

{

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)

{

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 IsStandardTx(const CTransaction& tx, string& reason)

{

if (tx.nVersion > CTransaction::CURRENT_VERSION || tx.nVersion < 1) {

reason = "version";

return false;

}

// Extremely large transactions with lots of inputs can cost the network

// almost as much to process as they cost the sender in fees, because

// computing signature hashes is O(ninputs*txsize). Limiting transactions

// to MAX_STANDARD_TX_SIZE mitigates CPU exhaustion attacks.

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

if (sz >= MAX_STANDARD_TX_SIZE) {

reason = "tx-size";

return false;

}

BOOST_FOREACH(const CTxIn& txin, tx.vin)

{

// Biggest 'standard' txin is a 15-of-15 P2SH multisig with compressed

// keys. (remember the 520 byte limit on redeemScript size) That works

// out to a (15*(33+1))+3=513 byte redeemScript, 513+1+15*(73+1)+3=1627

// bytes of scriptSig, which we round off to 1650 bytes for some minor

// future-proofing. That's also enough to spend a 20-of-20

// CHECKMULTISIG scriptPubKey, though such a scriptPubKey is not

// considered standard)

if (txin.scriptSig.size() > 1650) {

reason = "scriptsig-size";

return false;

}

if (!txin.scriptSig.IsPushOnly()) {

reason = "scriptsig-not-pushonly";

return false;

}

}

unsigned int nDataOut = 0;

txnouttype whichType;

BOOST_FOREACH(const CTxOut& txout, tx.vout) {

if (!::IsStandard(txout.scriptPubKey, whichType)) {

reason = "scriptpubkey";

return false;

}

if (whichType == TX_NULL_DATA)

nDataOut++;

else if ((whichType == TX_MULTISIG) && (!fIsBareMultisigStd)) {

reason = "bare-multisig";

return false;

} else if (txout.IsDust(::minRelayTxFee)) {

reason = "dust";

return false;

}

}

// only one OP_RETURN txout is permitted

if (nDataOut > 1) {

reason = "multi-op-return";

return false;

}

return true;

}

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.IsFinal())

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;

// Timestamps on the other hand don't get any special treatment,

// because we can't know what timestamp the next block will have,

// and there aren't timestamp applications where it matters.

// However this changes once median past time-locks are enforced:

const int64_t nBlockTime = (flags & LOCKTIME_MEDIAN_TIME_PAST)

? chainActive.Tip()->GetMedianTimePast()

: GetAdjustedTime();

return IsFinalTx(tx, nBlockHeight, nBlockTime);

}

/**

* Check transaction inputs to mitigate two

* potential denial-of-service attacks:

*

* 1. scriptSigs with extra data stuffed into them,

* not consumed by scriptPubKey (or P2SH script)

* 2. P2SH scripts with a crazy number of expensive

* CHECKSIG/CHECKMULTISIG operations

*/

bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)

{

if (tx.IsCoinBase())

return true; // Coinbases don't use vin normally

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

{

const CTxOut& prev = mapInputs.GetOutputFor(tx.vin[i]);

vector<vector<unsigned char> > vSolutions;

txnouttype whichType;

// get the scriptPubKey corresponding to this input:

const CScript& prevScript = prev.scriptPubKey;

if (!Solver(prevScript, whichType, vSolutions))

return false;

int nArgsExpected = ScriptSigArgsExpected(whichType, vSolutions);

if (nArgsExpected < 0)

return false;

// Transactions with extra stuff in their scriptSigs are

// non-standard. Note that this EvalScript() call will

// be quick, because if there are any operations

// beside "push data" in the scriptSig

// IsStandardTx() will have already returned false

// and this method isn't called.

vector<vector<unsigned char> > stack;

if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker()))

return false;

if (whichType == TX_SCRIPTHASH)

{

if (stack.empty())

return false;

CScript subscript(stack.back().begin(), stack.back().end());

vector<vector<unsigned char> > vSolutions2;

txnouttype whichType2;

if (Solver(subscript, whichType2, vSolutions2))

{

int tmpExpected = ScriptSigArgsExpected(whichType2, vSolutions2);

if (tmpExpected < 0)

return false;

nArgsExpected += tmpExpected;

}

else

{

// Any other Script with less than 15 sigops OK:

unsigned int sigops = subscript.GetSigOpCount(true);

// ... extra data left on the stack after execution is OK, too:

return (sigops <= MAX_P2SH_SIGOPS);

}

}

if (stack.size() != (unsigned int)nArgsExpected)

return false;

}

return true;

}

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, error("CheckTransaction(): vin empty"),

REJECT_INVALID, "bad-txns-vin-empty");

if (tx.vout.empty())

return state.DoS(10, error("CheckTransaction(): vout empty"),

REJECT_INVALID, "bad-txns-vout-empty");

// Size limits

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

return state.DoS(100, error("CheckTransaction(): size limits failed"),

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, error("CheckTransaction(): txout.nValue negative"),

REJECT_INVALID, "bad-txns-vout-negative");

if (txout.nValue > MAX_MONEY)

return state.DoS(100, error("CheckTransaction(): txout.nValue too high"),

REJECT_INVALID, "bad-txns-vout-toolarge");

nValueOut += txout.nValue;

if (!MoneyRange(nValueOut))

return state.DoS(100, error("CheckTransaction(): txout total out of range"),

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, error("CheckTransaction(): duplicate inputs"),

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, error("CheckTransaction(): coinbase script size"),

REJECT_INVALID, "bad-cb-length");

}

else

{

BOOST_FOREACH(const CTxIn& txin, tx.vin)

if (txin.prevout.IsNull())

return state.DoS(10, error("CheckTransaction(): prevout is null"),

REJECT_INVALID, "bad-txns-prevout-null");

}

return true;

}

CAmount GetMinRelayFee(const CTransaction& tx, unsigned int nBytes, bool fAllowFree)

{

{

LOCK(mempool.cs);

uint256 hash = tx.GetHash();

double dPriorityDelta = 0;

CAmount nFeeDelta = 0;

mempool.ApplyDeltas(hash, dPriorityDelta, nFeeDelta);

if (dPriorityDelta > 0 || nFeeDelta > 0)

return 0;

}

CAmount nMinFee = ::minRelayTxFee.GetFee(nBytes);

if (fAllowFree)

{

// There is a free transaction area in blocks created by most miners,

// * If we are relaying we allow transactions up to DEFAULT_BLOCK_PRIORITY_SIZE - 1000

// to be considered to fall into this category. We don't want to encourage sending

// multiple transactions instead of one big transaction to avoid fees.

if (nBytes < (DEFAULT_BLOCK_PRIORITY_SIZE - 1000))

nMinFee = 0;

}

if (!MoneyRange(nMinFee))

nMinFee = MAX_MONEY;

return nMinFee;

}

bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransaction &tx, bool fLimitFree,

bool* pfMissingInputs, bool fRejectAbsurdFee)

{

AssertLockHeld(cs_main);

if (pfMissingInputs)

*pfMissingInputs = false;

if (!CheckTransaction(tx, state))

return error("AcceptToMemoryPool: CheckTransaction failed");

// Coinbase is only valid in a block, not as a loose transaction

if (tx.IsCoinBase())

return state.DoS(100, error("AcceptToMemoryPool: coinbase as individual tx"),

REJECT_INVALID, "coinbase");

// Rather not work on nonstandard transactions (unless -testnet/-regtest)

string reason;

if (Params().RequireStandard() && !IsStandardTx(tx, reason))

return state.DoS(0,

error("AcceptToMemoryPool: nonstandard transaction: %s", reason),

REJECT_NONSTANDARD, reason);

// Only accept nLockTime-using transactions that can be mined in the next

// block; we don't want our mempool filled up with transactions that can't

// be mined yet.

if (!CheckFinalTx(tx, STANDARD_LOCKTIME_VERIFY_FLAGS))

return state.DoS(0, false, REJECT_NONSTANDARD, "non-final");

// is it already in the memory pool?

uint256 hash = tx.GetHash();

if (pool.exists(hash))

return false;

// Check for conflicts with in-memory transactions

{

LOCK(pool.cs); // protect pool.mapNextTx

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

{

COutPoint outpoint = tx.vin[i].prevout;

if (pool.mapNextTx.count(outpoint))

{

// Disable replacement feature for now

return false;

}

}

}

{

CCoinsView dummy;

CCoinsViewCache view(&dummy);

CAmount nValueIn = 0;

{

LOCK(pool.cs);

CCoinsViewMemPool viewMemPool(pcoinsTip, pool);

view.SetBackend(viewMemPool);

// do we already have it?

if (view.HaveCoins(hash))

return false;

// do all inputs exist?

// Note that this does not check for the presence of actual outputs (see the next check for that),

// and only helps with filling in pfMissingInputs (to determine missing vs spent).

BOOST_FOREACH(const CTxIn txin, tx.vin) {

if (!view.HaveCoins(txin.prevout.hash)) {

if (pfMissingInputs)