// Copyright (c) 2010 Satoshi Nakamoto

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

#include "base58.h"

#include "chain.h"

#include "chainparams.h"

#include "checkpoints.h"

#include "coins.h"

#include "consensus/validation.h"

#include "main.h"

#include "policy/policy.h"

#include "primitives/transaction.h"

#include "rpc/server.h"

#include "script/script.h"

#include "script/script_error.h"

#include "script/sign.h"

#include "script/standard.h"

#include "streams.h"

#include "sync.h"

#include "txmempool.h"

#include "util.h"

#include "utilstrencodings.h"

#include "hash.h"

#include "pos.h"

#include <stdint.h>

#include <univalue.h>

#include <boost/thread/thread.hpp> // boost::thread::interrupt

using namespace std;

extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry);

void ScriptPubKeyToJSON(const CScript& scriptPubKey, UniValue& out, bool fIncludeHex);

UniValue blockheaderToJSON(const CBlockIndex* blockindex)

{

UniValue result(UniValue::VOBJ);

result.push_back(Pair("hash", blockindex->GetBlockHash().GetHex()));

int confirmations = -1;

// Only report confirmations if the block is on the main chain

if (chainActive.Contains(blockindex))

confirmations = chainActive.Height() - blockindex->nHeight + 1;

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

result.push_back(Pair("height", blockindex->nHeight));

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

result.push_back(Pair("versionHex", strprintf("%08x", blockindex->nVersion)));

result.push_back(Pair("merkleroot", blockindex->hashMerkleRoot.GetHex()));

result.push_back(Pair("time", (int64_t)blockindex->nTime));

result.push_back(Pair("mediantime", (int64_t)blockindex->GetMedianTimePast()));

result.push_back(Pair("mint", ValueFromAmount(blockindex->nMint)));

result.push_back(Pair("nonce", (uint64_t)blockindex->nNonce));

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

result.push_back(Pair("difficulty", GetDifficulty(blockindex)));

result.push_back(Pair("chainwork", blockindex->nChainWork.GetHex()));

result.push_back(Pair("flags", strprintf("%s%s", blockindex->IsProofOfStake()? "proof-of-stake" : "proof-of-work", blockindex->GeneratedStakeModifier()? " stake-modifier": "")));

result.push_back(Pair("proofhash", blockindex->hashProof.GetHex()));

result.push_back(Pair("entropybit", (int)blockindex->GetStakeEntropyBit()));

result.push_back(Pair("modifier", strprintf("%016x", blockindex->nStakeModifier)));

if (blockindex->pprev)

result.push_back(Pair("previousblockhash", blockindex->pprev->GetBlockHash().GetHex()));

CBlockIndex *pnext = chainActive.Next(blockindex);

if (pnext)

result.push_back(Pair("nextblockhash", pnext->GetBlockHash().GetHex()));

return result;

}

UniValue blockToDeltasJSON(const CBlock& block, const CBlockIndex* blockindex)

{

UniValue result(UniValue::VOBJ);

result.push_back(Pair("hash", block.GetHash().GetHex()));

int confirmations = -1;

// Only report confirmations if the block is on the main chain

if (chainActive.Contains(blockindex)) {

confirmations = chainActive.Height() - blockindex->nHeight + 1;

} else {

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block is an orphan");

}

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

result.push_back(Pair("size", (int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION)));

result.push_back(Pair("height", blockindex->nHeight));

result.push_back(Pair("version", block.nVersion));

result.push_back(Pair("merkleroot", block.hashMerkleRoot.GetHex()));

if (block.IsProofOfStake())

result.push_back(Pair("signature", HexStr(block.vchBlockSig.begin(), block.vchBlockSig.end())));

UniValue deltas(UniValue::VARR);

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

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

const uint256 txhash = tx.GetHash();

UniValue entry(UniValue::VOBJ);

entry.push_back(Pair("txid", txhash.GetHex()));

entry.push_back(Pair("index", (int)i));

UniValue inputs(UniValue::VARR);

if (!tx.IsCoinBase()) {

for (size_t j = 0; j < tx.vin.size(); j++) {

const CTxIn input = tx.vin[j];

UniValue delta(UniValue::VOBJ);

CSpentIndexValue spentInfo;

CSpentIndexKey spentKey(input.prevout.hash, input.prevout.n);

if (GetSpentIndex(spentKey, spentInfo)) {

if (spentInfo.addressType == 1) {

delta.push_back(Pair("address", CNavCoinAddress(CKeyID(spentInfo.addressHash)).ToString()));

} else if (spentInfo.addressType == 2) {

delta.push_back(Pair("address", CNavCoinAddress(CScriptID(spentInfo.addressHash)).ToString()));

} else {

continue;

}

delta.push_back(Pair("satoshis", -1 * spentInfo.satoshis));

delta.push_back(Pair("index", (int)j));

delta.push_back(Pair("prevtxid", input.prevout.hash.GetHex()));

delta.push_back(Pair("prevout", (int)input.prevout.n));

inputs.push_back(delta);

} else {

throw JSONRPCError(RPC_INTERNAL_ERROR, "Spent information not available");

}

}

}

entry.push_back(Pair("inputs", inputs));

UniValue outputs(UniValue::VARR);

for (unsigned int k = 0; k < tx.vout.size(); k++) {

const CTxOut &out = tx.vout[k];

UniValue delta(UniValue::VOBJ);

if (out.scriptPubKey.IsPayToScriptHash()) {

vector<unsigned char> hashBytes(out.scriptPubKey.begin()+2, out.scriptPubKey.begin()+22);

delta.push_back(Pair("address", CNavCoinAddress(CScriptID(uint160(hashBytes))).ToString()));

} else if (out.scriptPubKey.IsPayToPublicKeyHash()) {

vector<unsigned char> hashBytes(out.scriptPubKey.begin()+3, out.scriptPubKey.begin()+23);

delta.push_back(Pair("address", CNavCoinAddress(CKeyID(uint160(hashBytes))).ToString()));

} else {

continue;

}

delta.push_back(Pair("satoshis", out.nValue));

delta.push_back(Pair("index", (int)k));

outputs.push_back(delta);

}

entry.push_back(Pair("outputs", outputs));

deltas.push_back(entry);

}

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

