// Copyright (c) 2010 Satoshi Nakamoto

// Copyright (c) 2009-2012 The Bitcoin developers

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

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

#include "main.h"

#include "db.h"

#include "txdb.h"

#include "init.h"

#include "miner.h"

#include "kernel.h"

#include "bitcoinrpc.h"

#include <boost/format.hpp>

#include <boost/assign/list_of.hpp>

#include <boost/iterator/counting_iterator.hpp>

using namespace json_spirit;

using namespace std;

extern uint256 nPoWBase;

extern uint64_t nStakeInputsMapSize;

Value getsubsidy(const Array& params, bool fHelp)

{

if (fHelp || params.size() > 1 || fHelp || params.size() < 99 )

throw runtime_error(

"getsubsidy [nTarget]\n"

"Currently not in use.");

unsigned int nBits = 0;

if (params.size() != 0)

{

CBigNum bnTarget(uint256(params[0].get_str()));

nBits = bnTarget.GetCompact();

}

else

{

nBits = GetNextTargetRequired(pindexBest, false);

}

return (uint64_t)GetProofOfWorkReward(nBits, 0, 0);

}

Value getmininginfo(const Array& params, bool fHelp)

{

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

throw runtime_error(

"getmininginfo\n"

"Returns an object containing mining-related information.");

Object obj, diff, weight;

obj.push_back(Pair("blocks", (int)nBestHeight));

obj.push_back(Pair("currentblocksize",(uint64_t)nLastBlockSize));

obj.push_back(Pair("currentblocktx",(uint64_t)nLastBlockTx));

diff.push_back(Pair("proof-of-work", GetDifficulty()));

diff.push_back(Pair("proof-of-stake", GetDifficulty(GetLastBlockIndex(pindexBest, true))));

diff.push_back(Pair("search-interval", (int)nLastCoinStakeSearchInterval));

obj.push_back(Pair("difficulty", diff));

obj.push_back(Pair("blockvalue", (uint64_t)GetProofOfWorkReward(GetLastBlockIndex(pindexBest, false)->nBits, 0, pindexBest->nHeight)));

obj.push_back(Pair("netmhashps", GetPoWMHashPS()));

obj.push_back(Pair("netstakeweight",GetPoSKernelPS()));

obj.push_back(Pair("errors", GetWarnings("statusbar")));

obj.push_back(Pair("pooledtx", (uint64_t)mempool.size()));

obj.push_back(Pair("stakeinputs", (uint64_t)nStakeInputsMapSize));

obj.push_back(Pair("stakeinterest", GetProofOfStakeReward(0, GetLastBlockIndex(pindexBest, true)->nBits, GetLastBlockIndex(pindexBest, true)->nTime, true)));

obj.push_back(Pair("testnet", fTestNet));

return obj;

}

// scaninput '{"txid":"95d640426fe66de866a8cf2d0601d2c8cf3ec598109b4d4ffa7fd03dad6d35ce","difficulty":0.01, "days":10}'

Value scaninput(const Array& params, bool fHelp)

