#include "miner.h"

#include "core.h"

#include "main.h"

#include "net.h"

#ifdef ENABLE_WALLET

#include "wallet.h"

#endif

int static FormatHashBlocks(void* pbuffer, unsigned int len)

}

static const unsigned int pSHA256InitState[8] =

{0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};

void SHA256Transform(void* pstate, void* pinput, const void* pinit)

}

class COrphan

};

uint64_t nLastBlockTx = 0;

uint64_t nLastBlockSize = 0;

typedef boost::tuple<double, double, const CTransaction*> TxPriority;

class TxPriorityCompare

};

CBlockTemplate* CreateNewBlock(const CScript& scriptPubKeyIn)

{

// Create new block

auto_ptr<CBlockTemplate> pblocktemplate(new CBlockTemplate());

if(!pblocktemplate.get())

return NULL;

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

// Create coinbase tx

CTransaction txNew;

txNew.vin.resize(1);

txNew.vin[0].prevout.SetNull();

txNew.vout.resize(1);

txNew.vout[0].scriptPubKey = scriptPubKeyIn;

// Add our coinbase tx as first transaction

pblock->vtx.push_back(txNew);

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

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

// Largest block you're willing to create:

unsigned int nBlockMaxSize = GetArg("-blockmaxsize", DEFAULT_BLOCK_MAX_SIZE);

// Limit to betweeen 1K and MAX_BLOCK_SIZE-1K for sanity:

nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MAX_BLOCK_SIZE-1000), nBlockMaxSize));

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

// included regardless of the fees they pay

unsigned int nBlockPrioritySize = GetArg("-blockprioritysize", DEFAULT_BLOCK_PRIORITY_SIZE);

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:

unsigned int nBlockMinSize = GetArg("-blockminsize", 0);

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

// Collect memory pool transactions into the block

int64_t nFees = 0;

{

LOCK2(cs_main, mempool.cs);

CBlockIndex* pindexPrev = chainActive.Tip();

CCoinsViewCache view(*pcoinsTip, true);

// Priority order to process transactions

list<COrphan> vOrphan; // list memory doesn't move

map<uint256, vector<COrphan*> > mapDependers;

bool fPrintPriority = GetBoolArg("-printpriority", false);

// This vector will be sorted into a priority queue:

vector<TxPriority> vecPriority;

vecPriority.reserve(mempool.mapTx.size());

for (map<uint256, CTxMemPoolEntry>::iterator mi = mempool.mapTx.begin();

mi != mempool.mapTx.end(); ++mi)

{

const CTransaction& tx = mi->second.GetTx();

if (tx.IsCoinBase() || !IsFinalTx(tx))

continue;

COrphan* porphan = NULL;

double dPriority = 0;

int64_t nTotalIn = 0;

bool fMissingInputs = false;

BOOST_FOREACH(const CTxIn& txin, tx.vin)

}

if (fMissingInputs) continue;

// Priority is sum(valuein * age) / modified_txsize

unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);

dPriority = tx.ComputePriority(dPriority, nTxSize);

// This is a more accurate fee-per-kilobyte than is used by the client code, because the

// client code rounds up the size to the nearest 1K. That's good, because it gives an

// incentive to create smaller transactions.

double dFeePerKb = double(nTotalIn-tx.GetValueOut()) / (double(nTxSize)/1000.0);

if (porphan)

{

porphan->dPriority = dPriority;

porphan->dFeePerKb = dFeePerKb;

}

else

vecPriority.push_back(TxPriority(dPriority, dFeePerKb, &mi->second.GetTx()));

}

// Collect transactions into block

uint64_t nBlockSize = 1000;

uint64_t nBlockTx = 0;

int nBlockSigOps = 100;

bool fSortedByFee = (nBlockPrioritySize <= 0);

TxPriorityCompare comparer(fSortedByFee);

std::make_heap(vecPriority.begin(), vecPriority.end(), comparer);

while (!vecPriority.empty())

{

// Take highest priority transaction off the priority queue:

double dPriority = vecPriority.front().get<0>();

double dFeePerKb = vecPriority.front().get<1>();

const CTransaction& tx = *(vecPriority.front().get<2>());

std::pop_heap(vecPriority.begin(), vecPriority.end(), comparer);

vecPriority.pop_back();

// Size limits

unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);

