static void MutateTxAddInput(CMutableTransaction& tx, const string& strInput)

{

// separate TXID:VOUT in string

size_t pos = strInput.find(':');

if ((pos == string::npos) ||

uint256 txid(uint256S(strTxid));

static const unsigned int minTxOutSz = 9;

// extract and validate vout

string strVout = strInput.substr(pos + 1, string::npos);

consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks

consensus.nPowTargetSpacing = 10 * 60;

consensus.fPowAllowMinDifficultyBlocks = false;

consensus.nMaxTxSize = 1000000;

/**

consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks

consensus.nPowTargetSpacing = 10 * 60;

consensus.fPowAllowMinDifficultyBlocks = true;

consensus.nMaxTxSize = 1000000;

pchMessageStart[0] = 0x0b;

pchMessageStart[1] = 0x11;

consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks

consensus.nPowTargetSpacing = 10 * 60;

consensus.fPowAllowMinDifficultyBlocks = true;

consensus.nMaxTxSize = 1000000;

pchMessageStart[0] = 0xfa;

pchMessageStart[1] = 0xbf;

#include <stdint.h>

class CTransaction;

class CValidationState;

bool CheckTx(const CTransaction& tx, CValidationState& state, const Params& consensusParams);

} // namespace Consensus

#endif // BITCOIN_CONSENSUS_CONSENSUS_H

struct Params {

uint256 hashGenesisBlock;

uint32_t nMaxTxSize;

int nSubsidyHalvingInterval;

/** Used to check majorities for block version upgrade */

int nMajorityEnforceBlockUpgrade;

// Check that the transaction doesn't have an excessive number of

// sigops, making it impossible to mine. Since the coinbase transaction

// itself can contain sigops MAX_STANDARD_TX_SIGOPS is less than

// merely non-standard transaction.

unsigned int nSigOps = GetLegacySigOpCount(tx);

nSigOps += GetP2SHSigOpCount(tx, view);

return pindexPrev->nHeight + 1;

}

{

// This doesn't trigger the DoS code on purpose; if it did, it would make it easier

// for an attacker to attempt to split the network.

// If prev is coinbase, check that it's matured

if (coins->IsCoinBase()) {

return state.Invalid(false,

REJECT_INVALID, "bad-txns-premature-spend-of-coinbase",

strprintf("tried to spend coinbase at depth %d", nSpendHeight - coins->nHeight));

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

return true;

}

bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheStore, std::vector<CScriptCheck> *pvChecks)

{

if (!tx.IsCoinBase())

{

return false;

if (pvChecks)

std::vector<std::pair<uint256, CDiskTxPos> > vPos;

vPos.reserve(block.vtx.size());

blockundo.vtxundo.reserve(block.vtx.size() - 1);

for (unsigned int i = 0; i < block.vtx.size(); i++)

{

const CTransaction &tx = block.vtx[i];

nInputs += tx.vin.size();

nSigOps += GetLegacySigOpCount(tx);

return state.DoS(100, error("ConnectBlock(): too many sigops"),

REJECT_INVALID, "bad-blk-sigops");

// this is to prevent a "rogue miner" from creating

// an incredibly-expensive-to-validate block.

nSigOps += GetP2SHSigOpCount(tx, view);

return state.DoS(100, error("ConnectBlock(): too many sigops"),

REJECT_INVALID, "bad-blk-sigops");

}

// because we receive the wrong transactions for it.

// Size limits

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

REJECT_INVALID, "bad-blk-length");

{

nSigOps += GetLegacySigOpCount(tx);

}

return state.DoS(100, error("CheckBlock(): out-of-bounds SigOpCount"),

REJECT_INVALID, "bad-blk-sigops", true);

// Map of disk positions for blocks with unknown parent (only used for reindex)

static std::multimap<uint256, CDiskBlockPos> mapBlocksUnknownParent;

int64_t nStart = GetTimeMillis();

int nLoaded = 0;

try {

// This takes over fileIn and calls fclose() on it in the CBufferedFile destructor

uint64_t nRewind = blkdat.GetPos();

while (!blkdat.eof()) {

boost::this_thread::interruption_point();

continue;

// read size

blkdat >> nSize;

continue;

} catch (const std::exception&) {

// no valid block header found; don't complain

// -regtest only: allow overriding block.nVersion with

// -blockversion=N to test forking scenarios

pblock->nVersion = GetArg("-blockversion", pblock->nVersion);

// Create coinbase tx

pblocktemplate->vTxSigOps.push_back(-1); // updated at end

// Largest block you're willing to create:

// How much of the block should be dedicated to high-priority transactions,

// included regardless of the fees they pay

nBlockPrioritySize = std::min(nBlockMaxSize, nBlockPrioritySize);

// Minimum block size you want to create; block will be filled with free transactions

// until there are no more or the block reaches this size:

nBlockMinSize = std::min(nBlockMaxSize, nBlockMinSize);

// Collect memory pool transactions into the block

// Legacy limits on sigOps:

unsigned int nTxSigOps = GetLegacySigOpCount(tx);

continue;

// Skip free transactions if we're past the minimum block size:

CAmount nTxFees = view.GetValueIn(tx)-tx.GetValueOut();

nTxSigOps += GetP2SHSigOpCount(tx, view);

continue;

// Note that flags: we don't want to set mempool/IsStandard()

// Fill in header

pblock->hashPrevBlock = pindexPrev->GetBlockHash();

pblock->nNonce = 0;

pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(pblock->vtx[0]);

QString strHTML;

LOCK2(cs_main, wallet->cs_wallet);

strHTML.reserve(4000);

strHTML += "<html><font face='verdana, arial, helvetica, sans-serif'>";

if (wtx.IsCoinBase())

{

strHTML += "<br>" + tr("Generated coins must mature %1 blocks before they can be spent. When you generated this block, it was broadcast to the network to be added to the block chain. If it fails to get into the chain, its state will change to \"not accepted\" and it won't be spendable. This may occasionally happen if another node generates a block within a few seconds of yours.").arg(QString::number(numBlocksToMaturity)) + "<br>";

}

);

LOCK(cs_main);

std::string strMode = "template";

UniValue lpval = NullUniValue;

CBlock* pblock = &pblocktemplate->block; // pointer for convenience

// Update nTime

pblock->nNonce = 0;

UniValue aCaps(UniValue::VARR); aCaps.push_back("proposal");

result.push_back(Pair("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1));

result.push_back(Pair("mutable", aMutable));

result.push_back(Pair("noncerange", "00000000ffffffff"));

result.push_back(Pair("curtime", pblock->GetBlockTime()));

result.push_back(Pair("bits", strprintf("%08x", pblock->nBits)));

result.push_back(Pair("height", (int64_t)(pindexPrev->nHeight+1)));

UniValue verifytxoutproof(const UniValue& params, bool fHelp)

{

if (fHelp || params.size() != 1)

throw runtime_error(

"verifytxoutproof \"proof\"\n"

UniValue res(UniValue::VARR);

vector<uint256> vMatch;

if (merkleBlock.txn.ExtractMatches(nMaxTransactions, vMatch) != merkleBlock.header.hashMerkleRoot)

return res;

#include "clientversion.h"

#include "consensus/validation.h"

#include "main.h" // For CheckBlock

#include "primitives/block.h"