{

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

throw runtime_error(

"scaninput '{\"txid\":\"txid\", \"vout\":[vout1, vout2, ..., voutN], \"difficulty\":difficulty, \"days\":days}'\n"

"Scan specified transaction or input for suitable kernel solutions.\n"

" difficulty - upper limit for difficulty, current difficulty by default;\n"

" days - time window, 90 days by default.\n"

);

RPCTypeCheck(params, boost::assign::list_of(obj_type));

Object scanParams = params[0].get_obj();

const Value& txid_v = find_value(scanParams, "txid");

if (txid_v.type() != str_type)

throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing txid key");

string txid = txid_v.get_str();

if (!IsHex(txid))

throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected hex txid");

uint256 hash(txid);

int32_t nDays = 90;

uint32_t nBits = GetNextTargetRequired(pindexBest, true);

const Value& diff_v = find_value(scanParams, "difficulty");

if (diff_v.type() == real_type || diff_v.type() == int_type)

{

double dDiff = diff_v.get_real();

if (dDiff <= 0)

throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, diff must be greater than zero");

CBigNum bnTarget(nPoWBase);

bnTarget *= 1000;

bnTarget /= (int) (dDiff * 1000);

nBits = bnTarget.GetCompact();

}

const Value& days_v = find_value(scanParams, "days");

if (days_v.type() == int_type)

{

nDays = days_v.get_int();

if (nDays <= 0)

throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, interval length must be greater than zero");

}

CTransaction tx;

uint256 hashBlock = 0;

if (GetTransaction(hash, tx, hashBlock))

{

if (hashBlock == 0)

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unable to find transaction in the blockchain");

vector<int> vInputs(0);

const Value& inputs_v = find_value(scanParams, "vout");

if (inputs_v.type() == array_type)

{

Array inputs = inputs_v.get_array();

BOOST_FOREACH(const Value &v_out, inputs)

{

int nOut = v_out.get_int();

if (nOut < 0 || nOut > (int)tx.vout.size() - 1)

{

stringstream strErrorMsg;

strErrorMsg << boost::format("Invalid parameter, input number %d is out of range") % nOut;

throw JSONRPCError(RPC_INVALID_PARAMETER, strErrorMsg.str());

}

vInputs.push_back(nOut);

}

}

else if(inputs_v.type() == int_type)

{

int nOut = inputs_v.get_int();

if (nOut < 0 || nOut > (int)tx.vout.size() - 1)

{

stringstream strErrorMsg;

strErrorMsg << boost::format("Invalid parameter, input number %d is out of range") % nOut;

throw JSONRPCError(RPC_INVALID_PARAMETER, strErrorMsg.str());

}

vInputs.push_back(nOut);

}

else

{

vInputs = vector<int>(boost::counting_iterator<int>( 0 ), boost::counting_iterator<int>( tx.vout.size() ));

}

CTxDB txdb("r");

CBlock block;

CTxIndex txindex;

// Load transaction index item

if (!txdb.ReadTxIndex(tx.GetHash(), txindex))

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unable to read block index item");

// Read block header

if (!block.ReadFromDisk(txindex.pos.nFile, txindex.pos.nBlockPos, false))

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "CBlock::ReadFromDisk() failed");

uint64_t nStakeModifier = 0;

if (!GetKernelStakeModifier(block.GetHash(), nStakeModifier))

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No kernel stake modifier generated yet");

std::pair<uint32_t, uint32_t> interval;

interval.first = GetTime();

// Only count coins meeting min age requirement

if (nStakeMinAge + block.nTime > interval.first)

interval.first += (nStakeMinAge + block.nTime - interval.first);

interval.second = interval.first + nDays * nOneDay;

Array results;

BOOST_FOREACH(const int &nOut, vInputs)

{

// Check for spent flag

// It doesn't make sense to scan spent inputs.

if (!txindex.vSpent[nOut].IsNull())

continue;

// Skip zero value outputs

if (tx.vout[nOut].nValue == 0)

continue;

// Build static part of kernel

CDataStream ssKernel(SER_GETHASH, 0);

ssKernel << nStakeModifier;

ssKernel << block.nTime << (txindex.pos.nTxPos - txindex.pos.nBlockPos) << tx.nTime << nOut;

CDataStream::const_iterator itK = ssKernel.begin();

std::vector<std::pair<uint256, uint32_t> > result;

if (ScanKernelForward((unsigned char *)&itK[0], nBits, tx.nTime, tx.vout[nOut].nValue, interval, result))

{

BOOST_FOREACH(const PAIRTYPE(uint256, uint32_t) solution, result)

{

Object item;

item.push_back(Pair("nout", nOut));

item.push_back(Pair("hash", solution.first.GetHex()));

item.push_back(Pair("time", DateTimeStrFormat(solution.second)));

results.push_back(item);

}

}

}

if (results.size() == 0)

return false;

return results;

}

else

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available about transaction");

}

Value getworkex(const Array& params, bool fHelp)