result.push_back(Pair("time", block.GetBlockTime()));

result.push_back(Pair("mediantime", (int64_t)blockindex->GetMedianTimePast()));

result.push_back(Pair("nonce", (uint64_t)block.nNonce));

result.push_back(Pair("bits", strprintf("%08x", block.nBits)));

result.push_back(Pair("difficulty", GetDifficulty(blockindex)));

result.push_back(Pair("chainwork", blockindex->nChainWork.GetHex()));

if (blockindex->pprev)

result.push_back(Pair("previousblockhash", blockindex->pprev->GetBlockHash().GetHex()));

CBlockIndex *pnext = chainActive.Next(blockindex);

if (pnext)

result.push_back(Pair("nextblockhash", pnext->GetBlockHash().GetHex()));

return result;

}

UniValue blockToJSON(const CBlock& block, const CBlockIndex* blockindex, bool txDetails = false)

{

UniValue result(UniValue::VOBJ);

result.push_back(Pair("hash", blockindex->GetBlockHash().GetHex()));

int confirmations = -1;

// Only report confirmations if the block is on the main chain

if (chainActive.Contains(blockindex))

confirmations = chainActive.Height() - blockindex->nHeight + 1;

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

result.push_back(Pair("strippedsize", (int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS)));

result.push_back(Pair("size", (int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION)));

result.push_back(Pair("weight", (int)::GetBlockWeight(block)));

result.push_back(Pair("height", blockindex->nHeight));

result.push_back(Pair("version", block.nVersion));

result.push_back(Pair("versionHex", strprintf("%08x", block.nVersion)));

result.push_back(Pair("merkleroot", block.hashMerkleRoot.GetHex()));

UniValue txs(UniValue::VARR);

BOOST_FOREACH(const CTransaction&tx, block.vtx)

{

if(txDetails)

{

UniValue objTx(UniValue::VOBJ);

TxToJSON(tx, uint256(), objTx);

txs.push_back(objTx);

}

else

txs.push_back(tx.GetHash().GetHex());

}

result.push_back(Pair("tx", txs));

result.push_back(Pair("time", block.GetBlockTime()));

result.push_back(Pair("mediantime", (int64_t)blockindex->GetMedianTimePast()));

result.push_back(Pair("nonce", (uint64_t)block.nNonce));

result.push_back(Pair("bits", strprintf("%08x", block.nBits)));

result.push_back(Pair("difficulty", GetDifficulty(blockindex)));

result.push_back(Pair("chainwork", blockindex->nChainWork.GetHex()));

if (blockindex->pprev)

result.push_back(Pair("previousblockhash", blockindex->pprev->GetBlockHash().GetHex()));

CBlockIndex *pnext = chainActive.Next(blockindex);

if (pnext)

result.push_back(Pair("nextblockhash", pnext->GetBlockHash().GetHex()));

return result;

}

UniValue getblockcount(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"getblockcount\n"

"\nReturns the number of blocks in the longest block chain.\n"

"\nResult:\n"

"n (numeric) The current block count\n"

"\nExamples:\n"

+ HelpExampleCli("getblockcount", "")

+ HelpExampleRpc("getblockcount", "")

);