if (nBlockSize + nTxSize >= nBlockMaxSize)

continue;

// Legacy limits on sigOps:

unsigned int nTxSigOps = GetLegacySigOpCount(tx);

if (nBlockSigOps + nTxSigOps >= MAX_BLOCK_SIGOPS)

continue;

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

if (fSortedByFee && (dFeePerKb < CTransaction::nMinTxFee) && (nBlockSize + nTxSize >= nBlockMinSize))

continue;

// Prioritize by fee once past the priority size or we run out of high-priority

// transactions:

if (!fSortedByFee &&

((nBlockSize + nTxSize >= nBlockPrioritySize) || !AllowFree(dPriority)))

{

fSortedByFee = true;

comparer = TxPriorityCompare(fSortedByFee);

std::make_heap(vecPriority.begin(), vecPriority.end(), comparer);

}

if (!view.HaveInputs(tx))

continue;

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

nTxSigOps += GetP2SHSigOpCount(tx, view);

if (nBlockSigOps + nTxSigOps >= MAX_BLOCK_SIGOPS)

continue;

CValidationState state;

if (!CheckInputs(tx, state, view, true, SCRIPT_VERIFY_P2SH))

continue;

CTxUndo txundo;

uint256 hash = tx.GetHash();

UpdateCoins(tx, state, view, txundo, pindexPrev->nHeight+1, hash);

// Added

pblock->vtx.push_back(tx);

pblocktemplate->vTxFees.push_back(nTxFees);

pblocktemplate->vTxSigOps.push_back(nTxSigOps);

nBlockSize += nTxSize;

++nBlockTx;

nBlockSigOps += nTxSigOps;

nFees += nTxFees;

if (fPrintPriority)

{

LogPrintf("priority %.1f feeperkb %.1f txid %s\n",

dPriority, dFeePerKb, tx.GetHash().ToString().c_str());

}

// Add transactions that depend on this one to the priority queue

if (mapDependers.count(hash))

{

BOOST_FOREACH(COrphan* porphan, mapDependers[hash])

}

}

}

nLastBlockTx = nBlockTx;

nLastBlockSize = nBlockSize;

LogPrintf("CreateNewBlock(): total size %"PRIu64"\n", nBlockSize);

pblock->vtx[0].vout[0].nValue = GetBlockValue(pindexPrev->nHeight+1, nFees);

pblocktemplate->vTxFees[0] = -nFees;

// Fill in header

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

UpdateTime(*pblock, pindexPrev);

pblock->nBits = GetNextWorkRequired(pindexPrev, pblock);

pblock->nNonce = 0;

pblock->vtx[0].vin[0].scriptSig = CScript() << OP_0 << OP_0;

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

CBlockIndex indexDummy(*pblock);

indexDummy.pprev = pindexPrev;

indexDummy.nHeight = pindexPrev->nHeight + 1;

CCoinsViewCache viewNew(*pcoinsTip, true);

CValidationState state;

if (!ConnectBlock(*pblock, state, &indexDummy, viewNew, true))

throw std::runtime_error("CreateNewBlock() : ConnectBlock failed");

}

return pblocktemplate.release();

}

void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce)

}

void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1)

}

#ifdef ENABLE_WALLET

double dHashesPerSec = 0.0;

int64_t nHPSTimerStart = 0;

unsigned int static ScanHash_CryptoPP(char* pmidstate, char* pdata, char* phash1, char* phash, unsigned int& nHashesDone)

}

CBlockTemplate* CreateNewBlockWithKey(CReserveKey& reservekey)

{

CPubKey pubkey;

if (!reservekey.GetReservedKey(pubkey))

return NULL;

CScript scriptPubKey = CScript() << pubkey << OP_CHECKSIG;

return CreateNewBlock(scriptPubKey);

}

bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey)

}

void static BitcoinMiner(CWallet *pwallet)

}

void GenerateBitcoins(bool fGenerate, CWallet* pwallet, int nThreads)

}

#endif