{

if (fHelp || params.size() > 2)

throw runtime_error(

"getworkex [data, coinbase]\n"

"If [data, coinbase] is not specified, returns extended work data.\n"

);

if (vNodes.empty())

throw JSONRPCError(-9, "Droxne is not connected!");

if (IsInitialBlockDownload())

throw JSONRPCError(-10, "Droxne is downloading blocks...");

if (pindexBest->nHeight >= LAST_POW_BLOCK)

throw JSONRPCError(RPC_MISC_ERROR, "No more PoW blocks");

typedef map<uint256, pair<CBlock*, CScript> > mapNewBlock_t;

static mapNewBlock_t mapNewBlock;

static vector<CBlock*> vNewBlock;

static CReserveKey reservekey(pwalletMain);

if (params.size() == 0)

{

// Update block

static unsigned int nTransactionsUpdatedLast;

static CBlockIndex* pindexPrev;

static int64_t nStart;

static CBlock* pblock;

if (pindexPrev != pindexBest ||

(nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 60))

{

if (pindexPrev != pindexBest)

{

// Deallocate old blocks since they're obsolete now

mapNewBlock.clear();

BOOST_FOREACH(CBlock* pblock, vNewBlock)

delete pblock;

vNewBlock.clear();

}

nTransactionsUpdatedLast = nTransactionsUpdated;

pindexPrev = pindexBest;

nStart = GetTime();

// Create new block

pblock = CreateNewBlock(pwalletMain);

if (!pblock)

throw JSONRPCError(-7, "Out of memory");

vNewBlock.push_back(pblock);

}

// Update nTime

pblock->nTime = max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());

pblock->nNonce = 0;

// Update nExtraNonce

static unsigned int nExtraNonce = 0;

IncrementExtraNonce(pblock, pindexPrev, nExtraNonce);

// Save

mapNewBlock[pblock->hashMerkleRoot] = make_pair(pblock, pblock->vtx[0].vin[0].scriptSig);

// Prebuild hash buffers

char pmidstate[32];

char pdata[128];

char phash1[64];

FormatHashBuffers(pblock, pmidstate, pdata, phash1);

uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();

CTransaction coinbaseTx = pblock->vtx[0];

std::vector<uint256> merkle = pblock->GetMerkleBranch(0);

Object result;

result.push_back(Pair("data", HexStr(BEGIN(pdata), END(pdata))));

result.push_back(Pair("target", HexStr(BEGIN(hashTarget), END(hashTarget))));

CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);

ssTx << coinbaseTx;

result.push_back(Pair("coinbase", HexStr(ssTx.begin(), ssTx.end())));

Array merkle_arr;

BOOST_FOREACH(uint256 merkleh, merkle) {

merkle_arr.push_back(HexStr(BEGIN(merkleh), END(merkleh)));

}

result.push_back(Pair("merkle", merkle_arr));

return result;

}

else

{

// Parse parameters

vector<unsigned char> vchData = ParseHex(params[0].get_str());

vector<unsigned char> coinbase;

if(params.size() == 2)

coinbase = ParseHex(params[1].get_str());

if (vchData.size() != 128)

throw JSONRPCError(-8, "Invalid parameter");

CBlock* pdata = (CBlock*)&vchData[0];

// Byte reverse

for (int i = 0; i < 128/4; i++)

((unsigned int*)pdata)[i] = ByteReverse(((unsigned int*)pdata)[i]);

// Get saved block

if (!mapNewBlock.count(pdata->hashMerkleRoot))

return false;

CBlock* pblock = mapNewBlock[pdata->hashMerkleRoot].first;

pblock->nTime = pdata->nTime;

pblock->nNonce = pdata->nNonce;

if(coinbase.size() == 0)

pblock->vtx[0].vin[0].scriptSig = mapNewBlock[pdata->hashMerkleRoot].second;

else

CDataStream(coinbase, SER_NETWORK, PROTOCOL_VERSION) >> pblock->vtx[0]; // FIXME - HACK!

pblock->hashMerkleRoot = pblock->BuildMerkleTree();

return CheckWork(pblock, *pwalletMain, reservekey);

}

}

Value getwork(const Array& params, bool fHelp)

