PRCYCoin  2.0.0.7rc1
P2P Digital Currency
masternode.cpp
Go to the documentation of this file.
1 // Copyright (c) 2009-2012 The Bitcoin developers
2 // Copyright (c) 2015-2018 The PIVX developers
3 // Copyright (c) 2018-2020 The DAPS Project developers
4 // Distributed under the MIT/X11 software license, see the accompanying
5 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
6 
7 #include "activemasternode.h"
8 #include "wallet/db.h"
9 #include "init.h"
10 #include "main.h"
11 #include "masternode-payments.h"
12 #include "masternode-sync.h"
13 #include "masternodeconfig.h"
14 #include "masternodeman.h"
15 #include "netbase.h"
16 #include "rpc/server.h"
17 #include "utilmoneystr.h"
18 
19 #include <boost/tokenizer.hpp>
20 #include <univalue.h>
21 
22 extern CAmount GetSeeSaw(const CAmount& blockValue, int nMasternodeCount, int nHeight);
23 
24 UniValue masternode(const UniValue& params, bool fHelp)
25 {
26  std::string strCommand;
27  if (params.size() >= 1)
28  strCommand = params[0].get_str();
29 
30  if (fHelp ||
31  (strCommand != "start" && strCommand != "start-alias" && strCommand != "start-many" && strCommand != "start-all" && strCommand != "start-missing" &&
32  strCommand != "start-disabled" && strCommand != "list" && strCommand != "list-conf" && strCommand != "count" && strCommand != "enforce" &&
33  strCommand != "debug" && strCommand != "current" && strCommand != "winners" && strCommand != "genkey" && strCommand != "connect" &&
34  strCommand != "outputs" && strCommand != "status" && strCommand != "calcscore"))
35  throw std::runtime_error(
36  "masternode \"command\"...\n"
37  "\nSet of commands to execute masternode related actions\n"
38  "This command is depreciated, please see individual command documentation for future reference\n\n"
39 
40  "\nArguments:\n"
41  "1. \"command\" (string or set of strings, required) The command to execute\n"
42 
43  "\nAvailable commands:\n"
44  " count - Print count information of all known masternodes\n"
45  " current - Print info on current masternode winner\n"
46  " debug - Print masternode status\n"
47  " genkey - Generate new masternodeprivkey\n"
48  " outputs - Print masternode compatible outputs\n"
49  " start - Start masternode configured in prcycoin.conf\n"
50  " start-alias - Start single masternode by assigned alias configured in masternode.conf\n"
51  " start-<mode> - Start masternodes configured in masternode.conf (<mode>: 'all', 'missing', 'disabled')\n"
52  " status - Print masternode status information\n"
53  " list - Print list of all known masternodes (see masternodelist for more info)\n"
54  " list-conf - Print masternode.conf in JSON format\n"
55  " winners - Print list of masternode winners\n");
56 
57  if (strCommand == "list") {
58  UniValue newParams(UniValue::VARR);
59  // forward params but skip command
60  for (unsigned int i = 1; i < params.size(); i++) {
61  newParams.push_back(params[i]);
62  }
63  return listmasternodes(newParams, fHelp);
64  }
65 
66  if (strCommand == "connect") {
67  UniValue newParams(UniValue::VARR);
68  // forward params but skip command
69  for (unsigned int i = 1; i < params.size(); i++) {
70  newParams.push_back(params[i]);
71  }
72  }
73 
74  if (strCommand == "count") {
75  UniValue newParams(UniValue::VARR);
76  // forward params but skip command
77  for (unsigned int i = 1; i < params.size(); i++) {
78  newParams.push_back(params[i]);
79  }
80  return getmasternodecount(newParams, fHelp);
81  }
82 
83  if (strCommand == "current") {
84  UniValue newParams(UniValue::VARR);
85  // forward params but skip command
86  for (unsigned int i = 1; i < params.size(); i++) {
87  newParams.push_back(params[i]);
88  }
89  return masternodecurrent(newParams, fHelp);
90  }
91 
92  if (strCommand == "start" || strCommand == "start-alias" || strCommand == "start-many" || strCommand == "start-all" || strCommand == "start-missing" || strCommand == "start-disabled") {
93  return startmasternode(params, fHelp);
94  }
95 
96  if (strCommand == "genkey") {
97  UniValue newParams(UniValue::VARR);
98  // forward params but skip command
99  for (unsigned int i = 1; i < params.size(); i++) {
100  newParams.push_back(params[i]);
101  }
102  return createmasternodekey(newParams, fHelp);
103  }
104 
105  if (strCommand == "list-conf") {
106  UniValue newParams(UniValue::VARR);
107  // forward params but skip command
108  for (unsigned int i = 1; i < params.size(); i++) {
109  newParams.push_back(params[i]);
110  }
111  return listmasternodeconf(newParams, fHelp);
112  }
113 
114  if (strCommand == "outputs") {
115  UniValue newParams(UniValue::VARR);
116  // forward params but skip command
117  for (unsigned int i = 1; i < params.size(); i++) {
118  newParams.push_back(params[i]);
119  }
120  return getmasternodeoutputs(newParams, fHelp);
121  }
122 
123  if (strCommand == "status") {
124  UniValue newParams(UniValue::VARR);
125  // forward params but skip command
126  for (unsigned int i = 1; i < params.size(); i++) {
127  newParams.push_back(params[i]);
128  }
129  return getmasternodestatus(newParams, fHelp);
130  }
131 
132  if (strCommand == "winners") {
133  UniValue newParams(UniValue::VARR);
134  // forward params but skip command
135  for (unsigned int i = 1; i < params.size(); i++) {
136  newParams.push_back(params[i]);
137  }
138  return getmasternodewinners(newParams, fHelp);
139  }
140 
141  if (strCommand == "calcscore") {
142  UniValue newParams(UniValue::VARR);
143  // forward params but skip command
144  for (unsigned int i = 1; i < params.size(); i++) {
145  newParams.push_back(params[i]);
146  }
147  return getmasternodescores(newParams, fHelp);
148  }
149 
150  return NullUniValue;
151 }
152 
153 UniValue listmasternodes(const UniValue& params, bool fHelp)
154 {
155  std::string strFilter = "";
156 
157  if (params.size() == 1) strFilter = params[0].get_str();
158 
159  if (fHelp || (params.size() > 1))
160  throw std::runtime_error(
161  "listmasternodes ( \"filter\" )\n"
162  "\nGet a ranked list of masternodes\n"
163 
164  "\nArguments:\n"
165  "1. \"filter\" (string, optional) Filter search text. Partial match by txhash, status, or addr.\n"
166 
167  "\nResult:\n"
168  "[\n"
169  " {\n"
170  " \"rank\": n, (numeric) Masternode Rank (or 0 if not enabled)\n"
171  " \"txhash\": \"hash\", (string) Collateral transaction hash\n"
172  " \"outidx\": n, (numeric) Collateral transaction output index\n"
173  " \"pubkey\": \"key\", (string) Masternode public key used for message broadcasting\n"
174  " \"status\": s, (string) Status (ENABLED/EXPIRED/REMOVE/etc)\n"
175  " \"addr\": \"addr\", (string) Masternode PRCY address\n"
176  " \"version\": v, (numeric) Masternode protocol version\n"
177  " \"lastseen\": ttt, (numeric) The time in seconds since epoch (Jan 1 1970 GMT) of the last seen\n"
178  " \"activetime\": ttt, (numeric) The time in seconds since epoch (Jan 1 1970 GMT) masternode has been active\n"
179  " \"lastpaid\": ttt, (numeric) The time in seconds since epoch (Jan 1 1970 GMT) masternode was last paid\n"
180  " }\n"
181  " ,...\n"
182  "]\n"
183  "\nExamples:\n" +
184  HelpExampleCli("masternodelist", "") + HelpExampleRpc("masternodelist", ""));
185 
186  UniValue ret(UniValue::VARR);
187  int nHeight;
188  {
189  LOCK(cs_main);
190  CBlockIndex* pindex = chainActive.Tip();
191  if(!pindex) return 0;
192  nHeight = pindex->nHeight;
193  }
194  std::vector<std::pair<int, CMasternode> > vMasternodeRanks = mnodeman.GetMasternodeRanks(nHeight);
195  for (PAIRTYPE(int, CMasternode) & s : vMasternodeRanks) {
196  UniValue obj(UniValue::VOBJ);
197  std::string strVin = s.second.vin.prevout.ToStringShort();
198  std::string strTxHash = s.second.vin.prevout.hash.ToString();
199  uint32_t oIdx = s.second.vin.prevout.n;
200 
201  CMasternode* mn = mnodeman.Find(s.second.vin);
202 
203  if (mn != NULL) {
204  if (strFilter != "" && strTxHash.find(strFilter) == std::string::npos &&
205  mn->Status().find(strFilter) == std::string::npos &&
206  CBitcoinAddress(mn->pubKeyCollateralAddress.GetID()).ToString().find(strFilter) == std::string::npos) continue;
207 
208  std::string strStatus = mn->Status();
209  std::string strHost;
210  int port;
211  SplitHostPort(mn->addr.ToString(), port, strHost);
212  CNetAddr node;
213  LookupHost(strHost.c_str(), node, false);
214  std::string strNetwork = GetNetworkName(node.GetNetwork());
215 
216  obj.push_back(Pair("rank", (strStatus == "ENABLED" ? s.first : 0)));
217  obj.push_back(Pair("network", strNetwork));
218  obj.push_back(Pair("txhash", strTxHash));
219  obj.push_back(Pair("outidx", (uint64_t)oIdx));
220  obj.push_back(Pair("pubkey", HexStr(mn->pubKeyMasternode)));
221  obj.push_back(Pair("status", strStatus));
222  obj.push_back(Pair("addr", CBitcoinAddress(mn->pubKeyCollateralAddress.GetID()).ToString()));
223  std::string mnStealth(mn->vin.masternodeStealthAddress.begin(), mn->vin.masternodeStealthAddress.end());
224  obj.push_back(Pair("stealthaddress", mnStealth));
225  obj.push_back(Pair("version", mn->protocolVersion));
226  obj.push_back(Pair("lastseen", (int64_t)mn->lastPing.sigTime));
227  obj.push_back(Pair("activetime", (int64_t)(mn->lastPing.sigTime - mn->sigTime)));
228  obj.push_back(Pair("lastpaid", (int64_t)mn->GetLastPaid()));
229 
230  ret.push_back(obj);
231  }
232  }
233 
234  return ret;
235 }
236 
237 UniValue getmasternodecount (const UniValue& params, bool fHelp)
238 {
239  if (fHelp)
240  throw std::runtime_error(
241  "getmasternodecount\n"
242  "\nGet masternode count values\n"
243 
244  "\nResult:\n"
245  "{\n"
246  " \"total\": n, (numeric) Total masternodes\n"
247  " \"stable\": n, (numeric) Stable count\n"
248  " \"enabled\": n, (numeric) Enabled masternodes\n"
249  " \"inqueue\": n (numeric) Masternodes in queue\n"
250  "}\n"
251  "\nExamples:\n" +
252  HelpExampleCli("getmasternodecount", "") + HelpExampleRpc("getmasternodecount", ""));
253 
254  UniValue obj(UniValue::VOBJ);
255  int nCount = 0;
256  int ipv4 = 0, ipv6 = 0, onion = 0;
257 
258  if (chainActive.Tip())
259  mnodeman.GetNextMasternodeInQueueForPayment(chainActive.Tip()->nHeight, true, nCount);
260 
261  mnodeman.CountNetworks(ActiveProtocol(), ipv4, ipv6, onion);
262 
263  obj.push_back(Pair("total", mnodeman.size()));
264  obj.push_back(Pair("stable", mnodeman.stable_size()));
265  obj.push_back(Pair("enabled", mnodeman.CountEnabled()));
266  obj.push_back(Pair("inqueue", nCount));
267  obj.push_back(Pair("ipv4", ipv4));
268  obj.push_back(Pair("ipv6", ipv6));
269  obj.push_back(Pair("onion", onion));
270 
271  return obj;
272 }
273 
274 UniValue masternodecurrent (const UniValue& params, bool fHelp)
275 {
276  if (fHelp || (params.size() != 0))
277  throw std::runtime_error(
278  "masternodecurrent\n"
279  "\nGet current masternode winner (scheduled to be paid next).\n"
280 
281  "\nResult:\n"
282  "{\n"
283  " \"protocol\": xxxx, (numeric) Protocol version\n"
284  " \"txhash\": \"xxxx\", (string) Collateral transaction hash\n"
285  " \"pubkey\": \"xxxx\", (string) MN Public key\n"
286  " \"lastseen\": xxx, (numeric) Time since epoch of last seen\n"
287  " \"activeseconds\": xxx, (numeric) Seconds MN has been active\n"
288  "}\n"
289  "\nExamples:\n" +
290  HelpExampleCli("masternodecurrent", "") + HelpExampleRpc("masternodecurrent", ""));
291 
292  const int nHeight = WITH_LOCK(cs_main, return chainActive.Height() + 1);
293  int nCount = 0;
294  CMasternode* winner = mnodeman.GetNextMasternodeInQueueForPayment(nHeight, true, nCount);
295  if (winner) {
296  UniValue obj(UniValue::VOBJ);
297  obj.push_back(Pair("protocol", (int64_t)winner->protocolVersion));
298  obj.push_back(Pair("txhash", winner->vin.prevout.hash.ToString()));
299  obj.push_back(Pair("pubkey", CBitcoinAddress(winner->pubKeyCollateralAddress.GetID()).ToString()));
300  obj.push_back(Pair("lastseen", (winner->lastPing == CMasternodePing()) ? winner->sigTime : (int64_t)winner->lastPing.sigTime));
301  obj.push_back(Pair("activeseconds", (winner->lastPing == CMasternodePing()) ? 0 : (int64_t)(winner->lastPing.sigTime - winner->sigTime)));
302  return obj;
303  }
304 
305  throw std::runtime_error("unknown");
306 }
307 
308 bool StartMasternodeEntry(UniValue& statusObjRet, CMasternodeBroadcast& mnbRet, bool& fSuccessRet, const CMasternodeConfig::CMasternodeEntry& mne, std::string& errorMessage, std::string strCommand = "")
309 {
310  int nIndex;
311  if(!mne.castOutputIndex(nIndex)) {
312  return false;
313  }
314 
315  CTxIn vin = CTxIn(uint256(mne.getTxHash()), uint32_t(nIndex));
316  CMasternode* pmn = mnodeman.Find(vin);
317  if (pmn != NULL) {
318  if (strCommand == "missing") return false;
319  if (strCommand == "disabled" && pmn->IsEnabled()) return false;
320  }
321 
322  fSuccessRet = CMasternodeBroadcast::Create(mne.getIp(), mne.getPrivKey(), mne.getTxHash(), mne.getOutputIndex(), errorMessage, mnbRet);
323 
324  statusObjRet.push_back(Pair("alias", mne.getAlias()));
325  statusObjRet.push_back(Pair("result", fSuccessRet ? "success" : "failed"));
326  statusObjRet.push_back(Pair("error", fSuccessRet ? "" : errorMessage));
327 
328  return true;
329 }
330 
331 void RelayMNB(CMasternodeBroadcast& mnb, const bool fSuccess, int& successful, int& failed)
332 {
333  if (fSuccess) {
334  successful++;
335  mnodeman.UpdateMasternodeList(mnb);
336  mnb.Relay();
337  } else {
338  failed++;
339  }
340 }
341 
342 void RelayMNB(CMasternodeBroadcast& mnb, const bool fSucces)
343 {
344  int successful = 0, failed = 0;
345  return RelayMNB(mnb, fSucces, successful, failed);
346 }
347 
348 void SerializeMNB(UniValue& statusObjRet, const CMasternodeBroadcast& mnb, const bool fSuccess, int& successful, int& failed)
349 {
350  if(fSuccess) {
351  successful++;
352  CDataStream ssMnb(SER_NETWORK, PROTOCOL_VERSION);
353  ssMnb << mnb;
354  statusObjRet.push_back(Pair("hex", HexStr(ssMnb.begin(), ssMnb.end())));
355  } else {
356  failed++;
357  }
358 }
359 
360 void SerializeMNB(UniValue& statusObjRet, const CMasternodeBroadcast& mnb, const bool fSuccess)
361 {
362  int successful = 0, failed = 0;
363  return SerializeMNB(statusObjRet, mnb, fSuccess, successful, failed);
364 }
365 
366 UniValue startmasternode (const UniValue& params, bool fHelp)
367 {
368  std::string strCommand;
369  if (params.size() >= 1) {
370  strCommand = params[0].get_str();
371 
372  // Backwards compatibility with legacy 'masternode' super-command forwarder
373  if (strCommand == "start") strCommand = "local";
374  if (strCommand == "start-alias") strCommand = "alias";
375  if (strCommand == "start-all") strCommand = "all";
376  if (strCommand == "start-many") strCommand = "many";
377  if (strCommand == "start-missing") strCommand = "missing";
378  if (strCommand == "start-disabled") strCommand = "disabled";
379  }
380 
381  if (fHelp || params.size() < 2 || params.size() > 3 ||
382  (params.size() == 2 && (strCommand != "local" && strCommand != "all" && strCommand != "many" && strCommand != "missing" && strCommand != "disabled")) ||
383  (params.size() == 3 && strCommand != "alias"))
384  throw std::runtime_error(
385  "startmasternode \"local|all|many|missing|disabled|alias\" lockwallet ( \"alias\" )\n"
386  "\nAttempts to start one or more masternode(s)\n"
387 
388  "\nArguments:\n"
389  "1. set (string, required) Specify which set of masternode(s) to start.\n"
390  "2. lockwallet (boolean, required) Lock wallet after completion.\n"
391  "3. alias (string) Masternode alias. Required if using 'alias' as the set.\n"
392 
393  "\nResult: (for 'local' set):\n"
394  "\"status\" (string) Masternode status message\n"
395 
396  "\nResult: (for other sets):\n"
397  "{\n"
398  " \"overall\": \"xxxx\", (string) Overall status message\n"
399  " \"detail\": [\n"
400  " {\n"
401  " \"node\": \"xxxx\", (string) Node name or alias\n"
402  " \"result\": \"xxxx\", (string) 'success' or 'failed'\n"
403  " \"error\": \"xxxx\" (string) Error message, if failed\n"
404  " }\n"
405  " ,...\n"
406  " ]\n"
407  "}\n"
408 
409  "\nExamples:\n" +
410  HelpExampleCli("startmasternode", "\"alias\" \"0\" \"my_mn\"") + HelpExampleRpc("startmasternode", "\"alias\" \"0\" \"my_mn\""));
411 
412  bool fLock = (params[1].get_str() == "true" ? true : false);
413 
414  EnsureWalletIsUnlocked();
415 
416  if (strCommand == "local") {
417  if (!fMasterNode) throw std::runtime_error("you must set masternode=1 in the configuration\n");
418 
419  if (activeMasternode.GetStatus() != ACTIVE_MASTERNODE_STARTED) {
420  activeMasternode.ResetStatus();
421  if (fLock)
422  pwalletMain->Lock();
423  }
424 
425  return activeMasternode.GetStatusMessage();
426  }
427 
428  if (strCommand == "all" || strCommand == "many" || strCommand == "missing" || strCommand == "disabled") {
429  if ((strCommand == "missing" || strCommand == "disabled") &&
430  (masternodeSync.RequestedMasternodeAssets <= MASTERNODE_SYNC_LIST ||
431  masternodeSync.RequestedMasternodeAssets == MASTERNODE_SYNC_FAILED)) {
432  throw std::runtime_error("You can't use this command until masternode list is synced\n");
433  }
434 
435  std::vector<CMasternodeConfig::CMasternodeEntry> mnEntries;
436  mnEntries = masternodeConfig.getEntries();
437 
438  int successful = 0;
439  int failed = 0;
440 
441  UniValue resultsObj(UniValue::VARR);
442 
443  for (CMasternodeConfig::CMasternodeEntry mne : masternodeConfig.getEntries()) {
444  UniValue statusObj(UniValue::VOBJ);
445  CMasternodeBroadcast mnb;
446  std::string errorMessage;
447  bool fSuccess = false;
448  if (!StartMasternodeEntry(statusObj, mnb, fSuccess, mne, errorMessage, strCommand))
449  continue;
450  resultsObj.push_back(statusObj);
451  RelayMNB(mnb, fSuccess, successful, failed);
452  }
453  if (fLock)
454  pwalletMain->Lock();
455 
456  UniValue returnObj(UniValue::VOBJ);
457  returnObj.push_back(Pair("overall", strprintf("Successfully started %d masternodes, failed to start %d, total %d", successful, failed, successful + failed)));
458  returnObj.push_back(Pair("detail", resultsObj));
459 
460  return returnObj;
461  }
462 
463  if (strCommand == "alias") {
464  std::string alias = params[2].get_str();
465 
466  bool found = false;
467 
468  UniValue resultsObj(UniValue::VARR);
469  UniValue statusObj(UniValue::VOBJ);
470 
471  for (CMasternodeConfig::CMasternodeEntry mne : masternodeConfig.getEntries()) {
472  if (mne.getAlias() == alias) {
473  CMasternodeBroadcast mnb;
474  found = true;
475  std::string errorMessage;
476  bool fSuccess = false;
477  if (!StartMasternodeEntry(statusObj, mnb, fSuccess, mne, errorMessage, strCommand))
478  continue;
479  RelayMNB(mnb, fSuccess);
480  break;
481  }
482  }
483 
484  if (fLock)
485  pwalletMain->Lock();
486 
487  if(!found) {
488  statusObj.push_back(Pair("success", false));
489  statusObj.push_back(Pair("error_message", "Could not find alias in config. Verify with list-conf."));
490  }
491 
492  return statusObj;
493  }
494  return NullUniValue;
495 }
496 
497 UniValue createmasternode(const UniValue& params, bool fHelp)
498 {
499  if (fHelp || (params.size() != 0))
500  throw std::runtime_error(
501  "createmasternode\n"
502  "\nCreate a new masternode collteral transaction, genkey, and locks the output\n"
503 
504  "\nResult:\n"
505  "\"txhash\" (string) output transaction hash\n"
506  "\"outputidx\" (numeric) output index numberh\n"
507  "\"genkey\" (string) Masternode private key\n"
508  "\nExamples:\n" +
509  HelpExampleCli("createmasternode", "") + HelpExampleRpc("createmasternode", ""));
510 
511  EnsureWalletIsUnlocked();
512 
513  // Stealth Address
514  std::string myAddress;
515  pwalletMain->ComputeStealthPublicAddress("masteraccount", myAddress);
516 
517  // Amount
518  CAmount nAmount = AmountFromValue(5000);
519 
520  // Wallet comments
521  CWalletTx wtx;
522 
523  if (!pwalletMain->SendToStealthAddress(myAddress, nAmount, wtx)) {
524  throw JSONRPCError(RPC_WALLET_ERROR,
525  "Cannot create Masternode colltaeral transaction.");
526  }
527 
528  CKey secret;
529  secret.MakeNewKey(false);
530 
531  UniValue ret(UniValue::VARR);
532  int indexOut = -1;
533  for (int i=0; i < (int)wtx.vout.size(); i++) {
534  UniValue obj(UniValue::VOBJ);
535  CTxOut& out = wtx.vout[i];
536  CAmount value = pwalletMain->getCTxOutValue(wtx, out);
537  if (value == Params().MNCollateralAmt()) {
538  indexOut = i;
539 
540  // Lock collateral output
541  COutPoint collateralOut(wtx.GetHash(), indexOut);
542  pwalletMain->LockCoin(collateralOut);
543  LogPrintf("Masternode transaction: %s:%i has been locked\n", wtx.GetHash().GetHex().c_str(), indexOut);
544 
545  obj.push_back(Pair("txhash", wtx.GetHash().GetHex().c_str()));
546  obj.push_back(Pair("outputidx", indexOut));
547  obj.push_back(Pair("genkey", CBitcoinSecret(secret).ToString()));
548  ret.push_back(obj);
549  }
550  }
551 
552  return ret;
553 }
554 
555 UniValue createmasternodekey (const UniValue& params, bool fHelp)
556 {
557  if (fHelp || (params.size() != 0))
558  throw std::runtime_error(
559  "createmasternodekey\n"
560  "\nCreate a new masternode private key\n"
561 
562  "\nResult:\n"
563  "\"key\" (string) Masternode private key\n"
564  "\nExamples:\n" +
565  HelpExampleCli("createmasternodekey", "") + HelpExampleRpc("createmasternodekey", ""));
566 
567  CKey secret;
568  secret.MakeNewKey(false);
569 
570  return CBitcoinSecret(secret).ToString();
571 }
572 
573 UniValue getmasternodeoutputs (const UniValue& params, bool fHelp)
574 {
575  if (fHelp || (params.size() != 0))
576  throw std::runtime_error(
577  "getmasternodeoutputs\n"
578  "\nPrint all masternode transaction outputs\n"
579 
580  "\nResult:\n"
581  "[\n"
582  " {\n"
583  " \"txhash\": \"xxxx\", (string) output transaction hash\n"
584  " \"outputidx\": n (numeric) output index number\n"
585  " }\n"
586  " ,...\n"
587  "]\n"
588 
589  "\nExamples:\n" +
590  HelpExampleCli("getmasternodeoutputs", "") + HelpExampleRpc("getmasternodeoutputs", ""));
591 
592  // Find possible candidates
593  std::vector<COutput> possibleCoins;
594  pwalletMain->AvailableCoins(possibleCoins, false, nullptr, false, ONLY_5000);
595 
596  UniValue ret(UniValue::VARR);
597  for (COutput& out : possibleCoins) {
598  UniValue obj(UniValue::VOBJ);
599  obj.push_back(Pair("txhash", out.tx->GetHash().ToString()));
600  obj.push_back(Pair("outputidx", out.i));
601  ret.push_back(obj);
602  }
603 
604  return ret;
605 }
606 
607 UniValue listmasternodeconf (const UniValue& params, bool fHelp)
608 {
609  std::string strFilter = "";
610 
611  if (params.size() == 1) strFilter = params[0].get_str();
612 
613  if (fHelp || (params.size() > 1))
614  throw std::runtime_error(
615  "listmasternodeconf ( \"filter\" )\n"
616  "\nPrint masternode.conf in JSON format\n"
617 
618  "\nArguments:\n"
619  "1. \"filter\" (string, optional) Filter search text. Partial match on alias, address, txHash, or status.\n"
620 
621  "\nResult:\n"
622  "[\n"
623  " {\n"
624  " \"alias\": \"xxxx\", (string) masternode alias\n"
625  " \"address\": \"xxxx\", (string) masternode IP address\n"
626  " \"privateKey\": \"xxxx\", (string) masternode private key\n"
627  " \"txHash\": \"xxxx\", (string) transaction hash\n"
628  " \"outputIndex\": n, (numeric) transaction output index\n"
629  " \"status\": \"xxxx\" (string) masternode status\n"
630  " }\n"
631  " ,...\n"
632  "]\n"
633 
634  "\nExamples:\n" +
635  HelpExampleCli("listmasternodeconf", "") + HelpExampleRpc("listmasternodeconf", ""));
636 
637  std::vector<CMasternodeConfig::CMasternodeEntry> mnEntries;
638  mnEntries = masternodeConfig.getEntries();
639 
640  UniValue ret(UniValue::VARR);
641 
642  for (CMasternodeConfig::CMasternodeEntry mne : masternodeConfig.getEntries()) {
643  int nIndex;
644  if(!mne.castOutputIndex(nIndex))
645  continue;
646  CTxIn vin = CTxIn(uint256S(mne.getTxHash()), uint32_t(nIndex));
647  CMasternode* pmn = mnodeman.Find(vin);
648 
649  std::string strStatus = pmn ? pmn->Status() : "MISSING";
650 
651  if (strFilter != "" && mne.getAlias().find(strFilter) == std::string::npos &&
652  mne.getIp().find(strFilter) == std::string::npos &&
653  mne.getTxHash().find(strFilter) == std::string::npos &&
654  strStatus.find(strFilter) == std::string::npos) continue;
655 
656  UniValue mnObj(UniValue::VOBJ);
657  mnObj.push_back(Pair("alias", mne.getAlias()));
658  mnObj.push_back(Pair("address", mne.getIp()));
659  mnObj.push_back(Pair("privateKey", mne.getPrivKey()));
660  mnObj.push_back(Pair("txHash", mne.getTxHash()));
661  mnObj.push_back(Pair("outputIndex", mne.getOutputIndex()));
662  mnObj.push_back(Pair("status", strStatus));
663  ret.push_back(mnObj);
664  }
665 
666  return ret;
667 }
668 
669 UniValue getmasternodestatus (const UniValue& params, bool fHelp)
670 {
671  if (fHelp || (params.size() != 0))
672  throw std::runtime_error(
673  "getmasternodestatus\n"
674  "\nPrint masternode status\n"
675 
676  "\nResult:\n"
677  "{\n"
678  " \"txhash\": \"xxxx\", (string) Collateral transaction hash\n"
679  " \"outputidx\": n, (numeric) Collateral transaction output index number\n"
680  " \"netaddr\": \"xxxx\", (string) Masternode network address\n"
681  " \"addr\": \"xxxx\", (string) PRCY address for masternode payments\n"
682  " \"status\": \"xxxx\", (string) Masternode status\n"
683  " \"message\": \"xxxx\" (string) Masternode status message\n"
684  "}\n"
685 
686  "\nExamples:\n" +
687  HelpExampleCli("getmasternodestatus", "") + HelpExampleRpc("getmasternodestatus", ""));
688 
689  if (!fMasterNode) throw std::runtime_error("This is not a masternode");
690 
691  std::cout << "Vin Script Sig:" << activeMasternode.vin.scriptSig.ToString() << std::endl;
692  std::cout << "Vin Tx hash:" << activeMasternode.vin.prevout.hash.GetHex() << std::endl;
693  CMasternode* pmn = mnodeman.Find(activeMasternode.vin);
694 
695  if (pmn) {
696  UniValue mnObj(UniValue::VOBJ);
697  mnObj.push_back(Pair("txhash", activeMasternode.vin.prevout.hash.ToString()));
698  mnObj.push_back(Pair("outputidx", (uint64_t)activeMasternode.vin.prevout.n));
699  mnObj.push_back(Pair("netaddr", activeMasternode.service.ToString()));
700  mnObj.push_back(Pair("addr", CBitcoinAddress(pmn->pubKeyCollateralAddress.GetID()).ToString()));
701  mnObj.push_back(Pair("status", activeMasternode.GetStatus()));
702  mnObj.push_back(Pair("message", activeMasternode.GetStatusMessage()));
703  return mnObj;
704  }
705  throw std::runtime_error("Masternode not found in the list of available masternodes. Current status: "
706  + activeMasternode.GetStatusMessage());
707 }
708 
709 UniValue getmasternodewinners (const UniValue& params, bool fHelp)
710 {
711  if (fHelp || params.size() > 3)
712  throw std::runtime_error(
713  "getmasternodewinners ( blocks \"filter\" )\n"
714  "\nPrint the masternode winners for the last n blocks\n"
715 
716  "\nArguments:\n"
717  "1. blocks (numeric, optional) Number of previous blocks to show (default: 10)\n"
718  "2. filter (string, optional) Search filter matching MN address\n"
719 
720  "\nResult (single winner):\n"
721  "[\n"
722  " {\n"
723  " \"nHeight\": n, (numeric) block height\n"
724  " \"winner\": {\n"
725  " \"address\": \"xxxx\", (string) PRCY MN Address\n"
726  " \"nVotes\": n, (numeric) Number of votes for winner\n"
727  " }\n"
728  " }\n"
729  " ,...\n"
730  "]\n"
731 
732  "\nResult (multiple winners):\n"
733  "[\n"
734  " {\n"
735  " \"nHeight\": n, (numeric) block height\n"
736  " \"winner\": [\n"
737  " {\n"
738  " \"address\": \"xxxx\", (string) PRCY MN Address\n"
739  " \"nVotes\": n, (numeric) Number of votes for winner\n"
740  " }\n"
741  " ,...\n"
742  " ]\n"
743  " }\n"
744  " ,...\n"
745  "]\n"
746  "\nExamples:\n" +
747  HelpExampleCli("getmasternodewinners", "") + HelpExampleRpc("getmasternodewinners", ""));
748 
749  int nHeight;
750  {
751  LOCK(cs_main);
752  CBlockIndex* pindex = chainActive.Tip();
753  if(!pindex) return 0;
754  nHeight = pindex->nHeight;
755  }
756 
757  int nLast = 10;
758  std::string strFilter = "";
759 
760  if (params.size() >= 1)
761  nLast = atoi(params[0].get_str());
762 
763  if (params.size() == 2)
764  strFilter = params[1].get_str();
765 
766  UniValue ret(UniValue::VARR);
767 
768  for (int i = nHeight - nLast; i < nHeight + 20; i++) {
769  UniValue obj(UniValue::VOBJ);
770  obj.push_back(Pair("nHeight", i));
771 
772  std::string strPayment = GetRequiredPaymentsString(i);
773  if (strFilter != "" && strPayment.find(strFilter) == std::string::npos) continue;
774 
775  if (strPayment.find(',') != std::string::npos) {
776  UniValue winner(UniValue::VARR);
777  boost::char_separator<char> sep(",");
778  boost::tokenizer< boost::char_separator<char> > tokens(strPayment, sep);
779  for (const std::string& t : tokens) {
780  UniValue addr(UniValue::VOBJ);
781  std::size_t pos = t.find(":");
782  std::string strAddress = t.substr(0,pos);
783  uint64_t nVotes = atoi(t.substr(pos+1));
784  addr.push_back(Pair("address", strAddress));
785  addr.push_back(Pair("nVotes", nVotes));
786  winner.push_back(addr);
787  }
788  obj.push_back(Pair("winner", winner));
789  } else if (strPayment.find("Unknown") == std::string::npos) {
790  UniValue winner(UniValue::VOBJ);
791  std::size_t pos = strPayment.find(":");
792  std::string strAddress = strPayment.substr(0,pos);
793  uint64_t nVotes = atoi(strPayment.substr(pos+1));
794  winner.push_back(Pair("address", strAddress));
795  winner.push_back(Pair("nVotes", nVotes));
796  obj.push_back(Pair("winner", winner));
797  } else {
798  UniValue winner(UniValue::VOBJ);
799  winner.push_back(Pair("address", strPayment));
800  winner.push_back(Pair("nVotes", 0));
801  obj.push_back(Pair("winner", winner));
802  }
803 
804  ret.push_back(obj);
805  }
806 
807  return ret;
808 }
809 
810 UniValue getmasternodescores (const UniValue& params, bool fHelp)
811 {
812  if (fHelp || params.size() > 1)
813  throw std::runtime_error(
814  "getmasternodescores ( blocks )\n"
815  "\nPrint list of winning masternode by score\n"
816 
817  "\nArguments:\n"
818  "1. blocks (numeric, optional) Show the last n blocks (default 10)\n"
819 
820  "\nResult:\n"
821  "{\n"
822  " xxxx: \"xxxx\" (numeric : string) Block height : Masternode hash\n"
823  " ,...\n"
824  "}\n"
825  "\nExamples:\n" +
826  HelpExampleCli("getmasternodescores", "") + HelpExampleRpc("getmasternodescores", ""));
827 
828  int nLast = 10;
829 
830  if (params.size() == 1) {
831  try {
832  nLast = std::stoi(params[0].get_str());
833  } catch (const std::invalid_argument&) {
834  throw std::runtime_error("Exception on param 2");
835  }
836  }
837  UniValue obj(UniValue::VOBJ);
838 
839  std::vector<CMasternode> vMasternodes = mnodeman.GetFullMasternodeVector();
840  for (int nHeight = chainActive.Tip()->nHeight - nLast; nHeight < chainActive.Tip()->nHeight + 20; nHeight++) {
841  uint256 nHigh;
842  CMasternode* pBestMasternode = NULL;
843  for (CMasternode& mn : vMasternodes) {
844  uint256 n = mn.CalculateScore(1, nHeight - 100);
845  if (n > nHigh) {
846  nHigh = n;
847  pBestMasternode = &mn;
848  }
849  }
850  if (pBestMasternode)
851  obj.push_back(Pair(strprintf("%d", nHeight), pBestMasternode->vin.prevout.hash.ToString().c_str()));
852  }
853 
854  return obj;
855 }
856 
857 UniValue getcurrentseesawreward (const UniValue& params, bool fHelp)
858 {
859  if (fHelp)
860  throw std::runtime_error(
861  "getcurrentseesawratio\n"
862  "\nPrint Current See Saw Reward Ratio\n"
863 
864  "\nNo Arguments needed\n"
865 
866  "\nResult:\n"
867  "{\n"
868  " SeeSaw reward ratio: Masternode-Staking node : xx-xx\n"
869  " ,...\n"
870  "}\n"
871  "\nExamples:\n" +
872  HelpExampleCli("getcurrentseesawratio", "") + HelpExampleRpc("getcurrentseesawratio", ""));
873 
874  UniValue obj(UniValue::VOBJ);
875  int ipv4 = 0, ipv6 = 0, onion = 0;
876  mnodeman.CountNetworks(ActiveProtocol(), ipv4, ipv6, onion);
877  int nblockHeight = chainActive.Tip()->nHeight;
878  CAmount nReward = GetBlockValue(nblockHeight);
879 
880  CAmount masternodeReward = GetSeeSaw(nReward, 0, nblockHeight);
881  CAmount stakingnodeReward = nReward - masternodeReward;
882  obj.push_back(Pair("Masternode Reward", ValueFromAmount(masternodeReward)));
883  obj.push_back(Pair("Staking Reward", ValueFromAmount(stakingnodeReward)));
884  obj.push_back(Pair("Total Reward", ValueFromAmount(nReward)));
885  return obj;
886 }
887 
888 UniValue getseesawrewardwithheight (const UniValue& params, bool fHelp)
889 {
890  if (fHelp || params.size() > 1)
891  throw std::runtime_error(
892  "getseesawrewardwithheight\n"
893  "\nPrint See Saw Reward With Specific block height\n"
894 
895  "\nArguments:\n"
896  "1. Height of block\n"
897  "\nResult:\n"
898  "{\n"
899  " SeeSaw reward: Masternode-Staking node : xx-xx\n"
900  " ,...\n"
901  "}\n"
902  "\nExamples:\n" +
903  HelpExampleCli("getseesawrewardwithheight", "") + HelpExampleRpc("getseesawrewardwithheight", ""));
904 
905  int nblockHeight = chainActive.Tip()->nHeight;;
906  if (params.size() == 1) {
907  nblockHeight = params[0].get_int();
908  }
909 
910  UniValue obj(UniValue::VOBJ);
911  int ipv4 = 0, ipv6 = 0, onion = 0;
912  mnodeman.CountNetworks(ActiveProtocol(), ipv4, ipv6, onion);
913  CAmount nReward = GetBlockValue(nblockHeight);
914 
915  CAmount masternodeReward = GetSeeSaw(nReward, 0, nblockHeight);
916  CAmount stakingnodeReward = nReward - masternodeReward;
917  obj.push_back(Pair("Block Height", nblockHeight));
918  obj.push_back(Pair("Masternode Reward", ValueFromAmount(masternodeReward)));
919  obj.push_back(Pair("Staking Reward", ValueFromAmount(stakingnodeReward)));
920  obj.push_back(Pair("Total Reward", ValueFromAmount(nReward)));
921  return obj;
922 }
923 
924 UniValue getseesawrewardratio (const UniValue& params, bool fHelp)
925 {
926  if (fHelp)
927  throw std::runtime_error(
928  "getseesawrewardratio\n"
929  "\nPrint See Saw Reward Ratio\n"
930 
931  "\nNo Arguments:\n"
932  "\nResult:\n"
933  "{\n"
934  " SeeSaw reward Ratio: Masternode-Staking node : xx-xx\n"
935  " ,...\n"
936  "}\n"
937  "\nExamples:\n" +
938  HelpExampleCli("getseesawrewardratio", "") + HelpExampleRpc("getseesawrewardratio", ""));
939 
940  int nblockHeight = chainActive.Tip()->nHeight;;
941 
942  UniValue obj(UniValue::VOBJ);
943  int ipv4 = 0, ipv6 = 0, onion = 0;
944  mnodeman.CountNetworks(ActiveProtocol(), ipv4, ipv6, onion);
945  CAmount nReward = GetBlockValue(nblockHeight);
946 
947  CAmount masternodeReward = GetSeeSaw(nReward, 0, nblockHeight);
948  int masternodeRatio = (masternodeReward * 100)/nReward;
949  obj.push_back(Pair("Masternode Reward Ratio", masternodeRatio));
950  obj.push_back(Pair("Staking Reward Ratio", 100 - masternodeRatio));
951  return obj;
952 }
953 
954 bool DecodeHexMnb(CMasternodeBroadcast& mnb, std::string strHexMnb) {
955 
956  if (!IsHex(strHexMnb))
957  return false;
958 
959  std::vector<unsigned char> mnbData(ParseHex(strHexMnb));
960  CDataStream ssData(mnbData, SER_NETWORK, PROTOCOL_VERSION);
961  try {
962  ssData >> mnb;
963  }
964  catch (const std::exception&) {
965  return false;
966  }
967 
968  return true;
969 }
970 
971 UniValue createmasternodebroadcast(const UniValue& params, bool fHelp)
972 {
973  std::string strCommand;
974  if (params.size() >= 1)
975  strCommand = params[0].get_str();
976  if (fHelp || (strCommand != "alias" && strCommand != "all") || (strCommand == "alias" && params.size() < 2))
977  throw std::runtime_error(
978  "createmasternodebroadcast \"command\" ( \"alias\")\n"
979  "\nCreates a masternode broadcast message for one or all masternodes configured in masternode.conf\n" +
980  HelpRequiringPassphrase() + "\n"
981 
982  "\nArguments:\n"
983  "1. \"command\" (string, required) \"alias\" for single masternode, \"all\" for all masternodes\n"
984  "2. \"alias\" (string, required if command is \"alias\") Alias of the masternode\n"
985 
986  "\nResult (all):\n"
987  "{\n"
988  " \"overall\": \"xxx\", (string) Overall status message indicating number of successes.\n"
989  " \"detail\": [ (array) JSON array of broadcast objects.\n"
990  " {\n"
991  " \"alias\": \"xxx\", (string) Alias of the masternode.\n"
992  " \"success\": true|false, (boolean) Success status.\n"
993  " \"hex\": \"xxx\" (string, if success=true) Hex encoded broadcast message.\n"
994  " \"error_message\": \"xxx\" (string, if success=false) Error message, if any.\n"
995  " }\n"
996  " ,...\n"
997  " ]\n"
998  "}\n"
999 
1000  "\nResult (alias):\n"
1001  "{\n"
1002  " \"alias\": \"xxx\", (string) Alias of the masternode.\n"
1003  " \"success\": true|false, (boolean) Success status.\n"
1004  " \"hex\": \"xxx\" (string, if success=true) Hex encoded broadcast message.\n"
1005  " \"error_message\": \"xxx\" (string, if success=false) Error message, if any.\n"
1006  "}\n"
1007 
1008  "\nExamples:\n" +
1009  HelpExampleCli("createmasternodebroadcast", "alias mymn1") + HelpExampleRpc("createmasternodebroadcast", "alias mymn1"));
1010 
1011  EnsureWalletIsUnlocked();
1012 
1013  if (strCommand == "alias")
1014  {
1015  // wait for reindex and/or import to finish
1016  if (fImporting || fReindex)
1017  throw JSONRPCError(RPC_INTERNAL_ERROR, "Wait for reindex and/or import to finish");
1018 
1019  std::string alias = params[1].get_str();
1020  bool found = false;
1021 
1022  UniValue statusObj(UniValue::VOBJ);
1023  statusObj.push_back(Pair("alias", alias));
1024 
1025  for (CMasternodeConfig::CMasternodeEntry mne : masternodeConfig.getEntries()) {
1026  if(mne.getAlias() == alias) {
1027  CMasternodeBroadcast mnb;
1028  found = true;
1029  std::string errorMessage;
1030  bool fSuccess = false;
1031  if (!StartMasternodeEntry(statusObj, mnb, fSuccess, mne, errorMessage, strCommand))
1032  continue;
1033  SerializeMNB(statusObj, mnb, fSuccess);
1034  break;
1035  }
1036  }
1037 
1038  if(!found) {
1039  statusObj.push_back(Pair("success", false));
1040  statusObj.push_back(Pair("error_message", "Could not find alias in config. Verify with list-conf."));
1041  }
1042 
1043  return statusObj;
1044  }
1045 
1046  if (strCommand == "all")
1047  {
1048  // wait for reindex and/or import to finish
1049  if (fImporting || fReindex)
1050  throw JSONRPCError(RPC_INTERNAL_ERROR, "Wait for reindex and/or import to finish");
1051 
1052  std::vector<CMasternodeConfig::CMasternodeEntry> mnEntries;
1053  mnEntries = masternodeConfig.getEntries();
1054 
1055  int successful = 0;
1056  int failed = 0;
1057 
1058  UniValue resultsObj(UniValue::VARR);
1059 
1060  for (CMasternodeConfig::CMasternodeEntry mne : masternodeConfig.getEntries()) {
1061  UniValue statusObj(UniValue::VOBJ);
1062  CMasternodeBroadcast mnb;
1063  std::string errorMessage;
1064  bool fSuccess = false;
1065  if (!StartMasternodeEntry(statusObj, mnb, fSuccess, mne, errorMessage, strCommand))
1066  continue;
1067  SerializeMNB(statusObj, mnb, fSuccess, successful, failed);
1068  resultsObj.push_back(statusObj);
1069  }
1070 
1071  UniValue returnObj(UniValue::VOBJ);
1072  returnObj.push_back(Pair("overall", strprintf("Successfully created broadcast messages for %d masternodes, failed to create %d, total %d", successful, failed, successful + failed)));
1073  returnObj.push_back(Pair("detail", resultsObj));
1074 
1075  return returnObj;
1076  }
1077  return NullUniValue;
1078 }
1079 
1080 UniValue decodemasternodebroadcast(const UniValue & params, bool fHelp)
1081 {
1082  if (fHelp || params.size() != 1)
1083  throw std::runtime_error(
1084  "decodemasternodebroadcast \"hexstring\"\n"
1085  "\nCommand to decode masternode broadcast messages\n"
1086 
1087  "\nArgument:\n"
1088  "1. \"hexstring\" (string) The hex encoded masternode broadcast message\n"
1089 
1090  "\nResult:\n"
1091  "{\n"
1092  " \"vin\": \"xxxx\" (string) The unspent output which is holding the masternode collateral\n"
1093  " \"addr\": \"xxxx\" (string) IP address of the masternode\n"
1094  " \"pubkeycollateral\": \"xxxx\" (string) Collateral address's public key\n"
1095  " \"pubkeymasternode\": \"xxxx\" (string) Masternode's public key\n"
1096  " \"vchsig\": \"xxxx\" (string) Base64-encoded signature of this message (verifiable via pubkeycollateral)\n"
1097  " \"sigtime\": \"nnn\" (numeric) Signature timestamp\n"
1098  " \"protocolversion\": \"nnn\" (numeric) Masternode's protocol version\n"
1099  " \"nlastdsq\": \"nnn\" (numeric) The last time the masternode sent a DSQ message (for mixing) (DEPRECATED)\n"
1100  " \"lastping\" : { (object) JSON object with information about the masternode's last ping\n"
1101  " \"vin\": \"xxxx\" (string) The unspent output of the masternode which is signing the message\n"
1102  " \"blockhash\": \"xxxx\" (string) Current chaintip blockhash minus 12\n"
1103  " \"sigtime\": \"nnn\" (numeric) Signature time for this ping\n"
1104  " \"vchsig\": \"xxxx\" (string) Base64-encoded signature of this ping (verifiable via pubkeymasternode)\n"
1105  "}\n"
1106 
1107  "\nExamples:\n" +
1108  HelpExampleCli("decodemasternodebroadcast", "hexstring") + HelpExampleRpc("decodemasternodebroadcast", "hexstring"));
1109 
1110  CMasternodeBroadcast mnb;
1111 
1112  if (!DecodeHexMnb(mnb, params[0].get_str()))
1113  throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Masternode broadcast message decode failed");
1114 
1115  if(!mnb.VerifySignature())
1116  throw JSONRPCError(RPC_INVALID_PARAMETER, "Masternode broadcast signature verification failed");
1117 
1118  UniValue resultObj(UniValue::VOBJ);
1119 
1120  resultObj.push_back(Pair("vin", mnb.vin.prevout.ToString()));
1121  resultObj.push_back(Pair("addr", mnb.addr.ToString()));
1122  resultObj.push_back(Pair("pubkeycollateral", CBitcoinAddress(mnb.pubKeyCollateralAddress.GetID()).ToString()));
1123  resultObj.push_back(Pair("pubkeymasternode", CBitcoinAddress(mnb.pubKeyMasternode.GetID()).ToString()));
1124  resultObj.push_back(Pair("vchsig", EncodeBase64(&mnb.sig[0], mnb.sig.size())));
1125  resultObj.push_back(Pair("sigtime", mnb.sigTime));
1126  resultObj.push_back(Pair("protocolversion", mnb.protocolVersion));
1127  resultObj.push_back(Pair("nlastdsq", mnb.nLastDsq));
1128 
1129  UniValue lastPingObj(UniValue::VOBJ);
1130  lastPingObj.push_back(Pair("vin", mnb.lastPing.vin.prevout.ToString()));
1131  lastPingObj.push_back(Pair("blockhash", mnb.lastPing.blockHash.ToString()));
1132  lastPingObj.push_back(Pair("sigtime", mnb.lastPing.sigTime));
1133  lastPingObj.push_back(Pair("vchsig", EncodeBase64(&mnb.lastPing.vchSig[0], mnb.lastPing.vchSig.size())));
1134 
1135  resultObj.push_back(Pair("lastping", lastPingObj));
1136 
1137  return resultObj;
1138 }
1139 
1140 UniValue relaymasternodebroadcast(const UniValue & params, bool fHelp)
1141 {
1142  if (fHelp || params.size() != 1)
1143  throw std::runtime_error(
1144  "relaymasternodebroadcast \"hexstring\"\n"
1145  "\nCommand to relay masternode broadcast messages\n"
1146 
1147  "\nArguments:\n"
1148  "1. \"hexstring\" (string) The hex encoded masternode broadcast message\n"
1149 
1150  "\nExamples:\n" +
1151  HelpExampleCli("relaymasternodebroadcast", "hexstring") + HelpExampleRpc("relaymasternodebroadcast", "hexstring"));
1152 
1153 
1154  CMasternodeBroadcast mnb;
1155 
1156  if (!DecodeHexMnb(mnb, params[0].get_str()))
1157  throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Masternode broadcast message decode failed");
1158 
1159  if(!mnb.VerifySignature())
1160  throw JSONRPCError(RPC_INVALID_PARAMETER, "Masternode broadcast signature verification failed");
1161 
1162  mnodeman.UpdateMasternodeList(mnb);
1163  mnb.Relay();
1164 
1165  return strprintf("Masternode broadcast sent (service %s, vin %s)", mnb.addr.ToString(), mnb.vin.ToString());
1166 }
CMasternodeConfig::CMasternodeEntry::getAlias
const std::string & getAlias() const
Definition: masternodeconfig.h:41
CWallet::LockCoin
void LockCoin(COutPoint &output)
Definition: wallet.cpp:5057
StartMasternodeEntry
bool StartMasternodeEntry(UniValue &statusObjRet, CMasternodeBroadcast &mnbRet, bool &fSuccessRet, const CMasternodeConfig::CMasternodeEntry &mne, std::string &errorMessage, std::string strCommand="")
Definition: masternode.cpp:308
CTxIn
An input of a transaction.
Definition: transaction.h:83
CMasternode::nLastDsq
int64_t nLastDsq
Definition: masternode.h:142
fImporting
std::atomic< bool > fImporting
Definition: main.cpp:80
createmasternode
UniValue createmasternode(const UniValue &params, bool fHelp)
Definition: masternode.cpp:497
getmasternodeoutputs
UniValue getmasternodeoutputs(const UniValue &params, bool fHelp)
Definition: masternode.cpp:573
CActiveMasternode::ResetStatus
void ResetStatus()
Definition: activemasternode.cpp:89
UniValue::VOBJ
@ VOBJ
Definition: univalue.h:21
SplitHostPort
void SplitHostPort(std::string in, int &portOut, std::string &hostOut)
Definition: netbase.cpp:74
CMasternodeMan::CountEnabled
int CountEnabled(int protocolVersion=-1)
Definition: masternodeman.cpp:379
CMasternodeMan::UpdateMasternodeList
void UpdateMasternodeList(CMasternodeBroadcast mnb)
Update masternode list and maps using provided CMasternodeBroadcast.
Definition: masternodeman.cpp:819
activeMasternode
CActiveMasternode activeMasternode
Keep track of the active Masternode.
Definition: masternodeman.cpp:24
RPC_INTERNAL_ERROR
@ RPC_INTERNAL_ERROR
Definition: protocol.h:36
masternodecurrent
UniValue masternodecurrent(const UniValue &params, bool fHelp)
Definition: masternode.cpp:274
CMasternodeSync::RequestedMasternodeAssets
int RequestedMasternodeAssets
Definition: masternode-sync.h:57
CKey::MakeNewKey
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
Definition: key.cpp:40
ParseHex
std::vector< unsigned char > ParseHex(const char *psz)
Definition: utilstrencodings.cpp:77
CDataStream::begin
const_iterator begin() const
Definition: streams.h:116
base_uint::GetHex
std::string GetHex() const
Definition: arith_uint256.cpp:155
GetRequiredPaymentsString
std::string GetRequiredPaymentsString(int nBlockHeight)
Definition: masternode-payments.cpp:222
getmasternodewinners
UniValue getmasternodewinners(const UniValue &params, bool fHelp)
Definition: masternode.cpp:709
CMasternodeBroadcast::Create
static bool Create(CTxIn vin, CService service, CKey keyCollateralAddressNew, CPubKey pubKeyCollateralAddressNew, CKey keyMasternodeNew, CPubKey pubKeyMasternodeNew, std::string &strErrorRet, CMasternodeBroadcast &mnbRet)
Create Masternode broadcast, needs to be relayed manually after that.
Definition: masternode.cpp:467
ValueFromAmount
UniValue ValueFromAmount(const CAmount &amount)
Definition: server.cpp:118
chainActive
CChain chainActive
The currently-connected chain of blocks.
Definition: main.cpp:70
COutPoint::hash
uint256 hash
Definition: transaction.h:39
NullUniValue
const UniValue NullUniValue
Definition: univalue.cpp:78
decodemasternodebroadcast
UniValue decodemasternodebroadcast(const UniValue &params, bool fHelp)
Definition: masternode.cpp:1080
CBitcoinAddress
base58-encoded PRCY addresses.
Definition: base58.h:109
CNetAddr
IP address (IPv6, or IPv4 using mapped IPv6 range (::FFFF:0:0/96))
Definition: netaddress.h:30
RPC_INVALID_PARAMETER
@ RPC_INVALID_PARAMETER
Ran out of memory during operation.
Definition: protocol.h:45
CMasternodeMan::Find
CMasternode * Find(const CScript &payee)
Find an entry.
Definition: masternodeman.cpp:440
CActiveMasternode::vin
CTxIn vin
Definition: activemasternode.h:44
CBlockIndex::nHeight
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:181
masternode
UniValue masternode(const UniValue &params, bool fHelp)
Definition: masternode.cpp:24
masternode-sync.h
WITH_LOCK
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:209
CMasternodeMan::size
int size()
Return the number of (unique) Masternodes.
Definition: masternodeman.h:148
CMasternodeBroadcast::Relay
void Relay()
Definition: masternode.cpp:694
CMasternodeMan::GetNextMasternodeInQueueForPayment
CMasternode * GetNextMasternodeInQueueForPayment(int nBlockHeight, bool fFilterSigTime, int &nCount)
Find an entry in the masternode list that is next to be paid.
Definition: masternodeman.cpp:479
CMasternodePing::sigTime
int64_t sigTime
Definition: masternode.h:44
createmasternodebroadcast
UniValue createmasternodebroadcast(const UniValue &params, bool fHelp)
Definition: masternode.cpp:971
CWallet::ComputeStealthPublicAddress
bool ComputeStealthPublicAddress(const std::string &accountName, std::string &pubAddress)
Definition: wallet.cpp:6379
SER_NETWORK
@ SER_NETWORK
Definition: serialize.h:159
masternodeman.h
getmasternodecount
UniValue getmasternodecount(const UniValue &params, bool fHelp)
Definition: masternode.cpp:237
CBase58Data::ToString
std::string ToString() const
Definition: base58.cpp:200
startmasternode
UniValue startmasternode(const UniValue &params, bool fHelp)
Definition: masternode.cpp:366
getmasternodestatus
UniValue getmasternodestatus(const UniValue &params, bool fHelp)
Definition: masternode.cpp:669
CMasternodeMan::stable_size
int stable_size()
Return the number of Masternodes older than (default) 8000 seconds.
Definition: masternodeman.cpp:358
CMasternode::vin
CTxIn vin
Definition: masternode.h:127
fMasterNode
bool fMasterNode
Definition: util.cpp:97
getseesawrewardwithheight
UniValue getseesawrewardwithheight(const UniValue &params, bool fHelp)
Definition: masternode.cpp:888
db.h
CMasternodeMan::GetMasternodeRanks
std::vector< std::pair< int, CMasternode > > GetMasternodeRanks(int64_t nBlockHeight, int minProtocol=0)
Definition: masternodeman.cpp:604
UniValue
Definition: univalue.h:19
CTxIn::masternodeStealthAddress
std::vector< unsigned char > masternodeStealthAddress
Definition: transaction.h:99
GetSeeSaw
CAmount GetSeeSaw(const CAmount &blockValue, int nMasternodeCount, int nHeight)
Definition: main.cpp:2187
CBitcoinSecret
A base58-encoded secret key.
Definition: base58.h:131
atoi
int atoi(const std::string &str)
Definition: utilstrencodings.cpp:587
listmasternodeconf
UniValue listmasternodeconf(const UniValue &params, bool fHelp)
Definition: masternode.cpp:607
HelpRequiringPassphrase
std::string HelpRequiringPassphrase()
Definition: rpcwallet.cpp:32
CMasternode::sigTime
int64_t sigTime
Definition: masternode.h:135
masternodeSync
CMasternodeSync masternodeSync
Definition: masternode-sync.cpp:19
CMasternodeConfig::CMasternodeEntry::getTxHash
const std::string & getTxHash() const
Definition: masternodeconfig.h:73
CMasternodeMan::GetFullMasternodeVector
std::vector< CMasternode > GetFullMasternodeVector()
Definition: masternodeman.h:135
UniValue::get_str
const std::string & get_str() const
Definition: univalue.cpp:309
cs_main
RecursiveMutex cs_main
Global state.
Definition: main.cpp:65
RPC_DESERIALIZATION_ERROR
@ RPC_DESERIALIZATION_ERROR
Database error.
Definition: protocol.h:47
ActiveProtocol
int ActiveProtocol()
See whether the protocol update is enforced for connected nodes.
Definition: main.cpp:6844
CMasternodeConfig::CMasternodeEntry::getPrivKey
const std::string & getPrivKey() const
Definition: masternodeconfig.h:63
RelayMNB
void RelayMNB(CMasternodeBroadcast &mnb, const bool fSuccess, int &successful, int &failed)
Definition: masternode.cpp:331
CNetAddr::GetNetwork
enum Network GetNetwork() const
Definition: netaddress.cpp:229
mnodeman
CMasternodeMan mnodeman
Masternode manager.
Definition: masternodeman.cpp:22
CService::ToString
std::string ToString() const
Definition: netaddress.cpp:568
getmasternodescores
UniValue getmasternodescores(const UniValue &params, bool fHelp)
Definition: masternode.cpp:810
IsHex
bool IsHex(const std::string &str)
Definition: utilstrencodings.cpp:68
CMasternode::Status
std::string Status()
Definition: masternode.h:267
CTxOut
An output of a transaction.
Definition: transaction.h:164
init.h
CTransaction::vout
std::vector< CTxOut > vout
Definition: transaction.h:286
LookupHost
bool LookupHost(const char *pszName, std::vector< CNetAddr > &vIP, unsigned int nMaxSolutions, bool fAllowLookup)
Definition: netbase.cpp:184
univalue.h
relaymasternodebroadcast
UniValue relaymasternodebroadcast(const UniValue &params, bool fHelp)
Definition: masternode.cpp:1140
CDataStream::end
const_iterator end() const
Definition: streams.h:118
CActiveMasternode::GetStatusMessage
std::string GetStatusMessage() const
Definition: activemasternode.cpp:95
HexStr
std::string HexStr(const T itbegin, const T itend, bool fSpaces=false)
Definition: utilstrencodings.h:85
PAIRTYPE
#define PAIRTYPE(t1, t2)
This is needed because the foreach macro can't get over the comma in pair<t1, t2>
Definition: utilstrencodings.h:24
JSONRPCError
UniValue JSONRPCError(int code, const std::string &message)
Definition: protocol.cpp:60
LogPrintf
#define LogPrintf(...)
Definition: logging.h:147
CAmount
int64_t CAmount
Amount in PRCY (Can be negative)
Definition: amount.h:17
RPC_WALLET_ERROR
@ RPC_WALLET_ERROR
Invalid IP/Subnet.
Definition: protocol.h:68
CMasternodePing::blockHash
uint256 blockHash
Definition: masternode.h:43
createmasternodekey
UniValue createmasternodekey(const UniValue &params, bool fHelp)
Definition: masternode.cpp:555
HelpExampleRpc
std::string HelpExampleRpc(std::string methodname, std::string args)
Definition: server.cpp:607
masternode-payments.h
getcurrentseesawreward
UniValue getcurrentseesawreward(const UniValue &params, bool fHelp)
Definition: masternode.cpp:857
uint256
256-bit unsigned big integer.
Definition: uint256.h:38
uint256S
uint256 uint256S(const char *str)
Definition: uint256.h:99
AmountFromValue
CAmount AmountFromValue(const UniValue &value)
Definition: server.cpp:107
listmasternodes
UniValue listmasternodes(const UniValue &params, bool fHelp)
Definition: masternode.cpp:153
MASTERNODE_SYNC_FAILED
#define MASTERNODE_SYNC_FAILED
Definition: masternode-sync.h:16
CWallet::SendToStealthAddress
bool SendToStealthAddress(const std::string &stealthAddr, CAmount nValue, CWalletTx &wtxNew, bool fUseIX=false, int ringSize=5)
Definition: wallet.cpp:6640
ONLY_5000
@ ONLY_5000
Definition: wallet.h:111
CMasternode::pubKeyMasternode
CPubKey pubKeyMasternode
Definition: masternode.h:130
EncodeBase64
std::string EncodeBase64(const unsigned char *pch, size_t len)
Definition: utilstrencodings.cpp:102
CChain::Height
int Height() const
Return the maximal height in the chain.
Definition: chain.h:641
CWallet::Lock
bool Lock()
Lock Wallet.
Definition: wallet.cpp:582
activemasternode.h
CMasternode::addr
CService addr
Definition: masternode.h:128
HelpExampleCli
std::string HelpExampleCli(std::string methodname, std::string args)
Definition: server.cpp:603
masternodeConfig
CMasternodeConfig masternodeConfig
Definition: masternodeconfig.cpp:13
CMasternodeConfig::CMasternodeEntry::castOutputIndex
bool castOutputIndex(int &n) const
Definition: masternodeconfig.cpp:89
CMasternode::sig
std::vector< unsigned char > sig
Definition: masternode.h:133
strprintf
#define strprintf
Definition: tinyformat.h:1056
CMasternodeMan::CountNetworks
void CountNetworks(int protocolVersion, int &ipv4, int &ipv6, int &onion)
Definition: masternodeman.cpp:393
CMasternode
Definition: masternode.h:107
CWallet::AvailableCoins
bool AvailableCoins(std::vector< COutput > &vCoins, bool fOnlyConfirmed=true, const CCoinControl *coinControl=NULL, bool fIncludeZeroValue=false, AvailableCoinsType nCoinType=ALL_COINS, bool fUseIX=false)
populate vCoins with vector of available COutputs.
Definition: wallet.cpp:2490
getseesawrewardratio
UniValue getseesawrewardratio(const UniValue &params, bool fHelp)
Definition: masternode.cpp:924
UniValue::get_int
int get_int() const
Definition: univalue.cpp:316
CKey
An encapsulated private key.
Definition: key.h:39
CActiveMasternode::service
CService service
Definition: activemasternode.h:45
utilmoneystr.h
CTxIn::ToString
std::string ToString() const
Definition: transaction.cpp:50
fReindex
std::atomic< bool > fReindex
Definition: main.cpp:81
main.h
COutPoint::n
uint32_t n
Definition: transaction.h:40
CMasternodeConfig::CMasternodeEntry::getIp
const std::string & getIp() const
Definition: masternodeconfig.h:83
EnsureWalletIsUnlocked
void EnsureWalletIsUnlocked(bool fAllowAnonOnly=false)
Definition: rpcwallet.cpp:45
CMasternode::GetLastPaid
int64_t GetLastPaid()
Definition: masternode.cpp:259
LOCK
#define LOCK(cs)
Definition: sync.h:182
CScript::ToString
std::string ToString() const
Definition: script.cpp:266
DecodeHexMnb
bool DecodeHexMnb(CMasternodeBroadcast &mnb, std::string strHexMnb)
Definition: masternode.cpp:954
CWalletTx
A transaction with a bunch of additional info that only the owner cares about.
Definition: wallet.h:792
CMasternodeConfig::CMasternodeEntry
Definition: masternodeconfig.h:22
CTxIn::prevout
COutPoint prevout
Definition: transaction.h:86
SerializeMNB
void SerializeMNB(UniValue &statusObjRet, const CMasternodeBroadcast &mnb, const bool fSuccess, int &successful, int &failed)
Definition: masternode.cpp:348
CTxIn::scriptSig
CScript scriptSig
Definition: transaction.h:87
UniValue::push_back
bool push_back(const UniValue &val)
Definition: univalue.cpp:173
Params
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:463
CActiveMasternode::GetStatus
int GetStatus() const
Definition: activemasternode.h:51
GetBlockValue
CAmount GetBlockValue(int nHeight)
Definition: main.cpp:2158
CDataStream
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:34
UniValue::size
size_t size() const
Definition: univalue.h:69
CMasternode::IsEnabled
bool IsEnabled()
Definition: masternode.h:242
COutPoint::ToString
std::string ToString() const
Definition: transaction.cpp:21
CTransaction::GetHash
const uint256 & GetHash() const
Definition: transaction.h:342
netbase.h
GetNetworkName
std::string GetNetworkName(enum Network net)
Definition: netbase.cpp:60
COutPoint
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:36
CChain::Tip
CBlockIndex * Tip(bool fProofOfStake=false) const
Returns the index entry for the tip of this chain, or NULL if none.
Definition: chain.h:596
CMasternodeConfig::CMasternodeEntry::getOutputIndex
const std::string & getOutputIndex() const
Definition: masternodeconfig.h:51
CMasternodePing::vchSig
std::vector< unsigned char > vchSig
Definition: masternode.h:45
ACTIVE_MASTERNODE_STARTED
#define ACTIVE_MASTERNODE_STARTED
Definition: activemasternode.h:20
UniValue::VARR
@ VARR
Definition: univalue.h:21
server.h
CBlockIndex
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:162
CMasternodeBroadcast
Definition: masternode.h:292
pwalletMain
CWallet * pwalletMain
Definition: wallet.cpp:49
COutput
Definition: wallet.h:922
MASTERNODE_SYNC_LIST
#define MASTERNODE_SYNC_LIST
Definition: masternode-sync.h:11
CMasternodeBroadcast::VerifySignature
bool VerifySignature()
Definition: masternode.cpp:720
CMasternode::protocolVersion
int protocolVersion
Definition: masternode.h:140
masternodeconfig.h
CMasternodePing
Definition: masternode.h:39
CWallet::getCTxOutValue
CAmount getCTxOutValue(const CTransaction &tx, const CTxOut &out) const
Definition: wallet.cpp:7202
CMasternode::pubKeyCollateralAddress
CPubKey pubKeyCollateralAddress
Definition: masternode.h:129
CMasternode::lastPing
CMasternodePing lastPing
Definition: masternode.h:145
CPubKey::GetID
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition: pubkey.h:143
CMasternodePing::vin
CTxIn vin
Definition: masternode.h:42
CMasternodeConfig::getEntries
std::vector< CMasternodeEntry > & getEntries()
Definition: masternodeconfig.h:103
base_uint::ToString
std::string ToString() const
Definition: arith_uint256.cpp:199
Generated on Tue Apr 28 2026 00:02:52 for PRCYCoin by   doxygen 1.8.17