LOCK(cs_main);

return chainActive.Height();

}

UniValue getbestblockhash(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"getbestblockhash\n"

"\nReturns the hash of the best (tip) block in the longest block chain.\n"

"\nResult\n"

"\"hex\" (string) the block hash hex encoded\n"

"\nExamples\n"

+ HelpExampleCli("getbestblockhash", "")

+ HelpExampleRpc("getbestblockhash", "")

);

LOCK(cs_main);

return chainActive.Tip()->GetBlockHash().GetHex();

}

UniValue getdifficulty(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"getdifficulty\n"

"\nReturns the proof-of-work difficulty as a multiple of the minimum difficulty.\n"

"\nResult:\n"

"n.nnn (numeric) the proof-of-work difficulty as a multiple of the minimum difficulty.\n"

"\nExamples:\n"

+ HelpExampleCli("getdifficulty", "")

+ HelpExampleRpc("getdifficulty", "")

);

LOCK(cs_main);

return GetDifficulty();

}

std::string EntryDescriptionString()

{

return " \"size\" : n, (numeric) transaction size in bytes\n"

" \"fee\" : n, (numeric) transaction fee in " + CURRENCY_UNIT + "\n"

" \"modifiedfee\" : n, (numeric) transaction fee with fee deltas used for mining priority\n"

" \"time\" : n, (numeric) local time transaction entered pool in seconds since 1 Jan 1970 GMT\n"

" \"height\" : n, (numeric) block height when transaction entered pool\n"

" \"startingpriority\" : n, (numeric) priority when transaction entered pool\n"

" \"currentpriority\" : n, (numeric) transaction priority now\n"

" \"descendantcount\" : n, (numeric) number of in-mempool descendant transactions (including this one)\n"

" \"descendantsize\" : n, (numeric) size of in-mempool descendants (including this one)\n"

" \"descendantfees\" : n, (numeric) modified fees (see above) of in-mempool descendants (including this one)\n"

" \"ancestorcount\" : n, (numeric) number of in-mempool ancestor transactions (including this one)\n"

" \"ancestorsize\" : n, (numeric) size of in-mempool ancestors (including this one)\n"

" \"ancestorfees\" : n, (numeric) modified fees (see above) of in-mempool ancestors (including this one)\n"

" \"depends\" : [ (array) unconfirmed transactions used as inputs for this transaction\n"

" \"transactionid\", (string) parent transaction id\n"

" ... ]\n";

}

void entryToJSON(UniValue &info, const CTxMemPoolEntry &e)

{

AssertLockHeld(mempool.cs);

info.push_back(Pair("size", (int)e.GetTxSize()));

info.push_back(Pair("fee", ValueFromAmount(e.GetFee())));

info.push_back(Pair("modifiedfee", ValueFromAmount(e.GetModifiedFee())));

info.push_back(Pair("time", e.GetTime()));

info.push_back(Pair("height", (int)e.GetHeight()));

info.push_back(Pair("startingpriority", e.GetPriority(e.GetHeight())));

info.push_back(Pair("currentpriority", e.GetPriority(chainActive.Height())));

info.push_back(Pair("descendantcount", e.GetCountWithDescendants()));

info.push_back(Pair("descendantsize", e.GetSizeWithDescendants()));

info.push_back(Pair("descendantfees", e.GetModFeesWithDescendants()));

info.push_back(Pair("ancestorcount", e.GetCountWithAncestors()));

info.push_back(Pair("ancestorsize", e.GetSizeWithAncestors()));

info.push_back(Pair("ancestorfees", e.GetModFeesWithAncestors()));

const CTransaction& tx = e.GetTx();

set<string> setDepends;

BOOST_FOREACH(const CTxIn& txin, tx.vin)

{

if (mempool.exists(txin.prevout.hash))

setDepends.insert(txin.prevout.hash.ToString());

}

UniValue depends(UniValue::VARR);

BOOST_FOREACH(const string& dep, setDepends)

{

depends.push_back(dep);

}

info.push_back(Pair("depends", depends));

}

UniValue mempoolToJSON(bool fVerbose = false)

{

if (fVerbose)

{

LOCK(mempool.cs);

UniValue o(UniValue::VOBJ);

BOOST_FOREACH(const CTxMemPoolEntry& e, mempool.mapTx)

{

const uint256& hash = e.GetTx().GetHash();

UniValue info(UniValue::VOBJ);

entryToJSON(info, e);

o.push_back(Pair(hash.ToString(), info));

}

return o;

}

else

{

vector<uint256> vtxid;

mempool.queryHashes(vtxid);

UniValue a(UniValue::VARR);

BOOST_FOREACH(const uint256& hash, vtxid)

a.push_back(hash.ToString());

return a;

}

}

