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;

}

uint256 hash;

CBlockIndex* pindex; //! Optional.

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

int nValidatedQueuedBefore; //! Number of blocks queued with validated headers (globally) at the time this one is requested.

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

/** Notifies listeners of updated transaction data (transaction, and optionally the block it is found in. */

boost::signals2::signal<void(const CTransaction&, const CBlock*)> SyncTransaction;

/** Notifies listeners of an erased transaction (currently disabled, requires transaction replacement). */

/** Notifies listeners of an updated transaction without new data (for now: a coinbase potentially becoming visible). */

boost::signals2::signal<void(const uint256&)> UpdatedTransaction;

/** Notifies listeners of a new active block chain. */

boost::signals2::signal<void(const CBlockLocator&)> SetBestChain;

/** Notifies listeners about an inventory item being seen on the network. */

boost::signals2::signal<void(const uint256&)> Inventory;

/** Tells listeners to broadcast their data. */

boost::signals2::signal<void()> Broadcast;

/** Notifies listeners of a block validation result */

boost::signals2::signal<void(const CBlock&, const CValidationState&)> BlockChecked;

{

g_signals.SyncTransaction.connect(boost::bind(&CValidationInterface::SyncTransaction, pwalletIn, _1, _2));

g_signals.UpdatedTransaction.connect(boost::bind(&CValidationInterface::UpdatedTransaction, pwalletIn, _1));

g_signals.SetBestChain.connect(boost::bind(&CValidationInterface::SetBestChain, pwalletIn, _1));

g_signals.Inventory.connect(boost::bind(&CValidationInterface::Inventory, pwalletIn, _1));

g_signals.Broadcast.connect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn));

g_signals.BlockChecked.connect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, _1, _2));

{

g_signals.BlockChecked.disconnect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, _1, _2));

g_signals.Broadcast.disconnect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn));

g_signals.Inventory.disconnect(boost::bind(&CValidationInterface::Inventory, pwalletIn, _1));

g_signals.SetBestChain.disconnect(boost::bind(&CValidationInterface::SetBestChain, pwalletIn, _1));

g_signals.UpdatedTransaction.disconnect(boost::bind(&CValidationInterface::UpdatedTransaction, pwalletIn, _1));

g_signals.SyncTransaction.disconnect(boost::bind(&CValidationInterface::SyncTransaction, pwalletIn, _1, _2));

