src/rpcmining.cpp

   1 // Copyright (c) 2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2013 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "chainparams.h"
   7 #include "core_io.h"
   8 #include "init.h"
   9 #include "net.h"
  10 #include "main.h"
  11 #include "miner.h"
  12 #include "pow.h"
  13 #include "rpcserver.h"
  14 #include "util.h"
  15 #ifdef ENABLE_WALLET
  16 #include "db.h"
  17 #include "wallet.h"
  18 #endif
  19
  20 #include <stdint.h>
  21
  22 #include <boost/assign/list_of.hpp>
  23
  24 #include "json/json_spirit_utils.h"
  25 #include "json/json_spirit_value.h"
  26
  27 using namespace json_spirit;
  28 using namespace std;
  29
  30 // Return average network hashes per second based on the last 'lookup' blocks,
  31 // or from the last difficulty change if 'lookup' is nonpositive.
  32 // If 'height' is nonnegative, compute the estimate at the time when a given block was found.
  33 Value GetNetworkHashPS(int lookup, int height) {
  34     CBlockIndex *pb = chainActive.Tip();
  35
  36     if (height >= 0 && height < chainActive.Height())
  37         pb = chainActive[height];
  38
  39     if (pb == NULL || !pb->nHeight)
  40         return 0;
  41
  42     // If lookup is -1, then use blocks since last difficulty change.
  43     if (lookup <= 0)
  44         lookup = pb->nHeight % 2016 + 1;
  45
  46     // If lookup is larger than chain, then set it to chain length.
  47     if (lookup > pb->nHeight)
  48         lookup = pb->nHeight;
  49
  50     CBlockIndex *pb0 = pb;
  51     int64_t minTime = pb0->GetBlockTime();
  52     int64_t maxTime = minTime;
  53     for (int i = 0; i < lookup; i++) {
  54         pb0 = pb0->pprev;
  55         int64_t time = pb0->GetBlockTime();
  56         minTime = std::min(time, minTime);
  57         maxTime = std::max(time, maxTime);
  58     }
  59
  60     // In case there's a situation where minTime == maxTime, we don't want a divide by zero exception.
  61     if (minTime == maxTime)
  62         return 0;
  63
  64     uint256 workDiff = pb->nChainWork - pb0->nChainWork;
  65     int64_t timeDiff = maxTime - minTime;
  66
  67     return (int64_t)(workDiff.getdouble() / timeDiff);
  68 }
  69
  70 Value getnetworkhashps(const Array& params, bool fHelp)
  71 {
  72     if (fHelp || params.size() > 2)
  73         throw runtime_error(
  74             "getnetworkhashps ( blocks height )\n"
  75             "\nReturns the estimated network hashes per second based on the last n blocks.\n"
  76             "Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change.\n"
  77             "Pass in [height] to estimate the network speed at the time when a certain block was found.\n"
  78             "\nArguments:\n"
  79             "1. blocks     (numeric, optional, default=120) The number of blocks, or -1 for blocks since last difficulty change.\n"
  80             "2. height     (numeric, optional, default=-1) To estimate at the time of the given height.\n"
  81             "\nResult:\n"
  82             "x             (numeric) Hashes per second estimated\n"
  83             "\nExamples:\n"
  84             + HelpExampleCli("getnetworkhashps", "")
  85             + HelpExampleRpc("getnetworkhashps", "")
  86        );
  87
  88     return GetNetworkHashPS(params.size() > 0 ? params[0].get_int() : 120, params.size() > 1 ? params[1].get_int() : -1);
  89 }
  90
  91 #ifdef ENABLE_WALLET
  92 Value getgenerate(const Array& params, bool fHelp)
  93 {
  94     if (fHelp || params.size() != 0)
  95         throw runtime_error(
  96             "getgenerate\n"
  97             "\nReturn if the server is set to generate coins or not. The default is false.\n"
  98             "It is set with the command line argument -gen (or bitcoin.conf setting gen)\n"
  99             "It can also be set with the setgenerate call.\n"
 100             "\nResult\n"
 101             "true|false      (boolean) If the server is set to generate coins or not\n"
 102             "\nExamples:\n"
 103             + HelpExampleCli("getgenerate", "")
 104             + HelpExampleRpc("getgenerate", "")
 105         );
 106
 107     return GetBoolArg("-gen", false);
 108 }
 109
 110
 111 Value setgenerate(const Array& params, bool fHelp)
 112 {
 113     if (fHelp || params.size() < 1 || params.size() > 2)
 114         throw runtime_error(
 115             "setgenerate generate ( genproclimit )\n"
 116             "\nSet 'generate' true or false to turn generation on or off.\n"
 117             "Generation is limited to 'genproclimit' processors, -1 is unlimited.\n"
 118             "See the getgenerate call for the current setting.\n"
 119             "\nArguments:\n"
 120             "1. generate         (boolean, required) Set to true to turn on generation, off to turn off.\n"
 121             "2. genproclimit     (numeric, optional) Set the processor limit for when generation is on. Can be -1 for unlimited.\n"
 122             "                    Note: in -regtest mode, genproclimit controls how many blocks are generated immediately.\n"
 123             "\nExamples:\n"
 124             "\nSet the generation on with a limit of one processor\n"
 125             + HelpExampleCli("setgenerate", "true 1") +
 126             "\nCheck the setting\n"
 127             + HelpExampleCli("getgenerate", "") +
 128             "\nTurn off generation\n"
 129             + HelpExampleCli("setgenerate", "false") +
 130             "\nUsing json rpc\n"
 131             + HelpExampleRpc("setgenerate", "true, 1")
 132         );
 133
 134     if (pwalletMain == NULL)
 135         throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found (disabled)");
 136
 137     bool fGenerate = true;
 138     if (params.size() > 0)
 139         fGenerate = params[0].get_bool();
 140
 141     int nGenProcLimit = -1;
 142     if (params.size() > 1)
 143     {
 144         nGenProcLimit = params[1].get_int();
 145         if (nGenProcLimit == 0)
 146             fGenerate = false;
 147     }
 148
 149     // -regtest mode: don't return until nGenProcLimit blocks are generated
 150     if (fGenerate && Params().MineBlocksOnDemand())
 151     {
 152         int nHeightStart = 0;
 153         int nHeightEnd = 0;
 154         int nHeight = 0;
 155         int nGenerate = (nGenProcLimit > 0 ? nGenProcLimit : 1);
 156         {   // Don't keep cs_main locked
 157             LOCK(cs_main);
 158             nHeightStart = chainActive.Height();
 159             nHeight = nHeightStart;
 160             nHeightEnd = nHeightStart+nGenerate;
 161         }
 162         int nHeightLast = -1;
 163         while (nHeight < nHeightEnd)
 164         {
 165             if (nHeightLast != nHeight)
 166             {
 167                 nHeightLast = nHeight;
 168                 GenerateBitcoins(fGenerate, pwalletMain, 1);
 169             }
 170             MilliSleep(1);
 171             {   // Don't keep cs_main locked
 172                 LOCK(cs_main);
 173                 nHeight = chainActive.Height();
 174             }
 175         }
 176     }
 177     else // Not -regtest: start generate thread, return immediately
 178     {
 179         mapArgs["-gen"] = (fGenerate ? "1" : "0");
 180         mapArgs ["-genproclimit"] = itostr(nGenProcLimit);
 181         GenerateBitcoins(fGenerate, pwalletMain, nGenProcLimit);
 182     }
 183
 184     return Value::null;
 185 }
 186
 187 Value gethashespersec(const Array& params, bool fHelp)
 188 {
 189     if (fHelp || params.size() != 0)
 190         throw runtime_error(
 191             "gethashespersec\n"
 192             "\nReturns a recent hashes per second performance measurement while generating.\n"
 193             "See the getgenerate and setgenerate calls to turn generation on and off.\n"
 194             "\nResult:\n"
 195             "n            (numeric) The recent hashes per second when generation is on (will return 0 if generation is off)\n"
 196             "\nExamples:\n"
 197             + HelpExampleCli("gethashespersec", "")
 198             + HelpExampleRpc("gethashespersec", "")
 199         );
 200
 201     if (GetTimeMillis() - nHPSTimerStart > 8000)
 202         return (int64_t)0;
 203     return (int64_t)dHashesPerSec;
 204 }
 205 #endif
 206
 207
 208 Value getmininginfo(const Array& params, bool fHelp)
 209 {
 210     if (fHelp || params.size() != 0)
 211         throw runtime_error(
 212             "getmininginfo\n"
 213             "\nReturns a json object containing mining-related information."
 214             "\nResult:\n"
 215             "{\n"
 216             "  \"blocks\": nnn,             (numeric) The current block\n"
 217             "  \"currentblocksize\": nnn,   (numeric) The last block size\n"
 218             "  \"currentblocktx\": nnn,     (numeric) The last block transaction\n"
 219             "  \"difficulty\": xxx.xxxxx    (numeric) The current difficulty\n"
 220             "  \"errors\": \"...\"          (string) Current errors\n"
 221             "  \"generate\": true|false     (boolean) If the generation is on or off (see getgenerate or setgenerate calls)\n"
 222             "  \"genproclimit\": n          (numeric) The processor limit for generation. -1 if no generation. (see getgenerate or setgenerate calls)\n"
 223             "  \"hashespersec\": n          (numeric) The hashes per second of the generation, or 0 if no generation.\n"
 224             "  \"pooledtx\": n              (numeric) The size of the mem pool\n"
 225             "  \"testnet\": true|false      (boolean) If using testnet or not\n"
 226             "  \"chain\": \"xxxx\",         (string) current network name as defined in BIP70 (main, test, regtest)\n"
 227             "}\n"
 228             "\nExamples:\n"
 229             + HelpExampleCli("getmininginfo", "")
 230             + HelpExampleRpc("getmininginfo", "")
 231         );
 232
 233     Object obj;
 234     obj.push_back(Pair("blocks",           (int)chainActive.Height()));
 235     obj.push_back(Pair("currentblocksize", (uint64_t)nLastBlockSize));
 236     obj.push_back(Pair("currentblocktx",   (uint64_t)nLastBlockTx));
 237     obj.push_back(Pair("difficulty",       (double)GetDifficulty()));
 238     obj.push_back(Pair("errors",           GetWarnings("statusbar")));
 239     obj.push_back(Pair("genproclimit",     (int)GetArg("-genproclimit", -1)));
 240     obj.push_back(Pair("networkhashps",    getnetworkhashps(params, false)));
 241     obj.push_back(Pair("pooledtx",         (uint64_t)mempool.size()));
 242     obj.push_back(Pair("testnet",          Params().NetworkID() == CBaseChainParams::TESTNET));
 243     obj.push_back(Pair("chain",            Params().NetworkIDString()));
 244 #ifdef ENABLE_WALLET
 245     obj.push_back(Pair("generate",         getgenerate(params, false)));
 246     obj.push_back(Pair("hashespersec",     gethashespersec(params, false)));
 247 #endif
 248     return obj;
 249 }
 250
 251
 252 Value prioritisetransaction(const Array& params, bool fHelp)
 253 {
 254     if (fHelp || params.size() != 3)
 255         throw runtime_error(
 256             "prioritisetransaction <txid> <priority delta> <fee delta>\n"
 257             "Accepts the transaction into mined blocks at a higher (or lower) priority\n"
 258             "\nArguments:\n"
 259             "1. \"txid\"       (string, required) The transaction id.\n"
 260             "2. priority delta (numeric, required) The priority to add or subtract.\n"
 261             "                  The transaction selection algorithm considers the tx as it would have a higher priority.\n"
 262             "                  (priority of a transaction is calculated: coinage * value_in_satoshis / txsize) \n"
 263             "3. fee delta      (numeric, required) The absolute fee value to add or subtract in bitcoin.\n"
 264             "                  The fee is not actually paid, only the algorithm for selecting transactions into a block\n"
 265             "                  considers the transaction as it would have paid a higher (or lower) fee.\n"
 266             "\nResult\n"
 267             "true              (boolean) Returns true\n"
 268             "\nExamples:\n"
 269             + HelpExampleCli("prioritisetransaction", "\"txid\" 0.0 0.00010000")
 270             + HelpExampleRpc("prioritisetransaction", "\"txid\", 0.0, 0.00010000")
 271         );
 272
 273     uint256 hash;
 274     hash.SetHex(params[0].get_str());
 275
 276     int64_t nAmount = 0;
 277     if (params[2].get_real() != 0.0)
 278         nAmount = AmountFromValue(params[2]);
 279
 280     mempool.PrioritiseTransaction(hash, params[0].get_str(), params[1].get_real(), nAmount);
 281     return true;
 282 }
 283
 284
 285 Value getblocktemplate(const Array& params, bool fHelp)
 286 {
 287     if (fHelp || params.size() > 1)
 288         throw runtime_error(
 289             "getblocktemplate ( \"jsonrequestobject\" )\n"
 290             "\nIf the request parameters include a 'mode' key, that is used to explicitly select between the default 'template' request or a 'proposal'.\n"
 291             "It returns data needed to construct a block to work on.\n"
 292             "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n"
 293
 294             "\nArguments:\n"
 295             "1. \"jsonrequestobject\"       (string, optional) A json object in the following spec\n"
 296             "     {\n"
 297             "       \"mode\":\"template\"    (string, optional) This must be set to \"template\" or omitted\n"
 298             "       \"capabilities\":[       (array, optional) A list of strings\n"
 299             "           \"support\"           (string) client side supported feature, 'longpoll', 'coinbasetxn', 'coinbasevalue', 'proposal', 'serverlist', 'workid'\n"
 300             "           ,...\n"
 301             "         ]\n"
 302             "     }\n"
 303             "\n"
 304
 305             "\nResult:\n"
 306             "{\n"
 307             "  \"version\" : n,                    (numeric) The block version\n"
 308             "  \"previousblockhash\" : \"xxxx\",    (string) The hash of current highest block\n"
 309             "  \"transactions\" : [                (array) contents of non-coinbase transactions that should be included in the next block\n"
 310             "      {\n"
 311             "         \"data\" : \"xxxx\",          (string) transaction data encoded in hexadecimal (byte-for-byte)\n"
 312             "         \"hash\" : \"xxxx\",          (string) hash/id encoded in little-endian hexadecimal\n"
 313             "         \"depends\" : [              (array) array of numbers \n"
 314             "             n                        (numeric) transactions before this one (by 1-based index in 'transactions' list) that must be present in the final block if this one is\n"
 315             "             ,...\n"
 316             "         ],\n"
 317             "         \"fee\": n,                   (numeric) difference in value between transaction inputs and outputs (in Satoshis); for coinbase transactions, this is a negative Number of the total collected block fees (ie, not including the block subsidy); if key is not present, fee is unknown and clients MUST NOT assume there isn't one\n"
 318             "         \"sigops\" : n,               (numeric) total number of SigOps, as counted for purposes of block limits; if key is not present, sigop count is unknown and clients MUST NOT assume there aren't any\n"
 319             "         \"required\" : true|false     (boolean) if provided and true, this transaction must be in the final block\n"
 320             "      }\n"
 321             "      ,...\n"
 322             "  ],\n"
 323             "  \"coinbaseaux\" : {                  (json object) data that should be included in the coinbase's scriptSig content\n"
 324             "      \"flags\" : \"flags\"            (string) \n"
 325             "  },\n"
 326             "  \"coinbasevalue\" : n,               (numeric) maximum allowable input to coinbase transaction, including the generation award and transaction fees (in Satoshis)\n"
 327             "  \"coinbasetxn\" : { ... },           (json object) information for coinbase transaction\n"
 328             "  \"target\" : \"xxxx\",               (string) The hash target\n"
 329             "  \"mintime\" : xxx,                   (numeric) The minimum timestamp appropriate for next block time in seconds since epoch (Jan 1 1970 GMT)\n"
 330             "  \"mutable\" : [                      (array of string) list of ways the block template may be changed \n"
 331             "     \"value\"                         (string) A way the block template may be changed, e.g. 'time', 'transactions', 'prevblock'\n"
 332             "     ,...\n"
 333             "  ],\n"
 334             "  \"noncerange\" : \"00000000ffffffff\",   (string) A range of valid nonces\n"
 335             "  \"sigoplimit\" : n,                 (numeric) limit of sigops in blocks\n"
 336             "  \"sizelimit\" : n,                  (numeric) limit of block size\n"
 337             "  \"curtime\" : ttt,                  (numeric) current timestamp in seconds since epoch (Jan 1 1970 GMT)\n"
 338             "  \"bits\" : \"xxx\",                 (string) compressed target of next block\n"
 339             "  \"height\" : n                      (numeric) The height of the next block\n"
 340             "}\n"
 341
 342             "\nExamples:\n"
 343             + HelpExampleCli("getblocktemplate", "")
 344             + HelpExampleRpc("getblocktemplate", "")
 345          );
 346
 347     std::string strMode = "template";
 348     Value lpval = Value::null;
 349     if (params.size() > 0)
 350     {
 351         const Object& oparam = params[0].get_obj();
 352         const Value& modeval = find_value(oparam, "mode");
 353         if (modeval.type() == str_type)
 354             strMode = modeval.get_str();
 355         else if (modeval.type() == null_type)
 356         {
 357             /* Do nothing */
 358         }
 359         else
 360             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
 361         lpval = find_value(oparam, "longpollid");
 362     }
 363
 364     if (strMode != "template")
 365         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
 366
 367     if (vNodes.empty())
 368         throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Bitcoin is not connected!");
 369
 370     if (IsInitialBlockDownload())
 371         throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Bitcoin is downloading blocks...");
 372
 373     static unsigned int nTransactionsUpdatedLast;
 374
 375     if (lpval.type() != null_type)
 376     {
 377         // Wait to respond until either the best block changes, OR a minute has passed and there are more transactions
 378         uint256 hashWatchedChain;
 379         boost::system_time checktxtime;
 380         unsigned int nTransactionsUpdatedLastLP;
 381
 382         if (lpval.type() == str_type)
 383         {
 384             // Format: <hashBestChain><nTransactionsUpdatedLast>
 385             std::string lpstr = lpval.get_str();
 386
 387             hashWatchedChain.SetHex(lpstr.substr(0, 64));
 388             nTransactionsUpdatedLastLP = atoi64(lpstr.substr(64));
 389         }
 390         else
 391         {
 392             // NOTE: Spec does not specify behaviour for non-string longpollid, but this makes testing easier
 393             hashWatchedChain = chainActive.Tip()->GetBlockHash();
 394             nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
 395         }
 396
 397         // Release the wallet and main lock while waiting
 398 #ifdef ENABLE_WALLET
 399         if(pwalletMain)
 400             LEAVE_CRITICAL_SECTION(pwalletMain->cs_wallet);
 401 #endif
 402         LEAVE_CRITICAL_SECTION(cs_main);
 403         {
 404             checktxtime = boost::get_system_time() + boost::posix_time::minutes(1);
 405
 406             boost::unique_lock<boost::mutex> lock(csBestBlock);
 407             while (chainActive.Tip()->GetBlockHash() == hashWatchedChain && IsRPCRunning())
 408             {
 409                 if (!cvBlockChange.timed_wait(lock, checktxtime))
 410                 {
 411                     // Timeout: Check transactions for update
 412                     if (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLastLP)
 413                         break;
 414                     checktxtime += boost::posix_time::seconds(10);
 415                 }
 416             }
 417         }
 418         ENTER_CRITICAL_SECTION(cs_main);
 419 #ifdef ENABLE_WALLET
 420         if(pwalletMain)
 421             ENTER_CRITICAL_SECTION(pwalletMain->cs_wallet);
 422 #endif
 423
 424         if (!IsRPCRunning())
 425             throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
 426         // TODO: Maybe recheck connections/IBD and (if something wrong) send an expires-immediately template to stop miners?
 427     }
 428
 429     // Update block
 430     static CBlockIndex* pindexPrev;
 431     static int64_t nStart;
 432     static CBlockTemplate* pblocktemplate;
 433     if (pindexPrev != chainActive.Tip() ||
 434         (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - nStart > 5))
 435     {
 436         // Clear pindexPrev so future calls make a new block, despite any failures from here on
 437         pindexPrev = NULL;
 438
 439         // Store the pindexBest used before CreateNewBlock, to avoid races
 440         nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
 441         CBlockIndex* pindexPrevNew = chainActive.Tip();
 442         nStart = GetTime();
 443
 444         // Create new block
 445         if(pblocktemplate)
 446         {
 447             delete pblocktemplate;
 448             pblocktemplate = NULL;
 449         }
 450         CScript scriptDummy = CScript() << OP_TRUE;
 451         pblocktemplate = CreateNewBlock(scriptDummy);
 452         if (!pblocktemplate)
 453             throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
 454
 455         // Need to update only after we know CreateNewBlock succeeded
 456         pindexPrev = pindexPrevNew;
 457     }
 458     CBlock* pblock = &pblocktemplate->block; // pointer for convenience
 459
 460     // Update nTime
 461     UpdateTime(pblock, pindexPrev);
 462     pblock->nNonce = 0;
 463
 464     Array transactions;
 465     map<uint256, int64_t> setTxIndex;
 466     int i = 0;
 467     BOOST_FOREACH (CTransaction& tx, pblock->vtx)
 468     {
 469         uint256 txHash = tx.GetHash();
 470         setTxIndex[txHash] = i++;
 471
 472         if (tx.IsCoinBase())
 473             continue;
 474
 475         Object entry;
 476
 477         entry.push_back(Pair("data", EncodeHexTx(tx)));
 478
 479         entry.push_back(Pair("hash", txHash.GetHex()));
 480
 481         Array deps;
 482         BOOST_FOREACH (const CTxIn &in, tx.vin)
 483         {
 484             if (setTxIndex.count(in.prevout.hash))
 485                 deps.push_back(setTxIndex[in.prevout.hash]);
 486         }
 487         entry.push_back(Pair("depends", deps));
 488
 489         int index_in_template = i - 1;
 490         entry.push_back(Pair("fee", pblocktemplate->vTxFees[index_in_template]));
 491         entry.push_back(Pair("sigops", pblocktemplate->vTxSigOps[index_in_template]));
 492
 493         transactions.push_back(entry);
 494     }
 495
 496     Object aux;
 497     aux.push_back(Pair("flags", HexStr(COINBASE_FLAGS.begin(), COINBASE_FLAGS.end())));
 498
 499     uint256 hashTarget = uint256().SetCompact(pblock->nBits);
 500
 501     static Array aMutable;
 502     if (aMutable.empty())
 503     {
 504         aMutable.push_back("time");
 505         aMutable.push_back("transactions");
 506         aMutable.push_back("prevblock");
 507     }
 508
 509     Object result;
 510     result.push_back(Pair("version", pblock->nVersion));
 511     result.push_back(Pair("previousblockhash", pblock->hashPrevBlock.GetHex()));
 512     result.push_back(Pair("transactions", transactions));
 513     result.push_back(Pair("coinbaseaux", aux));
 514     result.push_back(Pair("coinbasevalue", (int64_t)pblock->vtx[0].vout[0].nValue));
 515     result.push_back(Pair("longpollid", chainActive.Tip()->GetBlockHash().GetHex() + i64tostr(nTransactionsUpdatedLast)));
 516     result.push_back(Pair("target", hashTarget.GetHex()));
 517     result.push_back(Pair("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1));
 518     result.push_back(Pair("mutable", aMutable));
 519     result.push_back(Pair("noncerange", "00000000ffffffff"));
 520     result.push_back(Pair("sigoplimit", (int64_t)MAX_BLOCK_SIGOPS));
 521     result.push_back(Pair("sizelimit", (int64_t)MAX_BLOCK_SIZE));
 522     result.push_back(Pair("curtime", pblock->GetBlockTime()));
 523     result.push_back(Pair("bits", strprintf("%08x", pblock->nBits)));
 524     result.push_back(Pair("height", (int64_t)(pindexPrev->nHeight+1)));
 525
 526     return result;
 527 }
 528
 529 Value submitblock(const Array& params, bool fHelp)
 530 {
 531     if (fHelp || params.size() < 1 || params.size() > 2)
 532         throw runtime_error(
 533             "submitblock \"hexdata\" ( \"jsonparametersobject\" )\n"
 534             "\nAttempts to submit new block to network.\n"
 535             "The 'jsonparametersobject' parameter is currently ignored.\n"
 536             "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n"
 537
 538             "\nArguments\n"
 539             "1. \"hexdata\"    (string, required) the hex-encoded block data to submit\n"
 540             "2. \"jsonparametersobject\"     (string, optional) object of optional parameters\n"
 541             "    {\n"
 542             "      \"workid\" : \"id\"    (string, optional) if the server provided a workid, it MUST be included with submissions\n"
 543             "    }\n"
 544             "\nResult:\n"
 545             "\nExamples:\n"
 546             + HelpExampleCli("submitblock", "\"mydata\"")
 547             + HelpExampleRpc("submitblock", "\"mydata\"")
 548         );
 549
 550     vector<unsigned char> blockData(ParseHex(params[0].get_str()));
 551     CDataStream ssBlock(blockData, SER_NETWORK, PROTOCOL_VERSION);
 552     CBlock pblock;
 553     try {
 554         ssBlock >> pblock;
 555     }
 556     catch (std::exception &e) {
 557         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
 558     }
 559
 560     CValidationState state;
 561     bool fAccepted = ProcessBlock(state, NULL, &pblock);
 562     if (!fAccepted)
 563         return "rejected"; // TODO: report validation state
 564
 565     return Value::null;
 566 }
 567
 568 Value estimatefee(const Array& params, bool fHelp)
 569 {
 570     if (fHelp || params.size() != 1)
 571         throw runtime_error(
 572             "estimatefee nblocks\n"
 573             "\nEstimates the approximate fee per kilobyte\n"
 574             "needed for a transaction to get confirmed\n"
 575             "within nblocks blocks.\n"
 576             "\nArguments:\n"
 577             "1. nblocks     (numeric)\n"
 578             "\nResult:\n"
 579             "n :    (numeric) estimated fee-per-kilobyte\n"
 580             "\n"
 581             "-1.0 is returned if not enough transactions and\n"
 582             "blocks have been observed to make an estimate.\n"
 583             "\nExample:\n"
 584             + HelpExampleCli("estimatefee", "6")
 585             );
 586
 587     RPCTypeCheck(params, boost::assign::list_of(int_type));
 588
 589     int nBlocks = params[0].get_int();
 590     if (nBlocks < 1)
 591         nBlocks = 1;
 592
 593     CFeeRate feeRate = mempool.estimateFee(nBlocks);
 594     if (feeRate == CFeeRate(0))
 595         return -1.0;
 596
 597     return ValueFromAmount(feeRate.GetFeePerK());
 598 }
 599
 600 Value estimatepriority(const Array& params, bool fHelp)
 601 {
 602     if (fHelp || params.size() != 1)
 603         throw runtime_error(
 604             "estimatepriority nblocks\n"
 605             "\nEstimates the approximate priority\n"
 606             "a zero-fee transaction needs to get confirmed\n"
 607             "within nblocks blocks.\n"
 608             "\nArguments:\n"
 609             "1. nblocks     (numeric)\n"
 610             "\nResult:\n"
 611             "n :    (numeric) estimated priority\n"
 612             "\n"
 613             "-1.0 is returned if not enough transactions and\n"
 614             "blocks have been observed to make an estimate.\n"
 615             "\nExample:\n"
 616             + HelpExampleCli("estimatepriority", "6")
 617             );
 618
 619     RPCTypeCheck(params, boost::assign::list_of(int_type));
 620
 621     int nBlocks = params[0].get_int();
 622     if (nBlocks < 1)
 623         nBlocks = 1;
 624
 625     return mempool.estimatePriority(nBlocks);
 626 }