UniValue getrawmempool(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"getrawmempool ( verbose )\n"

"\nReturns all transaction ids in memory pool as a json array of string transaction ids.\n"

"\nArguments:\n"

"1. verbose (boolean, optional, default=false) true for a json object, false for array of transaction ids\n"

"\nResult: (for verbose = false):\n"

"[ (json array of string)\n"

" \"transactionid\" (string) The transaction id\n"

" ,...\n"

"]\n"

"\nResult: (for verbose = true):\n"

"{ (json object)\n"

" \"transactionid\" : { (json object)\n"

+ EntryDescriptionString()

+ " }, ...\n"

"}\n"

"\nExamples\n"

+ HelpExampleCli("getrawmempool", "true")

+ HelpExampleRpc("getrawmempool", "true")

);

bool fVerbose = false;

if (params.size() > 0)

fVerbose = params[0].get_bool();

return mempoolToJSON(fVerbose);

}

UniValue getmempoolancestors(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"getmempoolancestors txid (verbose)\n"

"\nIf txid is in the mempool, returns all in-mempool ancestors.\n"

"\nArguments:\n"

"1. \"txid\" (string, required) The transaction id (must be in mempool)\n"

"2. verbose (boolean, optional, default=false) true for a json object, false for array of transaction ids\n"

"\nResult (for verbose=false):\n"

"[ (json array of strings)\n"

" \"transactionid\" (string) The transaction id of an in-mempool ancestor transaction\n"

" ,...\n"

"]\n"

"\nResult (for verbose=true):\n"

"{ (json object)\n"

" \"transactionid\" : { (json object)\n"

+ EntryDescriptionString()

+ " }, ...\n"

"}\n"

"\nExamples\n"

+ HelpExampleCli("getmempoolancestors", "\"mytxid\"")

+ HelpExampleRpc("getmempoolancestors", "\"mytxid\"")

);

}

bool fVerbose = false;

if (params.size() > 1)

fVerbose = params[1].get_bool();

uint256 hash = ParseHashV(params[0], "parameter 1");

LOCK(mempool.cs);

CTxMemPool::txiter it = mempool.mapTx.find(hash);

if (it == mempool.mapTx.end()) {

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");

}

CTxMemPool::setEntries setAncestors;

uint64_t noLimit = std::numeric_limits<uint64_t>::max();

std::string dummy;

mempool.CalculateMemPoolAncestors(*it, setAncestors, noLimit, noLimit, noLimit, noLimit, dummy, false);

if (!fVerbose) {

UniValue o(UniValue::VARR);

BOOST_FOREACH(CTxMemPool::txiter ancestorIt, setAncestors) {

o.push_back(ancestorIt->GetTx().GetHash().ToString());

}

return o;

} else {

UniValue o(UniValue::VOBJ);

BOOST_FOREACH(CTxMemPool::txiter ancestorIt, setAncestors) {

const CTxMemPoolEntry &e = *ancestorIt;

const uint256& hash = e.GetTx().GetHash();

UniValue info(UniValue::VOBJ);

entryToJSON(info, e);

o.push_back(Pair(hash.ToString(), info));

}

return o;

}

}

UniValue getmempooldescendants(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"getmempooldescendants txid (verbose)\n"

"\nIf txid is in the mempool, returns all in-mempool descendants.\n"

"\nArguments:\n"

"1. \"txid\" (string, required) The transaction id (must be in mempool)\n"

"2. verbose (boolean, optional, default=false) true for a json object, false for array of transaction ids\n"

"\nResult (for verbose=false):\n"

"[ (json array of strings)\n"

" \"transactionid\" (string) The transaction id of an in-mempool descendant transaction\n"

" ,...\n"

"]\n"

"\nResult (for verbose=true):\n"

"{ (json object)\n"

" \"transactionid\" : { (json object)\n"

+ EntryDescriptionString()

+ " }, ...\n"

"}\n"

"\nExamples\n"

+ HelpExampleCli("getmempooldescendants", "\"mytxid\"")

+ HelpExampleRpc("getmempooldescendants", "\"mytxid\"")

);

}

bool fVerbose = false;

if (params.size() > 1)

fVerbose = params[1].get_bool();

uint256 hash = ParseHashV(params[0], "parameter 1");

LOCK(mempool.cs);

CTxMemPool::txiter it = mempool.mapTx.find(hash);

if (it == mempool.mapTx.end()) {

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");

}

CTxMemPool::setEntries setDescendants;

