Inside Bitcoin

251
252    // Key not "data" (bad address)
253    BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"somedata\":\"68656c6c6f776f726c64\"}"), std::runtime_error);
254
255    // Bad hex encoding of data output
256    BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"12345\"}"), std::runtime_error);
257    BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"12345g\"}"), std::runtime_error);
258
259    // Data 81 bytes long
260    BOOST_CHECK_NO_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081\"}"));
261}
262
263BOOST_AUTO_TEST_CASE(rpc_format_monetary_values)
264{
265    BOOST_CHECK(ValueFromAmount(0LL).write() == "0.00000000");
266    BOOST_CHECK(ValueFromAmount(1LL).write() == "0.00000001");
267    BOOST_CHECK(ValueFromAmount(17622195LL).write() == "0.17622195");
268    BOOST_CHECK(ValueFromAmount(50000000LL).write() == "0.50000000");
269    BOOST_CHECK(ValueFromAmount(89898989LL).write() == "0.89898989");
270    BOOST_CHECK(ValueFromAmount(100000000LL).write() == "1.00000000");
271    BOOST_CHECK(ValueFromAmount(2099999999999990LL).write() == "20999999.99999990");
272    BOOST_CHECK(ValueFromAmount(2099999999999999LL).write() == "20999999.99999999");
273
274    BOOST_CHECK_EQUAL(ValueFromAmount(0).write(), "0.00000000");
275    BOOST_CHECK_EQUAL(ValueFromAmount((COIN/10000)*123456789).write(), "12345.67890000");
276    BOOST_CHECK_EQUAL(ValueFromAmount(-COIN).write(), "-1.00000000");
277    BOOST_CHECK_EQUAL(ValueFromAmount(-COIN/10).write(), "-0.10000000");
278
279    BOOST_CHECK_EQUAL(ValueFromAmount(COIN*100000000).write(), "100000000.00000000");
280    BOOST_CHECK_EQUAL(ValueFromAmount(COIN*10000000).write(), "10000000.00000000");
281    BOOST_CHECK_EQUAL(ValueFromAmount(COIN*1000000).write(), "1000000.00000000");
282    BOOST_CHECK_EQUAL(ValueFromAmount(COIN*100000).write(), "100000.00000000");
283    BOOST_CHECK_EQUAL(ValueFromAmount(COIN*10000).write(), "10000.00000000");
284    BOOST_CHECK_EQUAL(ValueFromAmount(COIN*1000).write(), "1000.00000000");
285    BOOST_CHECK_EQUAL(ValueFromAmount(COIN*100).write(), "100.00000000");
286    BOOST_CHECK_EQUAL(ValueFromAmount(COIN*10).write(), "10.00000000");
287    BOOST_CHECK_EQUAL(ValueFromAmount(COIN).write(), "1.00000000");
288    BOOST_CHECK_EQUAL(ValueFromAmount(COIN/10).write(), "0.10000000");
289    BOOST_CHECK_EQUAL(ValueFromAmount(COIN/100).write(), "0.01000000");
290    BOOST_CHECK_EQUAL(ValueFromAmount(COIN/1000).write(), "0.00100000");
291    BOOST_CHECK_EQUAL(ValueFromAmount(COIN/10000).write(), "0.00010000");
292    BOOST_CHECK_EQUAL(ValueFromAmount(COIN/100000).write(), "0.00001000");
293    BOOST_CHECK_EQUAL(ValueFromAmount(COIN/1000000).write(), "0.00000100");
294    BOOST_CHECK_EQUAL(ValueFromAmount(COIN/10000000).write(), "0.00000010");
295    BOOST_CHECK_EQUAL(ValueFromAmount(COIN/100000000).write(), "0.00000001");
296
297    BOOST_CHECK_EQUAL(ValueFromAmount(std::numeric_limits<CAmount>::max()).write(), "92233720368.54775807");
298    BOOST_CHECK_EQUAL(ValueFromAmount(std::numeric_limits<CAmount>::max() - 1).write(), "92233720368.54775806");
299    BOOST_CHECK_EQUAL(ValueFromAmount(std::numeric_limits<CAmount>::max() - 2).write(), "92233720368.54775805");
300    BOOST_CHECK_EQUAL(ValueFromAmount(std::numeric_limits<CAmount>::max() - 3).write(), "92233720368.54775804");
301    // ...
302    BOOST_CHECK_EQUAL(ValueFromAmount(std::numeric_limits<CAmount>::min() + 3).write(), "-92233720368.54775805");
303    BOOST_CHECK_EQUAL(ValueFromAmount(std::numeric_limits<CAmount>::min() + 2).write(), "-92233720368.54775806");
304    BOOST_CHECK_EQUAL(ValueFromAmount(std::numeric_limits<CAmount>::min() + 1).write(), "-92233720368.54775807");
305    BOOST_CHECK_EQUAL(ValueFromAmount(std::numeric_limits<CAmount>::min()).write(), "-92233720368.54775808");
306}
307
308static UniValue ValueFromString(const std::string& str) noexcept
309{
310    UniValue value;
311    value.setNumStr(str);
312    return value;
313}
314
315BOOST_AUTO_TEST_CASE(rpc_parse_monetary_values)
316{
317    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("-0.00000001")), UniValue);
318    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0")), 0LL);
319    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000000")), 0LL);
320    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000001")), 1LL);
321    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.17622195")), 17622195LL);
322    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.5")), 50000000LL);
323    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.50000000")), 50000000LL);
324    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.89898989")), 89898989LL);
325    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("1.00000000")), 100000000LL);
326    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("20999999.9999999")), 2099999999999990LL);
327    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("20999999.99999999")), 2099999999999999LL);
328
329    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("1e-8")), COIN/100000000);
330    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.1e-7")), COIN/100000000);
331    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.01e-6")), COIN/100000000);
332    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000000000000000000000000000000000001e+30")), 1);
333    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.0000000000000000000000000000000000000000000000000000000000000000000000000001e+68")), COIN/100000000);
334    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("10000000000000000000000000000000000000000000000000000000000000000e-64")), COIN);
335    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000e64")), COIN);
336
337    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e-9")), UniValue); //should fail
338    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("0.000000019")), UniValue); //should fail
339    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000001000000")), 1LL); //should pass, cut trailing 0
340    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("19e-9")), UniValue); //should fail
341    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.19e-6")), 19); //should pass, leading 0 is present
342    BOOST_CHECK_EXCEPTION(AmountFromValue(".19e-6"), UniValue, HasJSON(R"({"code":-3,"message":"Invalid amount"})")); //should fail, no leading 0
343
344    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("92233720368.54775808")), UniValue); //overflow error
345    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e+11")), UniValue); //overflow error
346    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e11")), UniValue); //overflow error signless
347    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("93e+9")), UniValue); //overflow error
348}
349
350BOOST_AUTO_TEST_CASE(rpc_ban)
351{
352    BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
353
354    UniValue r;
355    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0 add")));
356    BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.0:8334")), std::runtime_error); //portnumber for setban not allowed
357    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
358    UniValue ar = r.get_array();
359    UniValue o1 = ar[0].get_obj();
360    UniValue adr = o1.find_value("address");
361    BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/32");
362    BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0 remove")));
363    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
364    ar = r.get_array();
365    BOOST_CHECK_EQUAL(ar.size(), 0U);
366
367    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/24 add 9907731200 true")));
368    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
369    ar = r.get_array();
370    o1 = ar[0].get_obj();
371    adr = o1.find_value("address");
372    int64_t banned_until{o1.find_value("banned_until").getInt<int64_t>()};
373    BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
374    BOOST_CHECK_EQUAL(banned_until, 9907731200); // absolute time check
375
376    BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
377
378    FakeNodeClock clock{10'000s};
379    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/24 add 200")));
380    clock += 2s;
381    const int64_t time_remaining_expected{198};
382    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
383    ar = r.get_array();
384    o1 = ar[0].get_obj();
385    adr = o1.find_value("address");
386    banned_until = o1.find_value("banned_until").getInt<int64_t>();
387    const int64_t ban_created{o1.find_value("ban_created").getInt<int64_t>()};
388    const int64_t ban_duration{o1.find_value("ban_duration").getInt<int64_t>()};
389    const int64_t time_remaining{o1.find_value("time_remaining").getInt<int64_t>()};
390    BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
391    BOOST_CHECK_EQUAL(banned_until, time_remaining_expected + TicksSinceEpoch<std::chrono::seconds>(NodeClock::now()));
392    BOOST_CHECK_EQUAL(ban_duration, banned_until - ban_created);
393    BOOST_CHECK_EQUAL(time_remaining, time_remaining_expected);
394
395    // must throw an exception because 127.0.0.1 is in already banned subnet range
396    BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.1 add")), std::runtime_error);
397
398    BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0/24 remove")));
399    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
400    ar = r.get_array();
401    BOOST_CHECK_EQUAL(ar.size(), 0U);
402
403    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/255.255.0.0 add")));
404    BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.1.1 add")), std::runtime_error);
405
406    BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
407    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
408    ar = r.get_array();
409    BOOST_CHECK_EQUAL(ar.size(), 0U);
410
411
412    BOOST_CHECK_THROW(r = CallRPC(std::string("setban test add")), std::runtime_error); //invalid IP
413
414    //IPv6 tests
415    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban FE80:0000:0000:0000:0202:B3FF:FE1E:8329 add")));
416    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
417    ar = r.get_array();
418    o1 = ar[0].get_obj();
419    adr = o1.find_value("address");
420    BOOST_CHECK_EQUAL(adr.get_str(), "fe80::202:b3ff:fe1e:8329/128");
421
422    BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
423    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 2001:db8::/ffff:fffc:0:0:0:0:0:0 add")));
424    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
425    ar = r.get_array();
426    o1 = ar[0].get_obj();
427    adr = o1.find_value("address");
428    BOOST_CHECK_EQUAL(adr.get_str(), "2001:db8::/30");
429
430    BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
431    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128 add")));
432    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
433    ar = r.get_array();
434    o1 = ar[0].get_obj();
435    adr = o1.find_value("address");
436    BOOST_CHECK_EQUAL(adr.get_str(), "2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128");
437}
438
439BOOST_AUTO_TEST_CASE(rpc_convert_values_generatetoaddress)
440{
441    UniValue result;
442
443    BOOST_CHECK_NO_THROW(result = RPCConvertValues("generatetoaddress", {"101", "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a"}));
444    BOOST_CHECK_EQUAL(result[0].getInt<int>(), 101);
445    BOOST_CHECK_EQUAL(result[1].get_str(), "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a");
446
447    BOOST_CHECK_NO_THROW(result = RPCConvertValues("generatetoaddress", {"101", "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU"}));
448    BOOST_CHECK_EQUAL(result[0].getInt<int>(), 101);
449    BOOST_CHECK_EQUAL(result[1].get_str(), "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU");
450
451    BOOST_CHECK_NO_THROW(result = RPCConvertValues("generatetoaddress", {"1", "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a", "9"}));
452    BOOST_CHECK_EQUAL(result[0].getInt<int>(), 1);
453    BOOST_CHECK_EQUAL(result[1].get_str(), "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a");
454    BOOST_CHECK_EQUAL(result[2].getInt<int>(), 9);
455
456    BOOST_CHECK_NO_THROW(result = RPCConvertValues("generatetoaddress", {"1", "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU", "9"}));
457    BOOST_CHECK_EQUAL(result[0].getInt<int>(), 1);
458    BOOST_CHECK_EQUAL(result[1].get_str(), "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU");
459    BOOST_CHECK_EQUAL(result[2].getInt<int>(), 9);
460}
461
462BOOST_AUTO_TEST_CASE(rpc_getblockstats_calculate_percentiles_by_weight)
463{
464    int64_t total_weight = 200;
465    std::vector<std::pair<CAmount, int64_t>> feerates;
466    feerates.reserve(200);
467    CAmount result[NUM_GETBLOCKSTATS_PERCENTILES] = { 0 };
468
469    for (int64_t i = 0; i < 100; i++) {
470        feerates.emplace_back(1 ,1);
471    }
472
473    for (int64_t i = 0; i < 100; i++) {
474        feerates.emplace_back(2 ,1);
475    }
476
477    CalculatePercentilesByWeight(result, feerates, total_weight);
478    BOOST_CHECK_EQUAL(result[0], 1);
479    BOOST_CHECK_EQUAL(result[1], 1);
480    BOOST_CHECK_EQUAL(result[2], 1);
481    BOOST_CHECK_EQUAL(result[3], 2);
482    BOOST_CHECK_EQUAL(result[4], 2);
483
484    // Test with more pairs, and two pairs overlapping 2 percentiles.
485    total_weight = 100;
486    CAmount result2[NUM_GETBLOCKSTATS_PERCENTILES] = { 0 };
487    feerates.clear();
488
489    feerates.emplace_back(1, 9);
490    feerates.emplace_back(2 , 16); //10th + 25th percentile
491    feerates.emplace_back(4 ,50); //50th + 75th percentile
492    feerates.emplace_back(5 ,10);
493    feerates.emplace_back(9 ,15);  // 90th percentile
494
495    CalculatePercentilesByWeight(result2, feerates, total_weight);
496
497    BOOST_CHECK_EQUAL(result2[0], 2);
498    BOOST_CHECK_EQUAL(result2[1], 2);
499    BOOST_CHECK_EQUAL(result2[2], 4);
500    BOOST_CHECK_EQUAL(result2[3], 4);