{

g_signals.BlockChecked.disconnect_all_slots();

g_signals.Broadcast.disconnect_all_slots();

g_signals.Inventory.disconnect_all_slots();

g_signals.SetBestChain.disconnect_all_slots();

g_signals.UpdatedTransaction.disconnect_all_slots();

g_signals.SyncTransaction.disconnect_all_slots();

unsigned char chRejectCode;

string strRejectReason;

uint256 hashBlock;

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

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

bool fPreferredDownload;

CNodeState()

{

fCurrentlyConnected = false;

nMisbehavior = 0;

fShouldBan = false;

pindexBestKnownBlock = NULL;

hashLastUnknownBlock = uint256(0);

pindexLastCommonBlock = NULL;

fSyncStarted = false;

nStallingSince = 0;

nBlocksInFlight = 0;

fPreferredDownload = false;

}

{

while (true) {

TRY_LOCK(cs_main, lockMain);

if (!lockMain) {

MilliSleep(50);

continue;

}

return chainActive.Height();

}

{

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;

{

LOCK(cs_main);

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

state.name = pnode->addrName;

state.address = pnode->addr;

{

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

{

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->vBlocksInFlight.erase(itInFlight->second.second);

state->nBlocksInFlight--;

state->nStallingSince = 0;

mapBlocksInFlight.erase(itInFlight);

}

{

CNodeState* state = State(nodeid);

assert(state != NULL);

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

MarkBlockAsReceived(hash);

QueuedBlock newentry = {hash, pindex, GetTimeMicros(), nQueuedValidatedHeaders, pindex != NULL};

nQueuedValidatedHeaders += newentry.fValidatedHeaders;

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

state->nBlocksInFlight++;

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

{

CNodeState* state = State(nodeid);

assert(state != NULL);

if (state->hashLastUnknownBlock != 0) {

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 = uint256(0);

}

}

{

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;

}

{

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 their 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.

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

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;

}

}

}

{

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;

{

nodeSignals.GetHeight.connect(&GetHeight);

nodeSignals.ProcessMessages.connect(&ProcessMessages);

nodeSignals.SendMessages.connect(&SendMessages);

nodeSignals.InitializeNode.connect(&InitializeNode);

nodeSignals.FinalizeNode.connect(&FinalizeNode);

{

nodeSignals.GetHeight.disconnect(&GetHeight);

nodeSignals.ProcessMessages.disconnect(&ProcessMessages);

nodeSignals.SendMessages.disconnect(&SendMessages);

nodeSignals.InitializeNode.disconnect(&InitializeNode);

nodeSignals.FinalizeNode.disconnect(&FinalizeNode);

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

if (mi != mapBlockIndex.end()) {

CBlockIndex* pindex = (*mi).second;

if (chain.Contains(pindex))

return pindex;

}

{

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;

{

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

{

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

{

AssertLockHeld(cs_main);

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

reason = "version";

return false;

}

// Treat non-final transactions as non-standard to prevent a specific type

// of double-spend attack, as well as DoS attacks. (if the transaction

// can't be mined, the attacker isn't expending resources broadcasting it)

// Basically we don't want to propagate transactions that can't be included in

// the next block.

//

// However, IsFinalTx() is confusing... Without arguments, it uses

// chainActive.Height() to evaluate nLockTime; when a block is accepted, chainActive.Height()

// is set to the value of nHeight in the block. However, 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().

//

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

if (!IsFinalTx(tx, chainActive.Height() + 1)) {

reason = "non-final";

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;

{

AssertLockHeld(cs_main);

// Time based nLockTime implemented in 0.1.6

if (tx.nLockTime == 0)

return true;

if (nBlockHeight == 0)

nBlockHeight = chainActive.Height();

if (nBlockTime == 0)

nBlockTime = GetAdjustedTime();

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;

{

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

// IsStandard() will have already returned false

// and this method isn't called.

vector<vector<unsigned char> > stack;

if (!EvalScript(stack, tx.vin[i].scriptSig, false, 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 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;

{

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;

{

CCoinsView viewDummy;

CCoinsViewCache view(&viewDummy);

{

LOCK(mempool.cs);

CCoinsViewMemPool viewMempool(pcoinsTip, mempool);

view.SetBackend(viewMempool); // temporarily switch cache backend to db+mempool view

const CCoins* coins = view.AccessCoins(vin.prevout.hash);

if (coins) {

if (coins->nHeight < 0) return 0;

return (chainActive.Tip()->nHeight + 1) - coins->nHeight;

} else

return -1;

}

{

int sigs = 0;

int nResult = GetInputAge(vin);

if (nResult < 0) nResult = 0;

if (nResult < 6) {

std::map<uint256, CTransactionLock>::iterator i = mapTxLocks.find(nTXHash);

if (i != mapTxLocks.end()) {

sigs = (*i).second.CountSignatures();

}

if (sigs >= SWIFTTX_SIGNATURES_REQUIRED) {

return nSwiftTXDepth + nResult;

}

}

return -1;

{

int sigs = 0;

std::map<uint256, CTransactionLock>::iterator i = mapTxLocks.find(nTXHash);

if (i != mapTxLocks.end()) {

sigs = (*i).second.CountSignatures();

}

if (sigs >= SWIFTTX_SIGNATURES_REQUIRED) {

return nSwiftTXDepth;

}

return 0;

{

uint256 bnCentSecond = 0; // coin age in the unit of cent-seconds

nCoinAge = 0;

CBlockIndex* pindex = NULL;

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

// First try finding the previous transaction in database

CTransaction txPrev;

uint256 hashBlockPrev;

if (!GetTransaction(txin.prevout.hash, txPrev, hashBlockPrev, true)) {

LogPrintf("GetCoinAge: failed to find vin transaction \n");

continue; // previous transaction not in main chain

}

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

if (it != mapBlockIndex.end())

pindex = it->second;

else {

LogPrintf("GetCoinAge() failed to find block index \n");

continue;

}

// Read block header

CBlockHeader prevblock = pindex->GetBlockHeader();

if (prevblock.nTime + nStakeMinAge > nTxTime)

continue; // only count coins meeting min age requirement

if (nTxTime < prevblock.nTime) {

LogPrintf("GetCoinAge: Timestamp Violation: txtime less than txPrev.nTime");

return false; // Transaction timestamp violation

}

int64_t nValueIn = txPrev.vout[txin.prevout.n].nValue;

bnCentSecond += uint256(nValueIn) * (nTxTime - prevblock.nTime);

}

uint256 bnCoinDay = bnCentSecond / COIN / (24 * 60 * 60);

LogPrintf("coin age bnCoinDay=%s\n", bnCoinDay.ToString().c_str());

nCoinAge = bnCoinDay.GetCompact();

return true;

{

// 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.IsEmpty() && !tx.IsCoinBase() && !tx.IsCoinStake())

return state.DoS(100, error("CheckTransaction(): txout empty for user transaction"));

if (txout.nValue < 0)

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

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

if (txout.nValue > Params().MaxMoneyOut())

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

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

nValueOut += txout.nValue;

if (!MoneyRange(nValueOut))