mempool.CalculateDescendants(it, setDescendants);

// CTxMemPool::CalculateDescendants will include the given tx

setDescendants.erase(it);

if (!fVerbose) {

UniValue o(UniValue::VARR);

BOOST_FOREACH(CTxMemPool::txiter descendantIt, setDescendants) {

o.push_back(descendantIt->GetTx().GetHash().ToString());

}

return o;

} else {

UniValue o(UniValue::VOBJ);

BOOST_FOREACH(CTxMemPool::txiter descendantIt, setDescendants) {

const CTxMemPoolEntry &e = *descendantIt;

const uint256& hash = e.GetTx().GetHash();

UniValue info(UniValue::VOBJ);

entryToJSON(info, e);

o.push_back(Pair(hash.ToString(), info));

}

return o;

}

}

UniValue getmempoolentry(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"getmempoolentry txid\n"

"\nReturns mempool data for given transaction\n"

"\nArguments:\n"

"1. \"txid\" (string, required) The transaction id (must be in mempool)\n"

"\nResult:\n"

"{ (json object)\n"

+ EntryDescriptionString()

+ "}\n"

"\nExamples\n"

+ HelpExampleCli("getmempoolentry", "\"mytxid\"")

+ HelpExampleRpc("getmempoolentry", "\"mytxid\"")

);

}

uint256 hash = ParseHashV(params[0], "parameter 1");

LOCK(mempool.cs);

CTxMemPool::txiter it = mempool.mapTx.find(hash);

if (it == mempool.mapTx.end()) {

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");

}

const CTxMemPoolEntry &e = *it;

UniValue info(UniValue::VOBJ);

entryToJSON(info, e);

return info;

}

UniValue getblockdeltas(const UniValue& params, bool fHelp)

{

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

throw runtime_error("");

std::string strHash = params[0].get_str();

uint256 hash(uint256S(strHash));

if (mapBlockIndex.count(hash) == 0)

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");

CBlock block;

CBlockIndex* pblockindex = mapBlockIndex[hash];

if (fHavePruned && !(pblockindex->nStatus & BLOCK_HAVE_DATA) && pblockindex->nTx > 0)

throw JSONRPCError(RPC_INTERNAL_ERROR, "Block not available (pruned data)");

if(!ReadBlockFromDisk(block, pblockindex, Params().GetConsensus()))

throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");

return blockToDeltasJSON(block, pblockindex);

}

UniValue getblockhashes(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"getblockhashes timestamp\n"

"\nReturns array of hashes of blocks within the timestamp range provided.\n"

"\nArguments:\n"

"1. high (numeric, required) The newer block timestamp\n"

"2. low (numeric, required) The older block timestamp\n"

"3. options (string, required) A json object\n"

" {\n"

" \"noOrphans\":true (boolean) will only include blocks on the main chain\n"

" \"logicalTimes\":true (boolean) will include logical timestamps with hashes\n"

" }\n"

"\nResult:\n"

"[\n"

" \"hash\" (string) The block hash\n"

"]\n"

"[\n"

" {\n"

" \"blockhash\": (string) The block hash\n"

" \"logicalts\": (numeric) The logical timestamp\n"

" }\n"

"]\n"

"\nExamples:\n"

+ HelpExampleCli("getblockhashes", "1231614698 1231024505")

+ HelpExampleRpc("getblockhashes", "1231614698, 1231024505")

+ HelpExampleCli("getblockhashes", "1231614698 1231024505 '{\"noOrphans\":false, \"logicalTimes\":true}'")

);

unsigned int high = params[0].get_int();

unsigned int low = params[1].get_int();

bool fActiveOnly = false;

bool fLogicalTS = false;

if (params.size() > 2) {

if (params[2].isObject()) {

UniValue noOrphans = find_value(params[2].get_obj(), "noOrphans");

UniValue returnLogical = find_value(params[2].get_obj(), "logicalTimes");

if (noOrphans.isBool())

fActiveOnly = noOrphans.get_bool();

if (returnLogical.isBool())

fLogicalTS = returnLogical.get_bool();

}

}

std::vector<std::pair<uint256, unsigned int> > blockHashes;

if (fActiveOnly)

LOCK(cs_main);

if (!GetTimestampIndex(high, low, fActiveOnly, blockHashes)) {

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available for block hashes");

}

UniValue result(UniValue::VARR);

for (std::vector<std::pair<uint256, unsigned int> >::const_iterator it=blockHashes.begin(); it!=blockHashes.end(); it++) {

if (fLogicalTS) {

UniValue item(UniValue::VOBJ);

item.push_back(Pair("blockhash", it->first.GetHex()));

item.push_back(Pair("logicalts", (int)it->second));

result.push_back(item);

} else {

result.push_back(it->first.GetHex());

}

}