{

if (fHelp || params.size() > 1)

throw runtime_error(

"getwork [data]\n"

"If [data] is not specified, returns formatted hash data to work on:\n"

" \"midstate\" : precomputed hash state after hashing the first half of the data (DEPRECATED)\n" // deprecated

" \"data\" : block data\n"

" \"hash1\" : formatted hash buffer for second hash (DEPRECATED)\n" // deprecated

" \"target\" : little endian hash target\n"

"If [data] is specified, tries to solve the block and returns true if it was successful.");

if (vNodes.empty())

throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Droxne is not connected!");

if (IsInitialBlockDownload())

throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Droxne is downloading blocks...");

if (pindexBest->nHeight >= LAST_POW_BLOCK)

throw JSONRPCError(RPC_MISC_ERROR, "No more PoW blocks");

typedef map<uint256, pair<CBlock*, CScript> > mapNewBlock_t;

static mapNewBlock_t mapNewBlock; // FIXME: thread safety

static vector<CBlock*> vNewBlock;

static CReserveKey reservekey(pwalletMain);

if (params.size() == 0)

{

// Update block

static unsigned int nTransactionsUpdatedLast;

static CBlockIndex* pindexPrev;

static int64_t nStart;

static CBlock* pblock;

if (pindexPrev != pindexBest ||

(nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 60))

{

if (pindexPrev != pindexBest)

{

// Deallocate old blocks since they're obsolete now

mapNewBlock.clear();

BOOST_FOREACH(CBlock* pblock, vNewBlock)

delete pblock;

vNewBlock.clear();

}

// Clear pindexPrev so future getworks make a new block, despite any failures from here on

pindexPrev = NULL;

// Store the pindexBest used before CreateNewBlock, to avoid races

nTransactionsUpdatedLast = nTransactionsUpdated;

CBlockIndex* pindexPrevNew = pindexBest;

nStart = GetTime();

// Create new block

pblock = CreateNewBlock(pwalletMain);

if (!pblock)

throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");

vNewBlock.push_back(pblock);

// Need to update only after we know CreateNewBlock succeeded

pindexPrev = pindexPrevNew;

}

// Update nTime

pblock->UpdateTime(pindexPrev);

pblock->nNonce = 0;

// Update nExtraNonce

static unsigned int nExtraNonce = 0;

IncrementExtraNonce(pblock, pindexPrev, nExtraNonce);

// Save

mapNewBlock[pblock->hashMerkleRoot] = make_pair(pblock, pblock->vtx[0].vin[0].scriptSig);

// Pre-build hash buffers

char pmidstate[32];

char pdata[128];

char phash1[64];

FormatHashBuffers(pblock, pmidstate, pdata, phash1);

uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();

Object result;

result.push_back(Pair("midstate", HexStr(BEGIN(pmidstate), END(pmidstate)))); // deprecated

result.push_back(Pair("data", HexStr(BEGIN(pdata), END(pdata))));

result.push_back(Pair("hash1", HexStr(BEGIN(phash1), END(phash1)))); // deprecated

result.push_back(Pair("target", HexStr(BEGIN(hashTarget), END(hashTarget))));

return result;

}

else

{

// Parse parameters

vector<unsigned char> vchData = ParseHex(params[0].get_str());

if (vchData.size() != 128)

throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter");

CBlock* pdata = (CBlock*)&vchData[0];

// Byte reverse

for (int i = 0; i < 128/4; i++)

((unsigned int*)pdata)[i] = ByteReverse(((unsigned int*)pdata)[i]);

// Get saved block

if (!mapNewBlock.count(pdata->hashMerkleRoot))

return false;

CBlock* pblock = mapNewBlock[pdata->hashMerkleRoot].first;

pblock->nTime = pdata->nTime;

pblock->nNonce = pdata->nNonce;

pblock->vtx[0].vin[0].scriptSig = mapNewBlock[pdata->hashMerkleRoot].second;

pblock->hashMerkleRoot = pblock->BuildMerkleTree();

return CheckWork(pblock, *pwalletMain, reservekey);

}

}

Value getblocktemplate(const Array& params, bool fHelp)

