PIVX Core  5.6.99
P2P Digital Currency
rpc_tests.cpp
Go to the documentation of this file.
1 // Copyright (c) 2012-2013 The Bitcoin Core developers
2 // Copyright (c) 2017-2021 The PIVX Core 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 "rpc/server.h"
7 #include "rpc/client.h"
8 
9 #include "netbase.h"
10 #include "util/system.h"
11 
12 #include "test/test_pivx.h"
13 
14 #include <boost/algorithm/string.hpp>
15 #include <boost/test/unit_test.hpp>
16 
17 #include <univalue.h>
18 
19 
20 UniValue
21 createArgs(int nRequired, const char* address1=nullptr, const char* address2=nullptr)
22 {
23  UniValue result(UniValue::VARR);
24  result.push_back(nRequired);
25  UniValue addresses(UniValue::VARR);
26  if (address1) addresses.push_back(address1);
27  if (address2) addresses.push_back(address2);
28  result.push_back(addresses);
29  return result;
30 }
31 
32 UniValue CallRPC(std::string args)
33 {
34  std::vector<std::string> vArgs;
35  boost::split(vArgs, args, boost::is_any_of(" \t"));
36  std::string strMethod = vArgs[0];
37  vArgs.erase(vArgs.begin());
38  JSONRPCRequest request;
39  request.strMethod = strMethod;
40  request.params = RPCConvertValues(strMethod, vArgs);
41  request.fHelp = false;
42  BOOST_CHECK(tableRPC[strMethod]);
43  rpcfn_type method = tableRPC[strMethod]->actor;
44  try {
45  UniValue result = (*method)(request);
46  return result;
47  }
48  catch (const UniValue& objError) {
49  throw std::runtime_error(find_value(objError, "message").get_str());
50  }
51 }
52 
53 
54 BOOST_FIXTURE_TEST_SUITE(rpc_tests, TestingSetup)
55 
56 BOOST_AUTO_TEST_CASE(rpc_rawparams)
57 {
58  // Test raw transaction API argument handling
59  UniValue r;
60 
61  BOOST_CHECK_THROW(CallRPC("getrawtransaction"), std::runtime_error);
62  BOOST_CHECK_THROW(CallRPC("getrawtransaction not_hex"), std::runtime_error);
63  BOOST_CHECK_THROW(CallRPC("getrawtransaction a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed not_int"), std::runtime_error);
64 
65  BOOST_CHECK_THROW(CallRPC("createrawtransaction"), std::runtime_error);
66  BOOST_CHECK_THROW(CallRPC("createrawtransaction null null"), std::runtime_error);
67  BOOST_CHECK_THROW(CallRPC("createrawtransaction not_array"), std::runtime_error);
68  BOOST_CHECK_THROW(CallRPC("createrawtransaction [] []"), std::runtime_error);
69  BOOST_CHECK_THROW(CallRPC("createrawtransaction {} {}"), std::runtime_error);
70  BOOST_CHECK_NO_THROW(CallRPC("createrawtransaction [] {}"));
71  BOOST_CHECK_THROW(CallRPC("createrawtransaction [] {} extra"), std::runtime_error);
72 
73  BOOST_CHECK_THROW(CallRPC("decoderawtransaction"), std::runtime_error);
74  BOOST_CHECK_THROW(CallRPC("decoderawtransaction null"), std::runtime_error);
75  BOOST_CHECK_THROW(CallRPC("decoderawtransaction DEADBEEF"), std::runtime_error);
76  std::string rawtx = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
77  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("decoderawtransaction ")+rawtx));
78  BOOST_CHECK_EQUAL(find_value(r.get_obj(), "version").get_int(), 1);
79  BOOST_CHECK_EQUAL(find_value(r.get_obj(), "locktime").get_int(), 0);
80  BOOST_CHECK_THROW(r = CallRPC(std::string("decoderawtransaction ")+rawtx+" extra"), std::runtime_error);
81 
82  BOOST_CHECK_THROW(CallRPC("signrawtransaction"), std::runtime_error);
83  BOOST_CHECK_THROW(CallRPC("signrawtransaction null"), std::runtime_error);
84  BOOST_CHECK_THROW(CallRPC("signrawtransaction ff00"), std::runtime_error);
85  BOOST_CHECK_NO_THROW(CallRPC(std::string("signrawtransaction ")+rawtx));
86  BOOST_CHECK_NO_THROW(CallRPC(std::string("signrawtransaction ")+rawtx+" null null NONE|ANYONECANPAY"));
87  BOOST_CHECK_NO_THROW(CallRPC(std::string("signrawtransaction ")+rawtx+" [] [] NONE|ANYONECANPAY"));
88  BOOST_CHECK_THROW(CallRPC(std::string("signrawtransaction ")+rawtx+" null null badenum"), std::runtime_error);
89 
90  // Only check failure cases for sendrawtransaction, there's no network to send to...
91  BOOST_CHECK_THROW(CallRPC("sendrawtransaction"), std::runtime_error);
92  BOOST_CHECK_THROW(CallRPC("sendrawtransaction null"), std::runtime_error);
93  BOOST_CHECK_THROW(CallRPC("sendrawtransaction DEADBEEF"), std::runtime_error);
94  BOOST_CHECK_THROW(CallRPC(std::string("sendrawtransaction ")+rawtx+" extra"), std::runtime_error);
95 }
96 
97 BOOST_AUTO_TEST_CASE(rpc_togglenetwork)
98 {
99  UniValue r;
100 
101  r = CallRPC("getnetworkinfo");
102  bool netState = find_value(r.get_obj(), "networkactive").get_bool();
103  BOOST_CHECK_EQUAL(netState, true);
104 
105  BOOST_CHECK_NO_THROW(CallRPC("setnetworkactive false"));
106  r = CallRPC("getnetworkinfo");
107  int numConnection = find_value(r.get_obj(), "connections").get_int();
108  BOOST_CHECK_EQUAL(numConnection, 0);
109 
110  netState = find_value(r.get_obj(), "networkactive").get_bool();
111  BOOST_CHECK_EQUAL(netState, false);
112 
113  BOOST_CHECK_NO_THROW(CallRPC("setnetworkactive true"));
114  r = CallRPC("getnetworkinfo");
115  netState = find_value(r.get_obj(), "networkactive").get_bool();
116  BOOST_CHECK_EQUAL(netState, true);
117 }
118 
119 BOOST_AUTO_TEST_CASE(rpc_rawsign)
120 {
121  UniValue r;
122  // input is a 1-of-2 multisig (so is output):
123  std::string prevout =
124  "[{\"txid\":\"dd2888870cdc3f6e92661f6b0829667ee4bb07ed086c44205e726bbf3338f726\","
125  "\"vout\":1,\"scriptPubKey\":\"a914f5404a39a4799d8710e15db4c4512c5e06f97fed87\","
126  "\"redeemScript\":\"5121021431a18c7039660cd9e3612a2a47dc53b69cb38ea4ad743b7df8245fd0438f8e21029bbeff390ce736bd396af43b52a1c14ed52c086b1e5585c15931f68725772bac52ae\"}]";
127  r = CallRPC(std::string("createrawtransaction ")+prevout+" "+
128  "{\"6ckcNMWRYgTnPcrTXCdwhDnMLwj3zwseej\":1}");
129  std::string notsigned = r.get_str();
130  std::string privkey1 = "\"YVobcS47fr6kceZy9LzLJR8WQ6YRpUwYKoJhrnEXepebMxaSpbnn\"";
131  std::string privkey2 = "\"YRyMjG8hbm8jHeDMAfrzSeHq5GgAj7kuHFvJtMudCUH3sCkq1WtA\"";
132  r = CallRPC(std::string("signrawtransaction ")+notsigned+" "+prevout+" "+"[]");
133  BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == false);
134  r = CallRPC(std::string("signrawtransaction ")+notsigned+" "+prevout+" "+"["+privkey1+","+privkey2+"]");
135  BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == true);
136 }
137 
138 BOOST_AUTO_TEST_CASE(rpc_format_monetary_values)
139 {
140  BOOST_CHECK(ValueFromAmount(0LL).write() == "0.00000000");
141  BOOST_CHECK(ValueFromAmount(1LL).write() == "0.00000001");
142  BOOST_CHECK(ValueFromAmount(17622195LL).write() == "0.17622195");
143  BOOST_CHECK(ValueFromAmount(50000000LL).write() == "0.50000000");
144  BOOST_CHECK(ValueFromAmount(89898989LL).write() == "0.89898989");
145  BOOST_CHECK(ValueFromAmount(100000000LL).write() == "1.00000000");
146  BOOST_CHECK(ValueFromAmount(2099999999999990LL).write() == "20999999.99999990");
147  BOOST_CHECK(ValueFromAmount(2099999999999999LL).write() == "20999999.99999999");
148 
149  BOOST_CHECK_EQUAL(ValueFromAmount(0).write(), "0.00000000");
150  BOOST_CHECK_EQUAL(ValueFromAmount((COIN/10000)*123456789).write(), "12345.67890000");
151  BOOST_CHECK_EQUAL(ValueFromAmount(-COIN).write(), "-1.00000000");
152  BOOST_CHECK_EQUAL(ValueFromAmount(-COIN/10).write(), "-0.10000000");
153 
154  BOOST_CHECK_EQUAL(ValueFromAmount(COIN*100000000).write(), "100000000.00000000");
155  BOOST_CHECK_EQUAL(ValueFromAmount(COIN*10000000).write(), "10000000.00000000");
156  BOOST_CHECK_EQUAL(ValueFromAmount(COIN*1000000).write(), "1000000.00000000");
157  BOOST_CHECK_EQUAL(ValueFromAmount(COIN*100000).write(), "100000.00000000");
158  BOOST_CHECK_EQUAL(ValueFromAmount(COIN*10000).write(), "10000.00000000");
159  BOOST_CHECK_EQUAL(ValueFromAmount(COIN*1000).write(), "1000.00000000");
160  BOOST_CHECK_EQUAL(ValueFromAmount(COIN*100).write(), "100.00000000");
161  BOOST_CHECK_EQUAL(ValueFromAmount(COIN*10).write(), "10.00000000");
162  BOOST_CHECK_EQUAL(ValueFromAmount(COIN).write(), "1.00000000");
163  BOOST_CHECK_EQUAL(ValueFromAmount(COIN/10).write(), "0.10000000");
164  BOOST_CHECK_EQUAL(ValueFromAmount(COIN/100).write(), "0.01000000");
165  BOOST_CHECK_EQUAL(ValueFromAmount(COIN/1000).write(), "0.00100000");
166  BOOST_CHECK_EQUAL(ValueFromAmount(COIN/10000).write(), "0.00010000");
167  BOOST_CHECK_EQUAL(ValueFromAmount(COIN/100000).write(), "0.00001000");
168  BOOST_CHECK_EQUAL(ValueFromAmount(COIN/1000000).write(), "0.00000100");
169  BOOST_CHECK_EQUAL(ValueFromAmount(COIN/10000000).write(), "0.00000010");
170  BOOST_CHECK_EQUAL(ValueFromAmount(COIN/100000000).write(), "0.00000001");
171 }
172 
173 static UniValue ValueFromString(const std::string &str)
174 {
175  UniValue value;
176  BOOST_CHECK(value.setNumStr(str));
177  return value;
178 }
179 
180 BOOST_AUTO_TEST_CASE(rpc_parse_monetary_values)
181 {
182  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000001")), 1LL);
183  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.17622195")), 17622195LL);
184  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.5")), 50000000LL);
185  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.50000000")), 50000000LL);
186  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.89898989")), 89898989LL);
187  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("1.00000000")), 100000000LL);
188  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("20999999.9999999")), 2099999999999990LL);
189  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("20999999.99999999")), 2099999999999999LL);
190 
191  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("1e-8")), COIN/100000000);
192  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.1e-7")), COIN/100000000);
193  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.01e-6")), COIN/100000000);
194  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.0000000000000000000000000000000000000000000000000000000000000000000000000001e+68")), COIN/100000000);
195  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("10000000000000000000000000000000000000000000000000000000000000000e-64")), COIN);
196  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000e64")), COIN);
197 
198  BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e-9")), UniValue); //should fail
199  BOOST_CHECK_THROW(AmountFromValue(ValueFromString("0.000000019")), UniValue); //should fail
200  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000001000000")), 1LL); //should pass, cut trailing 0
201  BOOST_CHECK_THROW(AmountFromValue(ValueFromString("19e-9")), UniValue); //should fail
202  BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.19e-6")), 19); //should pass, leading 0 is present
203 
204  BOOST_CHECK_THROW(AmountFromValue(ValueFromString("92233720368.54775808")), UniValue); //overflow error
205  BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e+11")), UniValue); //overflow error
206  BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e11")), UniValue); //overflow error signless
207  BOOST_CHECK_THROW(AmountFromValue(ValueFromString("93e+9")), UniValue); //overflow error
208 }
209 
210 BOOST_AUTO_TEST_CASE(json_parse_errors)
211 {
212  // Valid
213  BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0").get_real(), 1.0);
214  // Valid, with leading or trailing whitespace
215  BOOST_CHECK_EQUAL(ParseNonRFCJSONValue(" 1.0").get_real(), 1.0);
216  BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0 ").get_real(), 1.0);
217  // Invalid, initial garbage
218  BOOST_CHECK_THROW(ParseNonRFCJSONValue("[1.0"), std::runtime_error);
219  BOOST_CHECK_THROW(ParseNonRFCJSONValue("a1.0"), std::runtime_error);
220  // Invalid, trailing garbage
221  BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0sds"), std::runtime_error);
222  BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0]"), std::runtime_error);
223  // BTC addresses should fail parsing
224  BOOST_CHECK_THROW(ParseNonRFCJSONValue("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"), std::runtime_error);
225  BOOST_CHECK_THROW(ParseNonRFCJSONValue("3J98t1WpEZ73CNmQviecrnyiWrnqRhWNL"), std::runtime_error);
226 }
227 
228 BOOST_AUTO_TEST_CASE(rpc_ban)
229 {
230  BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
231 
232  UniValue r;
233  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0 add")));
234  BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.0:8334")), std::runtime_error); //portnumber for setban not allowed
235  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
236  UniValue ar = r.get_array();
237  UniValue o1 = ar[0].get_obj();
238  UniValue adr = find_value(o1, "address");
239  BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/32");
240  BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0 remove")));;
241  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
242  ar = r.get_array();
243  BOOST_CHECK_EQUAL(ar.size(), 0);
244 
245  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/24 add 9907731200 true")));
246  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
247  ar = r.get_array();
248  o1 = ar[0].get_obj();
249  adr = find_value(o1, "address");
250  UniValue banned_until = find_value(o1, "banned_until");
251  BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
252  BOOST_CHECK_EQUAL(banned_until.get_int64(), 9907731200); // absolute time check
253 
254  BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
255 
256  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/24 add 200")));
257  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
258  ar = r.get_array();
259  o1 = ar[0].get_obj();
260  adr = find_value(o1, "address");
261  banned_until = find_value(o1, "banned_until");
262  BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
263  int64_t now = GetTime();
264  BOOST_CHECK(banned_until.get_int64() > now);
265  BOOST_CHECK(banned_until.get_int64()-now <= 200);
266 
267  // must throw an exception because 127.0.0.1 is in already banned suubnet range
268  BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.1 add")), std::runtime_error);
269 
270  BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0/24 remove")));;
271  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
272  ar = r.get_array();
273  BOOST_CHECK_EQUAL(ar.size(), 0);
274 
275  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/255.255.0.0 add")));
276  BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.1.1 add")), std::runtime_error);
277 
278  BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
279  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
280  ar = r.get_array();
281  BOOST_CHECK_EQUAL(ar.size(), 0);
282 
283  BOOST_CHECK_THROW(r = CallRPC(std::string("setban test add")), std::runtime_error); //invalid IP
284 
285  //IPv6 tests
286  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban FE80:0000:0000:0000:0202:B3FF:FE1E:8329 add")));
287  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
288  ar = r.get_array();
289  o1 = ar[0].get_obj();
290  adr = find_value(o1, "address");
291  BOOST_CHECK_EQUAL(adr.get_str(), "fe80::202:b3ff:fe1e:8329/128");
292 
293  BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
294  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 2001:db8::/ffff:fffc:0:0:0:0:0:0 add")));
295  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
296  ar = r.get_array();
297  o1 = ar[0].get_obj();
298  adr = find_value(o1, "address");
299  BOOST_CHECK_EQUAL(adr.get_str(), "2001:db8::/30");
300 
301  BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
302  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128 add")));
303  BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
304  ar = r.get_array();
305  o1 = ar[0].get_obj();
306  adr = find_value(o1, "address");
307  BOOST_CHECK_EQUAL(adr.get_str(), "2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128");
308 }
309 
310 BOOST_AUTO_TEST_SUITE_END()
JSONRPCRequest::params
UniValue params
Definition: server.h:47
JSONRPCRequest::strMethod
std::string strMethod
Definition: server.h:46
JSONRPCRequest::fHelp
bool fHelp
Definition: server.h:48
UniValue::setNumStr
bool setNumStr(const std::string &val)
Definition: univalue.cpp:46
UniValue::get_str
const std::string & get_str() const
Definition: univalue_get.cpp:97
UniValue::VARR
@ VARR
Definition: univalue.h:21
UniValue::get_int64
int64_t get_int64() const
Definition: univalue_get.cpp:114
UniValue::get_obj
const UniValue & get_obj() const
Definition: univalue_get.cpp:134
UniValue::size
size_t size() const
Definition: univalue.h:68
UniValue::push_back
bool push_back(const UniValue &val)
Definition: univalue.cpp:108
UniValue::get_array
const UniValue & get_array() const
Definition: univalue_get.cpp:141
UniValue::get_bool
bool get_bool() const
Definition: univalue_get.cpp:90
UniValue::get_int
int get_int() const
Definition: univalue_get.cpp:104
ParseNonRFCJSONValue
UniValue ParseNonRFCJSONValue(const std::string &strVal)
Non-RFC4627 JSON parser, accepts internal values (such as numbers, true, false, null) as well as obje...
Definition: client.cpp:241
RPCConvertValues
UniValue RPCConvertValues(const std::string &strMethod, const std::vector< std::string > &strParams)
Convert positional arguments to command-specific RPC representation.
Definition: client.cpp:250
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
BOOST_CHECK_THROW
#define BOOST_CHECK_THROW(stmt, excMatch)
Definition: object.cpp:19
BOOST_FIXTURE_TEST_SUITE
#define BOOST_FIXTURE_TEST_SUITE(a, b)
Definition: object.cpp:14
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
BOOST_CHECK_NO_THROW
#define BOOST_CHECK_NO_THROW(stmt)
Definition: object.cpp:28
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
CallRPC
UniValue CallRPC(std::string args)
Definition: rpc_tests.cpp:32
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(rpc_rawparams)
Definition: rpc_tests.cpp:56
createArgs
UniValue createArgs(int nRequired, const char *address1=nullptr, const char *address2=nullptr)
Definition: rpc_tests.cpp:21
ValueFromAmount
UniValue ValueFromAmount(const CAmount &amount)
Definition: server.cpp:128
AmountFromValue
CAmount AmountFromValue(const UniValue &value)
Definition: server.cpp:116
tableRPC
CRPCTable tableRPC
Definition: server.cpp:565
rpcfn_type
UniValue(* rpcfn_type)(const JSONRPCRequest &jsonRequest)
Definition: server.h:131
test_pivx.h
find_value
const UniValue & find_value(const UniValue &obj, const std::string &name)
Definition: univalue.cpp:234
GetTime
int64_t GetTime()
DEPRECATED Use either GetSystemTimeInSeconds (not mockable) or GetTime<T> (mockable)
Definition: utiltime.cpp:27
Generated on Wed Apr 2 2025 00:40:37 for PIVX Core by doxygen 1.9.1