return result;

}

UniValue getblockhash(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"getblockhash index\n"

"\nReturns hash of block in best-block-chain at index provided.\n"

"\nArguments:\n"

"1. index (numeric, required) The block index\n"

"\nResult:\n"

"\"hash\" (string) The block hash\n"

"\nExamples:\n"

+ HelpExampleCli("getblockhash", "1000")

+ HelpExampleRpc("getblockhash", "1000")

);

LOCK(cs_main);

int nHeight = params[0].get_int();

if (nHeight < 0 || nHeight > chainActive.Height())

throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range");

CBlockIndex* pblockindex = chainActive[nHeight];

return pblockindex->GetBlockHash().GetHex();

}

UniValue getblockheader(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"getblockheader \"hash\" ( verbose )\n"

"\nIf verbose is false, returns a string that is serialized, hex-encoded data for blockheader 'hash'.\n"

"If verbose is true, returns an Object with information about blockheader <hash>.\n"

"\nArguments:\n"

"1. \"hash\" (string, required) The block hash\n"

"2. verbose (boolean, optional, default=true) true for a json object, false for the hex encoded data\n"

"\nResult (for verbose = true):\n"

"{\n"

" \"hash\" : \"hash\", (string) the block hash (same as provided)\n"

" \"confirmations\" : n, (numeric) The number of confirmations, or -1 if the block is not on the main chain\n"

" \"height\" : n, (numeric) The block height or index\n"

" \"version\" : n, (numeric) The block version\n"

" \"versionHex\" : \"00000000\", (string) The block version formatted in hexadecimal\n"

" \"merkleroot\" : \"xxxx\", (string) The merkle root\n"

" \"time\" : ttt, (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)\n"

" \"mediantime\" : ttt, (numeric) The median block time in seconds since epoch (Jan 1 1970 GMT)\n"

" \"nonce\" : n, (numeric) The nonce\n"

" \"bits\" : \"1d00ffff\", (string) The bits\n"

" \"difficulty\" : x.xxx, (numeric) The difficulty\n"

" \"previousblockhash\" : \"hash\", (string) The hash of the previous block\n"

" \"nextblockhash\" : \"hash\", (string) The hash of the next block\n"

" \"chainwork\" : \"0000...1f3\" (string) Expected number of hashes required to produce the current chain (in hex)\n"

"}\n"

"\nResult (for verbose=false):\n"

"\"data\" (string) A string that is serialized, hex-encoded data for block 'hash'.\n"

"\nExamples:\n"

+ HelpExampleCli("getblockheader", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")

+ HelpExampleRpc("getblockheader", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")

);

LOCK(cs_main);

std::string strHash = params[0].get_str();

uint256 hash(uint256S(strHash));

bool fVerbose = true;

if (params.size() > 1)

fVerbose = params[1].get_bool();

if (mapBlockIndex.count(hash) == 0)

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");

CBlockIndex* pblockindex = mapBlockIndex[hash];

if (!fVerbose)

{

CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);

ssBlock << pblockindex->GetBlockHeader();

std::string strHex = HexStr(ssBlock.begin(), ssBlock.end());

return strHex;

}

return blockheaderToJSON(pblockindex);

}