{

if (fHelp || params.size() > 1)

throw runtime_error(

"getblocktemplate [params]\n"

"Returns data needed to construct a block to work on:\n"

" \"version\" : block version\n"

" \"previousblockhash\" : hash of current highest block\n"

" \"transactions\" : contents of non-coinbase transactions that should be included in the next block\n"

" \"coinbaseaux\" : data that should be included in coinbase\n"

" \"coinbasevalue\" : maximum allowable input to coinbase transaction, including the generation award and transaction fees\n"

" \"target\" : hash target\n"

" \"mintime\" : minimum timestamp appropriate for next block\n"

" \"curtime\" : current timestamp\n"

" \"mutable\" : list of ways the block template may be changed\n"

" \"noncerange\" : range of valid nonces\n"

" \"sigoplimit\" : limit of sigops in blocks\n"

" \"sizelimit\" : limit of block size\n"

" \"bits\" : compressed target of next block\n"

" \"height\" : height of the next block\n"

"See https://en.bitcoin.it/wiki/BIP_0022 for full specification.");

std::string strMode = "template";

if (params.size() > 0)

{

const Object& oparam = params[0].get_obj();

const Value& modeval = find_value(oparam, "mode");

if (modeval.type() == str_type)

strMode = modeval.get_str();

else if (modeval.type() == null_type)

{

/* Do nothing */

}

else

throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");

}

if (strMode != "template")

throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");

if (vNodes.empty())

throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Droxne is not connected!");

if (IsInitialBlockDownload())

throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Droxne is downloading blocks...");

if (pindexBest->nHeight >= LAST_POW_BLOCK)

throw JSONRPCError(RPC_MISC_ERROR, "No more PoW blocks");

static CReserveKey reservekey(pwalletMain);

// Update block

static unsigned int nTransactionsUpdatedLast;

static CBlockIndex* pindexPrev;

static int64_t nStart;

static CBlock* pblock;

if (pindexPrev != pindexBest ||

(nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 5))

{

// Clear pindexPrev so future calls make a new block, despite any failures from here on

pindexPrev = NULL;

// Store the pindexBest used before CreateNewBlock, to avoid races

nTransactionsUpdatedLast = nTransactionsUpdated;

CBlockIndex* pindexPrevNew = pindexBest;

nStart = GetTime();

// Create new block

if(pblock)

{

delete pblock;

pblock = NULL;

}

pblock = CreateNewBlock(pwalletMain);

if (!pblock)

throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");

// Need to update only after we know CreateNewBlock succeeded

pindexPrev = pindexPrevNew;

}

// Update nTime

pblock->UpdateTime(pindexPrev);

pblock->nNonce = 0;

Array transactions;

map<uint256, int64_t> setTxIndex;

int i = 0;

CTxDB txdb("r");

BOOST_FOREACH (CTransaction& tx, pblock->vtx)

{

uint256 txHash = tx.GetHash();

setTxIndex[txHash] = i++;

if (tx.IsCoinBase() || tx.IsCoinStake())

continue;

Object entry;

CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);

ssTx << tx;

entry.push_back(Pair("data", HexStr(ssTx.begin(), ssTx.end())));

entry.push_back(Pair("hash", txHash.GetHex()));

MapPrevTx mapInputs;

map<uint256, CTxIndex> mapUnused;

bool fInvalid = false;

if (tx.FetchInputs(txdb, mapUnused, false, false, mapInputs, fInvalid))

{

entry.push_back(Pair("fee", (int64_t)(tx.GetValueIn(mapInputs) - tx.GetValueOut())));

Array deps;

BOOST_FOREACH (MapPrevTx::value_type& inp, mapInputs)

{

if (setTxIndex.count(inp.first))

deps.push_back(setTxIndex[inp.first]);

}

entry.push_back(Pair("depends", deps));

int64_t nSigOps = tx.GetLegacySigOpCount();

nSigOps += tx.GetP2SHSigOpCount(mapInputs);

entry.push_back(Pair("sigops", nSigOps));

}

transactions.push_back(entry);

}

Object aux;

aux.push_back(Pair("flags", HexStr(COINBASE_FLAGS.begin(), COINBASE_FLAGS.end())));

uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();

static Array aMutable;

if (aMutable.empty())

{

aMutable.push_back("time");

aMutable.push_back("transactions");

aMutable.push_back("prevblock");

}

Object result;

result.push_back(Pair("version", pblock->nVersion));

result.push_back(Pair("previousblockhash", pblock->hashPrevBlock.GetHex()));

result.push_back(Pair("transactions", transactions));

result.push_back(Pair("coinbaseaux", aux));

result.push_back(Pair("coinbasevalue", (int64_t)pblock->vtx[0].vout[0].nValue));

result.push_back(Pair("target", hashTarget.GetHex()));

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("sigoplimit", (int64_t)MAX_BLOCK_SIGOPS));

result.push_back(Pair("sizelimit", (int64_t)MAX_BLOCK_SIZE));

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

result.push_back(Pair("bits", HexBits(pblock->nBits)));

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

return result;

}

Value submitblock(const Array& params, bool fHelp)

{

if (fHelp || params.size() < 1 || params.size() > 2)

throw runtime_error(

"submitblock <hex data> [optional-params-obj]\n"

"[optional-params-obj] parameter is currently ignored.\n"

"Attempts to submit new block to network.\n"

"See https://en.bitcoin.it/wiki/BIP_0022 for full specification.");

vector<unsigned char> blockData(ParseHex(params[0].get_str()));

CDataStream ssBlock(blockData, SER_NETWORK, PROTOCOL_VERSION);

CBlock block;

try {

ssBlock >> block;

}

catch (const std::exception&) {

throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");

}

bool fAccepted = ProcessBlock(NULL, &block);

if (!fAccepted)

return "rejected";

return Value::null;

}