UniValue getblock(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"getblock \"hash\" ( verbose )\n"

"\nIf verbose is false, returns a string that is serialized, hex-encoded data for block 'hash'.\n"

"If verbose is true, returns an Object with information about block <hash>.\n"

"\nArguments:\n"

"1. \"hash\" (string, required) The block hash\n"

"2. verbose (boolean, optional, default=true) true for a json object, false for the hex encoded data\n"

"\nResult (for verbose = true):\n"

"{\n"

" \"hash\" : \"hash\", (string) the block hash (same as provided)\n"

" \"confirmations\" : n, (numeric) The number of confirmations, or -1 if the block is not on the main chain\n"

" \"size\" : n, (numeric) The block size\n"

" \"strippedsize\" : n, (numeric) The block size excluding witness data\n"

" \"weight\" : n (numeric) The block weight (BIP 141)\n"

" \"height\" : n, (numeric) The block height or index\n"

" \"version\" : n, (numeric) The block version\n"

" \"versionHex\" : \"00000000\", (string) The block version formatted in hexadecimal\n"

" \"merkleroot\" : \"xxxx\", (string) The merkle root\n"

" \"tx\" : [ (array of string) The transaction ids\n"

" \"transactionid\" (string) The transaction id\n"

" ,...\n"

" ],\n"

" \"time\" : ttt, (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)\n"

" \"mediantime\" : ttt, (numeric) The median block time in seconds since epoch (Jan 1 1970 GMT)\n"

" \"nonce\" : n, (numeric) The nonce\n"

" \"bits\" : \"1d00ffff\", (string) The bits\n"

" \"difficulty\" : x.xxx, (numeric) The difficulty\n"

" \"chainwork\" : \"xxxx\", (string) Expected number of hashes required to produce the chain up to this block (in hex)\n"

" \"previousblockhash\" : \"hash\", (string) The hash of the previous block\n"

" \"nextblockhash\" : \"hash\" (string) The hash of the next block\n"

"}\n"

"\nResult (for verbose=false):\n"

"\"data\" (string) A string that is serialized, hex-encoded data for block 'hash'.\n"

"\nExamples:\n"

+ HelpExampleCli("getblock", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")

+ HelpExampleRpc("getblock", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")

);

LOCK(cs_main);

std::string strHash = params[0].get_str();

uint256 hash(uint256S(strHash));

bool fVerbose = true;

if (params.size() > 1)

fVerbose = params[1].get_bool();

if (mapBlockIndex.count(hash) == 0)

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");

CBlock block;

CBlockIndex* pblockindex = mapBlockIndex[hash];

if (fHavePruned && !(pblockindex->nStatus & BLOCK_HAVE_DATA) && pblockindex->nTx > 0)

throw JSONRPCError(RPC_INTERNAL_ERROR, "Block not available (pruned data)");

if(!ReadBlockFromDisk(block, pblockindex, Params().GetConsensus()))

throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");

if (!fVerbose)

{

CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);

ssBlock << block;

std::string strHex = HexStr(ssBlock.begin(), ssBlock.end());

return strHex;

}

return blockToJSON(block, pblockindex);

}

struct CCoinsStats

{

int nHeight;

uint256 hashBlock;

uint64_t nTransactions;

uint64_t nTransactionOutputs;

uint64_t nSerializedSize;

uint256 hashSerialized;

CAmount nTotalAmount;

CCoinsStats() : nHeight(0), nTransactions(0), nTransactionOutputs(0), nSerializedSize(0), nTotalAmount(0) {}

};

//! Calculate statistics about the unspent transaction output set

static bool GetUTXOStats(CCoinsView *view, CCoinsStats &stats)

{

boost::scoped_ptr<CCoinsViewCursor> pcursor(view->Cursor());

CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);

stats.hashBlock = pcursor->GetBestBlock();

{

LOCK(cs_main);

stats.nHeight = mapBlockIndex.find(stats.hashBlock)->second->nHeight;

}

ss << stats.hashBlock;

CAmount nTotalAmount = 0;

while (pcursor->Valid()) {

boost::this_thread::interruption_point();

uint256 key;

CCoins coins;

if (pcursor->GetKey(key) && pcursor->GetValue(coins)) {

stats.nTransactions++;

ss << key;

for (unsigned int i=0; i<coins.vout.size(); i++) {

const CTxOut &out = coins.vout[i];

if (!out.IsNull()) {

stats.nTransactionOutputs++;

ss << VARINT(i+1);

ss << out;

nTotalAmount += out.nValue;

}

}

stats.nSerializedSize += 32 + pcursor->GetValueSize();

ss << VARINT(0);

} else {

return error("%s: unable to read value", __func__);

}

pcursor->Next();

}

stats.hashSerialized = ss.GetHash();

stats.nTotalAmount = nTotalAmount;

return true;

}

UniValue gettxoutsetinfo(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"gettxoutsetinfo\n"

"\nReturns statistics about the unspent transaction output set.\n"

"Note this call may take some time.\n"

"\nResult:\n"

"{\n"

" \"height\":n, (numeric) The current block height (index)\n"

" \"bestblock\": \"hex\", (string) the best block hash hex\n"

" \"transactions\": n, (numeric) The number of transactions\n"

" \"txouts\": n, (numeric) The number of output transactions\n"

" \"bytes_serialized\": n, (numeric) The serialized size\n"

" \"hash_serialized\": \"hash\", (string) The serialized hash\n"

" \"total_amount\": x.xxx (numeric) The total amount\n"

"}\n"

"\nExamples:\n"

+ HelpExampleCli("gettxoutsetinfo", "")

+ HelpExampleRpc("gettxoutsetinfo", "")

);

UniValue ret(UniValue::VOBJ);

CCoinsStats stats;

FlushStateToDisk();

if (GetUTXOStats(pcoinsTip, stats)) {

ret.push_back(Pair("height", (int64_t)stats.nHeight));

ret.push_back(Pair("bestblock", stats.hashBlock.GetHex()));

ret.push_back(Pair("transactions", (int64_t)stats.nTransactions));

ret.push_back(Pair("txouts", (int64_t)stats.nTransactionOutputs));

ret.push_back(Pair("bytes_serialized", (int64_t)stats.nSerializedSize));

ret.push_back(Pair("hash_serialized", stats.hashSerialized.GetHex()));

ret.push_back(Pair("total_amount", ValueFromAmount(stats.nTotalAmount)));

}

return ret;

}

UniValue listproposals(const UniValue& params, bool fHelp)

{

if (fHelp)

throw runtime_error(

"listproposals \"filter\"\n"

"\nList the proposals and all the relating data including payment requests and status.\n"

"\nNote passing no argument returns all proposals regardless of state.\n"

"\nArguments:\n"

"\n1. \"filter\" (string, optional) \"accepted\" | \"rejected\" | \"expired\" | \"pending\"\n"

"\nExamples:\n"

+ HelpExampleCli("listproposal", "accepted")

+ HelpExampleRpc("listproposal", "")

);

LOCK(cs_main);

UniValue ret(UniValue::VARR);

bool showAll = true;

bool showAccepted = false;

bool showRejected = false;

bool showExpired = false;

bool showPending = false;

if(params.size() == 1) {

if(params[0].get_str() == "accepted") {

showAccepted = true;

showAll = false;

}

if(params[0].get_str() == "rejected") {

showRejected = true;

showAll = false;

}

if(params[0].get_str() == "expired") {

showAll = false;

showExpired = true;

}

if(params[0].get_str() == "pending") {

showAll = false;

showPending = true;

}

}

std::vector<CFund::CProposal> vec;

if(pblocktree->GetProposalIndex(vec))

{

BOOST_FOREACH(const CFund::CProposal& proposal, vec) {

if((showAll && (!proposal.IsExpired(pindexBestHeader->GetBlockTime())

|| proposal.fState == CFund::PENDING_VOTING_PREQ

|| proposal.fState == CFund::PENDING_FUNDS))

|| (showPending && (proposal.fState == CFund::NIL || proposal.fState == CFund::PENDING_VOTING_PREQ

|| proposal.fState == CFund::PENDING_FUNDS))

|| (showAccepted && (proposal.fState == CFund::ACCEPTED || proposal.IsAccepted()))

|| (showRejected && (proposal.fState == CFund::REJECTED || proposal.IsRejected()))

|| (showExpired && proposal.IsExpired(pindexBestHeader->GetBlockTime()))) {

UniValue o(UniValue::VOBJ);

proposal.ToJson(o, *pcoinsTip);

ret.push_back(o);

}

}

}

return ret;

}

UniValue cfundstats(const UniValue& params, bool fHelp)

{

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

throw runtime_error(

"cfundstats\n"

"\nReturns statistics about the community fund.\n"

+ HelpExampleCli("cfundstats", "")

+ HelpExampleRpc("cfundstats", "")

);

CFund::CProposal proposal; CFund::CPaymentRequest prequest;

int nBlocks = (chainActive.Tip()->nHeight % Params().GetConsensus().nBlocksPerVotingCycle) + 1;

CBlockIndex* pindexblock = chainActive.Tip();

std::map<uint256, bool> vSeen;

std::map<uint256, std::pair<int, int>> vCacheProposalsRPC;

std::map<uint256, std::pair<int, int>> vCachePaymentRequestRPC;

vCacheProposalsRPC.clear();

vCachePaymentRequestRPC.clear();

while(nBlocks > 0 && pindexblock != NULL) {

vSeen.clear();

for(unsigned int i = 0; i < pindexblock->vProposalVotes.size(); i++) {

if(!CFund::FindProposal(pindexblock->vProposalVotes[i].first, proposal))

continue;

if(vSeen.count(pindexblock->vProposalVotes[i].first) == 0) {

if(vCacheProposalsRPC.count(pindexblock->vProposalVotes[i].first) == 0)

vCacheProposalsRPC[pindexblock->vProposalVotes[i].first] = make_pair(0, 0);

if(pindexblock->vProposalVotes[i].second)

vCacheProposalsRPC[pindexblock->vProposalVotes[i].first].first += 1;

else

vCacheProposalsRPC[pindexblock->vProposalVotes[i].first].second += 1;

vSeen[pindexblock->vProposalVotes[i].first]=true;

}

}

for(unsigned int i = 0; i < pindexblock->vPaymentRequestVotes.size(); i++) {

if(!CFund::FindPaymentRequest(pindexblock->vPaymentRequestVotes[i].first, prequest))

continue;

if(!CFund::FindProposal(prequest.proposalhash, proposal))

continue;